Función SQLBulkOperations

Conformidad
Versión introducida: Cumplimiento de estándares ODBC 3.0: ODBC

Resumen
SQLBulkOperations realiza inserciones masivas y operaciones masivas de marcadores, incluidas las operaciones de actualización, eliminación y captura por marcador.

Sintaxis

  
SQLRETURN SQLBulkOperations(  
     SQLHSTMT       StatementHandle,  
     SQLUSMALLINT   Operation);  

Argumentos

StatementHandle
[Entrada] Identificador de instrucción.

operación
[Entrada] Operación que se va a realizar:

SQL_ADD SQL_UPDATE_BY_BOOKMARK SQL_DELETE_BY_BOOKMARK SQL_FETCH_BY_BOOKMARK

Para obtener más información, vea "Comentarios".

Devoluciones

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NEED_DATA, SQL_STILL_EXECUTING, SQL_ERROR o SQL_INVALID_HANDLE.

Diagnóstico

Cuando SQLBulkOperations devuelve SQL_ERROR o SQL_SUCCESS_WITH_INFO, se puede obtener un valor SQLSTATE asociado mediante una llamada a SQLGetDiagRec con un HandleType de SQL_HANDLE_STMT y un identificador de StatementHandle. En la tabla siguiente se enumeran los valores SQLSTATE devueltos normalmente por SQLBulkOperations y se explica cada uno en el contexto de esta función; la notación "(DM)" precede a las descripciones de SQLSTATEs devueltas por el Administrador de controladores. El código de retorno asociado a cada valor SQLSTATE es SQL_ERROR, a menos que se indique lo contrario.

Para todos esos SQLSTATEs que pueden devolver SQL_SUCCESS_WITH_INFO o SQL_ERROR (excepto 01xxx SQLSTATEs), se devuelve SQL_SUCCESS_WITH_INFO si se produce un error en una o varias filas de una operación de varias filas, pero no todas, y SQL_ERROR se devuelve si se produce un error en una operación de fila única.

Comentarios

Una aplicación usa SQLBulkOperations para realizar las siguientes operaciones en la tabla base o vista que corresponde a la consulta actual:

• Agregue nuevas filas.

• Actualice un conjunto de filas donde un marcador identifica cada fila.

• Elimine un conjunto de filas donde un marcador identifica cada fila.

• Capturar un conjunto de filas donde un marcador identifica cada fila.

Después de una llamada a SQLBulkOperations, la posición del cursor de bloque no está definida. La aplicación tiene que llamar a SQLFetchScroll para establecer la posición del cursor. Una aplicación solo debe llamar a SQLFetchScroll con un argumento FetchOrientation de SQL_FETCH_FIRST, SQL_FETCH_LAST, SQL_FETCH_ABSOLUTE o SQL_FETCH_BOOKMARK. La posición del cursor no está definida si la aplicación llama a SQLFetch o SQLFetchScroll con un argumento FetchOrientation de SQL_FETCH_PRIOR, SQL_FETCH_NEXT o SQL_FETCH_RELATIVE.

Una columna se puede omitir en operaciones masivas realizadas por una llamada a SQLBulkOperations estableciendo el búfer de longitud o indicador de columna especificado en la llamada a SQLBindCol, en SQL_COLUMN_IGNORE.

No es necesario que la aplicación establezca el atributo de instrucción SQL_ATTR_ROW_OPERATION_PTR cuando llama a SQLBulkOperations porque las filas no se pueden omitir al realizar operaciones masivas con esta función.

El búfer al que apunta el atributo de instrucción SQL_ATTR_ROWS_FETCHED_PTR contiene el número de filas afectadas por una llamada a SQLBulkOperations.

Cuando el argumento Operation se SQL_ADD o SQL_UPDATE_BY_BOOKMARK y la lista de selección de la especificación de consulta asociada al cursor contiene más de una referencia a la misma columna, se define si se genera un error o el controlador o el controlador omite las referencias duplicadas y realiza las operaciones solicitadas.

Para obtener más información sobre cómo usar SQLBulkOperations, vea Actualizar datos con SQLBulkOperations.

Realización de inserciones masivas

Para insertar datos con SQLBulkOperations, una aplicación realiza la siguiente secuencia de pasos:

1. Ejecuta una consulta que devuelve un conjunto de resultados.

2. Establece el atributo de instrucción SQL_ATTR_ROW_ARRAY_SIZE en el número de filas que desea insertar.

3. Llama a SQLBindCol para enlazar los datos que desea insertar. Los datos se enlazan a una matriz con un tamaño igual al valor de SQL_ATTR_ROW_ARRAY_SIZE.

   Nota

   El tamaño de la matriz a la que apunta el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR debe ser igual a SQL_ATTR_ROW_ARRAY_SIZE o SQL_ATTR_ROW_STATUS_PTR debe ser un puntero nulo.

4. Llama a SQLBulkOperations(StatementHandle, SQL_ADD) para realizar la inserción.

5. Si la aplicación ha establecido el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR, puede inspeccionar esta matriz para ver el resultado de la operación.

Si una aplicación enlaza la columna 0 antes de llamar a SQLBulkOperations con un argumento Operation de SQL_ADD, el controlador actualizará los búferes de la columna enlazada 0 con los valores de marcador para la fila recién insertada. Para que esto ocurra, la aplicación debe haber establecido el atributo de instrucción SQL_ATTR_USE_BOOKMARKS en SQL_UB_VARIABLE antes de ejecutar la instrucción. (Esto no funciona con ODBC 2. controlador x ).

SqlBulkOperations puede agregar datos largos en partes mediante llamadas a SQLParamData y SQLPutData. Para obtener más información, vea "Proporcionar datos largos para inserciones masivas y Novedades" más adelante en esta referencia de función.

No es necesario que la aplicación llame a SQLFetch o SQLFetchScroll antes de llamar a SQLBulkOperations (excepto cuando se contrae a ODBC 2. x driver; consulte Compatibilidad con versiones anteriores y cumplimiento de estándares).

El comportamiento se define por el controlador si SQLBulkOperations, con un argumento Operation de SQL_ADD, se llama a en un cursor que contiene columnas duplicadas. El controlador puede devolver un SQLSTATE definido por el controlador, agregar los datos a la primera columna que aparece en el conjunto de resultados o realizar otro comportamiento definido por el controlador.

Realizar Novedades masiva mediante marcadores

Para realizar actualizaciones masivas mediante marcadores con SQLBulkOperations, una aplicación realiza los pasos siguientes en secuencia:

1. Establece el atributo de instrucción SQL_ATTR_USE_BOOKMARKS en SQL_UB_VARIABLE.

2. Ejecuta una consulta que devuelve un conjunto de resultados.

3. Establece el atributo de instrucción SQL_ATTR_ROW_ARRAY_SIZE en el número de filas que desea actualizar.

4. Llama a SQLBindCol para enlazar los datos que desea actualizar. Los datos se enlazan a una matriz con un tamaño igual al valor de SQL_ATTR_ROW_ARRAY_SIZE. También llama a SQLBindCol para enlazar la columna 0 (la columna de marcador).

5. Copia los marcadores de las filas que le interesan actualizar a la matriz enlazada a la columna 0.

6. Novedades los datos de los búferes enlazados.

   Nota

   El tamaño de la matriz a la que apunta el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR debe ser igual a SQL_ATTR_ROW_ARRAY_SIZE o SQL_ATTR_ROW_STATUS_PTR debe ser un puntero nulo.

7. Llama a SQLBulkOperations(StatementHandle, SQL_UPDATE_BY_BOOKMARK).

   Nota

   Si la aplicación ha establecido el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR, puede inspeccionar esta matriz para ver el resultado de la operación.

8. Opcionalmente, llama a SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK) para capturar datos en los búferes de aplicación enlazados para comprobar que se ha producido la actualización.

9. Si se han actualizado los datos, el controlador cambia el valor de la matriz de estado de fila para las filas adecuadas a SQL_ROW_UPDATED.

Las actualizaciones masivas realizadas por SQLBulkOperations pueden incluir datos largos mediante llamadas a SQLParamData y SQLPutData. Para obtener más información, vea "Proporcionar datos largos para inserciones masivas y Novedades" más adelante en esta referencia de función.

Si los marcadores se conservan entre cursores, la aplicación no necesita llamar a SQLFetch o SQLFetchScroll antes de actualizar por marcadores. Puede usar marcadores almacenados desde un cursor anterior. Si los marcadores no se conservan entre cursores, la aplicación debe llamar a SQLFetch o SQLFetchScroll para recuperar los marcadores.

El comportamiento es definido por el controlador si SQLBulkOperations, con un argumento Operation de SQL_UPDATE_BY_BOOKMARK, se llama a en un cursor que contiene columnas duplicadas. El controlador puede devolver un SQLSTATE definido por el controlador, actualizar la primera columna que aparece en el conjunto de resultados o realizar otro comportamiento definido por el controlador.

Realización de capturas masivas mediante marcadores

Para realizar capturas masivas mediante marcadores con SQLBulkOperations, una aplicación realiza los pasos siguientes en secuencia:

1. Establece el atributo de instrucción SQL_ATTR_USE_BOOKMARKS en SQL_UB_VARIABLE.

2. Ejecuta una consulta que devuelve un conjunto de resultados.

3. Establece el atributo de instrucción SQL_ATTR_ROW_ARRAY_SIZE en el número de filas que desea capturar.

4. Llama a SQLBindCol para enlazar los datos que desea capturar. Los datos se enlazan a una matriz con un tamaño igual al valor de SQL_ATTR_ROW_ARRAY_SIZE. También llama a SQLBindCol para enlazar la columna 0 (la columna de marcador).

5. Copia los marcadores de las filas que está interesado en capturar en la matriz enlazada a la columna 0. (Se supone que la aplicación ya ha obtenido los marcadores por separado).

   Nota

   El tamaño de la matriz a la que apunta el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR debe ser igual a SQL_ATTR_ROW_ARRAY_SIZE o SQL_ATTR_ROW_STATUS_PTR debe ser un puntero nulo.

6. Llama a SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK).

7. Si la aplicación ha establecido el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR, puede inspeccionar esta matriz para ver el resultado de la operación.

Si los marcadores se conservan entre cursores, la aplicación no necesita llamar a SQLFetch o SQLFetchScroll antes de capturar por marcadores. Puede usar marcadores almacenados desde un cursor anterior. Si los marcadores no se conservan entre cursores, la aplicación debe llamar a SQLFetch o SQLFetchScroll una vez para recuperar los marcadores.

Realización de eliminaciones masivas mediante marcadores

Para realizar eliminaciones masivas mediante marcadores con SQLBulkOperations, una aplicación realiza los pasos siguientes en secuencia:

1. Establece el atributo de instrucción SQL_ATTR_USE_BOOKMARKS en SQL_UB_VARIABLE.

2. Ejecuta una consulta que devuelve un conjunto de resultados.

3. Establece el atributo de instrucción SQL_ATTR_ROW_ARRAY_SIZE en el número de filas que desea eliminar.

4. Llama a SQLBindCol para enlazar la columna 0 (la columna de marcador).

5. Copia los marcadores de las filas que está interesado en eliminar en la matriz enlazada a la columna 0.

   Nota

   El tamaño de la matriz a la que apunta el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR debe ser igual a SQL_ATTR_ROW_ARRAY_SIZE o SQL_ATTR_ROW_STATUS_PTR debe ser un puntero nulo.

6. Llama a SQLBulkOperations(StatementHandle, SQL_DELETE_BY_BOOKMARK).

7. Si la aplicación ha establecido el atributo de instrucción SQL_ATTR_ROW_STATUS_PTR, puede inspeccionar esta matriz para ver el resultado de la operación.

Si los marcadores se conservan entre cursores, la aplicación no tiene que llamar a SQLFetch o SQLFetchScroll antes de eliminar por marcadores. Puede usar marcadores almacenados desde un cursor anterior. Si los marcadores no se conservan entre cursores, la aplicación debe llamar a SQLFetch o SQLFetchScroll una vez para recuperar los marcadores.

Proporcionar datos largos para inserciones masivas y Novedades

Se pueden proporcionar datos largos para inserciones masivas y actualizaciones realizadas por llamadas a SQLBulkOperations. Para insertar o actualizar datos largos, una aplicación realiza los pasos siguientes además de los pasos descritos en las secciones "Realizar inserciones masivas" y "Realizar Novedades masivas mediante marcadores" anteriormente en este tema.

1. Cuando enlaza los datos mediante SQLBindCol, la aplicación coloca un valor definido por la aplicación, como el número de columna, en el búfer *TargetValuePtr para las columnas de datos en ejecución. El valor se puede usar más adelante para identificar la columna.

   La aplicación coloca el resultado de la macro SQL_LEN_DATA_AT_EXEC(length) en el búfer *StrLen_or_IndPtr . Si el tipo de datos SQL de la columna es SQL_LONGVARBINARY, SQL_LONGVARCHAR o un tipo de datos específico del origen de datos largo y el controlador devuelve "Y" para el tipo de información de SQL_NEED_LONG_DATA_LEN en SQLGetInfo, la longitud es el número de bytes de datos que se enviarán para el parámetro; de lo contrario, debe ser un valor no negativo y se omite.

2. Cuando se llama a SQLBulkOperations , si hay columnas de datos en ejecución, la función devuelve SQL_NEED_DATA y continúa con el paso 3, que sigue. (Si no hay columnas de datos en ejecución, el proceso se ha completado).

3. La aplicación llama a SQLParamData para recuperar la dirección del búfer *TargetValuePtr para que se procese la primera columna de datos en ejecución. SQLParamData devuelve SQL_NEED_DATA. La aplicación recupera el valor definido por la aplicación del búfer *TargetValuePtr .

   Nota

   Aunque los parámetros de datos en ejecución son similares a las columnas de datos en ejecución, el valor devuelto por SQLParamData es diferente para cada una.

   Las columnas de datos en ejecución son columnas de un conjunto de filas para el que se enviarán datos con SQLPutData cuando se actualice o inserte una fila con SQLBulkOperations. Se enlazan con SQLBindCol. El valor devuelto por SQLParamData es la dirección de la fila en el búfer *TargetValuePtr que se está procesando.

4. La aplicación llama a SQLPutData una o varias veces para enviar datos para la columna. Se necesita más de una llamada si no se puede devolver todo el valor de datos en el búfer *TargetValuePtr especificado en SQLPutData; solo se permiten varias llamadas a SQLPutData para la misma columna cuando se envían datos de caracteres C a una columna con un tipo de datos específico del origen de datos, binario o de caracteres, o al enviar datos binarios de C a una columna con un tipo de datos específico de origen de datos, binarios o caracteres.

5. La aplicación llama a SQLParamData de nuevo para indicar que todos los datos se han enviado para la columna.

   • Si hay más columnas de datos en ejecución, SQLParamData devuelve SQL_NEED_DATA y la dirección del búfer TargetValuePtr para la siguiente columna de datos en ejecución que se va a procesar. La aplicación repite los pasos 4 y 5.

   • Si no hay más columnas de datos en ejecución, el proceso se completa. Si la instrucción se ejecutó correctamente, SQLParamData devuelve SQL_SUCCESS o SQL_SUCCESS_WITH_INFO; si se produjo un error en la ejecución, devuelve SQL_ERROR. En este momento, SQLParamData puede devolver cualquier SQLSTATE que SQLBulkOperations pueda devolver.

Si se cancela la operación o se produce un error en SQLParamData o SQLPutData después de que SQLBulkOperations devuelva SQL_NEED_DATA y antes de que se envíen datos para todas las columnas de datos en ejecución, la aplicación solo puede llamar a SQLCancel, SQLGetDiagField, SQLGetDiagRec, SQLGetFunctions, SQLParamData o SQLPutData para la instrucción o la conexión asociada a la instrucción . Si llama a cualquier otra función para la instrucción o la conexión asociada a la instrucción , la función devuelve SQL_ERROR y SQLSTATE HY010 (error de secuencia de función).

Si la aplicación llama a SQLCancel mientras el controlador sigue necesitando datos para las columnas de datos en ejecución, el controlador cancela la operación. A continuación, la aplicación puede llamar a SQLBulkOperations de nuevo; la cancelación no afecta al estado del cursor ni a la posición actual del cursor.

Matriz de Estados de fila

La matriz de estado de fila contiene valores de estado para cada fila de datos del conjunto de filas después de una llamada a SQLBulkOperations. El controlador establece los valores de estado de esta matriz después de una llamada a SQLFetch, SQLFetchScroll, SQLSetPos o SQLBulkOperations. Esta matriz se rellena inicialmente mediante una llamada a SQLBulkOperations si no se ha llamado a SQLFetch o SQLFetchScroll antes de SQLBulkOperations. El atributo de instrucción SQL_ATTR_ROW_STATUS_PTR apunta a esta matriz. El número de elementos de las matrices de estado de fila debe ser igual al número de filas del conjunto de filas (según lo definido por el atributo de instrucción SQL_ATTR_ROW_ARRAY_SIZE). Para obtener información sobre esta matriz de estado de fila, vea SQLFetch.

Ejemplo de código

En el ejemplo siguiente se capturan 10 filas de datos a la vez de la tabla Customers. A continuación, solicita al usuario que realice una acción. Para reducir el tráfico de red, el búfer de ejemplo actualiza, elimina e inserta localmente en las matrices enlazadas, pero en desplazamientos pasados los datos del conjunto de filas. Cuando el usuario elige enviar actualizaciones, eliminaciones e inserciones en el origen de datos, el código establece el desplazamiento de enlace correctamente y llama a SQLBulkOperations. Para simplificar, el usuario no puede almacenar en búfer más de 10 actualizaciones, eliminaciones o inserciones.

// SQLBulkOperations_Function.cpp  
// compile with: ODBC32.lib  
#include <windows.h>  
#include <sqlext.h>  
#include "stdio.h"  
  
#define UPDATE_ROW 100  
#define DELETE_ROW 101  
#define ADD_ROW 102  
#define SEND_TO_DATA_SOURCE 103  
#define UPDATE_OFFSET 10  
#define INSERT_OFFSET 20  
#define DELETE_OFFSET 30  
  
// Define structure for customer data (assume 10 byte maximum bookmark size).  
typedef struct tagCustStruct {  
   SQLCHAR Bookmark[10];  
   SQLINTEGER BookmarkLen;  
   SQLUINTEGER CustomerID;  
   SQLINTEGER CustIDInd;  
   SQLCHAR CompanyName[51];  
   SQLINTEGER NameLenOrInd;  
   SQLCHAR Address[51];  
   SQLINTEGER AddressLenOrInd;  
   SQLCHAR Phone[11];  
   SQLINTEGER PhoneLenOrInd;  
} CustStruct;  
  
// Allocate 40 of these structures. Elements 0-9 are for the current rowset,  
// elements 10-19 are for the buffered updates, elements 20-29 are for  
// the buffered inserts, and elements 30-39 are for the buffered deletes.  
CustStruct CustArray[40];  
SQLUSMALLINT RowStatusArray[10], Action, RowNum, NumUpdates = 0, NumInserts = 0,  
NumDeletes = 0;  
SQLLEN BindOffset = 0;  
SQLRETURN retcode;  
SQLHENV henv = NULL;  
SQLHDBC hdbc = NULL;  
SQLHSTMT hstmt = NULL;  
  
int main() {  
   retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);  
   retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0);   
  
   retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);   
   retcode = SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);  
  
   retcode = SQLConnect(hdbc, (SQLCHAR*) "Northwind", SQL_NTS, (SQLCHAR*) NULL, 0, NULL, 0);  
   retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);  
  
   // Set the following statement attributes:  
   // SQL_ATTR_CURSOR_TYPE:           Keyset-driven  
   // SQL_ATTR_ROW_BIND_TYPE:         Row-wise  
   // SQL_ATTR_ROW_ARRAY_SIZE:        10  
   // SQL_ATTR_USE_BOOKMARKS:         Use variable-length bookmarks  
   // SQL_ATTR_ROW_STATUS_PTR:        Points to RowStatusArray  
   // SQL_ATTR_ROW_BIND_OFFSET_PTR:   Points to BindOffset  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_BIND_TYPE, (SQLPOINTER)sizeof(CustStruct), 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)10, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_USE_BOOKMARKS, (SQLPOINTER)SQL_UB_VARIABLE, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_STATUS_PTR, RowStatusArray, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &BindOffset, 0);  
  
   // Bind arrays to the bookmark, CustomerID, CompanyName, Address, and Phone columns.  
   retcode = SQLBindCol(hstmt, 0, SQL_C_VARBOOKMARK, CustArray[0].Bookmark, sizeof(CustArray[0].Bookmark), &CustArray[0].BookmarkLen);  
   retcode = SQLBindCol(hstmt, 1, SQL_C_ULONG, &CustArray[0].CustomerID, 0, &CustArray[0].CustIDInd);  
   retcode = SQLBindCol(hstmt, 2, SQL_C_CHAR, CustArray[0].CompanyName, sizeof(CustArray[0].CompanyName), &CustArray[0].NameLenOrInd);  
   retcode = SQLBindCol(hstmt, 3, SQL_C_CHAR, CustArray[0].Address, sizeof(CustArray[0].Address), &CustArray[0].AddressLenOrInd);  
   retcode = SQLBindCol(hstmt, 4, SQL_C_CHAR, CustArray[0].Phone, sizeof(CustArray[0].Phone), &CustArray[0].PhoneLenOrInd);  
  
   // Execute a statement to retrieve rows from the Customers table.  
   retcode = SQLExecDirect(hstmt, (SQLCHAR*)"SELECT CustomerID, CompanyName, Address, Phone FROM Customers", SQL_NTS);  
  
   // Fetch and display the first 10 rows.  
   retcode = SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 0);  
   // DisplayCustData(CustArray, 10);  
  
   // Call GetAction to get an action and a row number from the user.  
   // while (GetAction(&Action, &RowNum)) {  
   Action = SQL_FETCH_NEXT;  
   RowNum = 2;  
   switch (Action) {  
      case SQL_FETCH_NEXT:  
      case SQL_FETCH_PRIOR:  
      case SQL_FETCH_FIRST:  
      case SQL_FETCH_LAST:  
      case SQL_FETCH_ABSOLUTE:  
      case SQL_FETCH_RELATIVE:  
         // Fetch and display the requested data.  
         SQLFetchScroll(hstmt, Action, RowNum);  
         // DisplayCustData(CustArray, 10);  
         break;  
  
      case UPDATE_ROW:  
         // Check if we have reached the maximum number of buffered updates.  
         if (NumUpdates < 10) {  
            // Get the new customer data and place it in the next available element of  
            // the buffered updates section of CustArray, copy the bookmark of the row  
            // being updated to the same element, and increment the update counter.  
            // Checking to see we have not already buffered an update for this  
            // row not shown.  
            // GetNewCustData(CustArray, UPDATE_OFFSET + NumUpdates);  
            memcpy(CustArray[UPDATE_OFFSET + NumUpdates].Bookmark,  
               CustArray[RowNum - 1].Bookmark,  
               CustArray[RowNum - 1].BookmarkLen);  
            CustArray[UPDATE_OFFSET + NumUpdates].BookmarkLen =  
               CustArray[RowNum - 1].BookmarkLen;  
            NumUpdates++;  
         } else {  
            printf("Buffers full. Send buffered changes to the data source.");  
         }  
         break;  
      case DELETE_ROW:  
         // Check if we have reached the maximum number of buffered deletes.  
         if (NumDeletes < 10) {  
            // Copy the bookmark of the row being deleted to the next available element  
            // of the buffered deletes section of CustArray and increment the delete  
            // counter. Checking to see we have not already buffered an update for  
            // this row not shown.  
            memcpy(CustArray[DELETE_OFFSET + NumDeletes].Bookmark,  
               CustArray[RowNum - 1].Bookmark,  
               CustArray[RowNum - 1].BookmarkLen);  
  
            CustArray[DELETE_OFFSET + NumDeletes].BookmarkLen =  
               CustArray[RowNum - 1].BookmarkLen;  
  
            NumDeletes++;  
         } else  
            printf("Buffers full. Send buffered changes to the data source.");  
         break;  
  
      case ADD_ROW:  
         // reached maximum number of buffered inserts?  
         if (NumInserts < 10) {  
            // Get the new customer data and place it in the next available element of  
            // the buffered inserts section of CustArray and increment insert counter.  
            // GetNewCustData(CustArray, INSERT_OFFSET + NumInserts);  
            NumInserts++;  
         } else  
            printf("Buffers full. Send buffered changes to the data source.");  
         break;  
  
      case SEND_TO_DATA_SOURCE:  
         // If there are any buffered updates, inserts, or deletes, set the array size  
         // to that number, set the binding offset to use the data in the buffered  
         // update, insert, or delete part of CustArray, and call SQLBulkOperations to  
         // do the updates, inserts, or deletes. Because we will never have more than  
         // 10 updates, inserts, or deletes, we can use the same row status array.  
         if (NumUpdates) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumUpdates, 0);  
            BindOffset = UPDATE_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_UPDATE_BY_BOOKMARK);  
            NumUpdates = 0;  
         }  
  
         if (NumInserts) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumInserts, 0);  
            BindOffset = INSERT_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_ADD);  
            NumInserts = 0;  
         }  
  
         if (NumDeletes) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumDeletes, 0);  
            BindOffset = DELETE_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_DELETE_BY_BOOKMARK);  
            NumDeletes = 0;  
         }  
  
         // If there were any updates, inserts, or deletes, reset the binding offset  
         // and array size to their original values.  
         if (NumUpdates || NumInserts || NumDeletes) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)10, 0);  
            BindOffset = 0;  
         }  
         break;  
   }  
   // }  
  
   // Close the cursor.  
   SQLFreeStmt(hstmt, SQL_CLOSE);  
}  

Funciones relacionadas

Consulte también

Referencia de API ODBC
Archivos de encabezado de ODBC