SQLBulkOperations, fonction

Conformité
Version introduite : Conformité aux normes ODBC 3.0 : ODBC

Résumé
SQLBulkOperations effectue des insertions en bloc et des opérations de signet en bloc, notamment la mise à jour, la suppression et la récupération par signet.

Syntaxe

  
SQLRETURN SQLBulkOperations(  
     SQLHSTMT       StatementHandle,  
     SQLUSMALLINT   Operation);  

Arguments

StatementHandle
[Entrée] Handle d’instruction.

opération
[Entrée] Opération à effectuer :

SQL_ADD SQL_UPDATE_BY_BOOKMARK SQL_DELETE_BY_BOOKMARK SQL_FETCH_BY_BOOKMARK

Pour plus d’informations, consultez « Commentaires ».

Retours

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

Diagnostics

Lorsque SQLBulkOperations retourne SQL_ERROR ou SQL_SUCCESS_WITH_INFO, une valeur SQLSTATE associée peut être obtenue en appelant SQLGetDiagRec avec un HandleType de SQL_HANDLE_STMT et un Handle of StatementHandle. Le tableau suivant répertorie les valeurs SQLSTATE généralement retournées par SQLBulkOperations et explique chacune d’elles dans le contexte de cette fonction ; la notation « (DM) » précède les descriptions de SQLSTATEs retournées par le Gestionnaire de pilotes. Le code de retour associé à chaque valeur SQLSTATE est SQL_ERROR, sauf indication contraire.

Pour tous les SQLSTATEs qui peuvent retourner des SQL_SUCCESS_WITH_INFO ou des SQL_ERROR (à l’exception de 01xxx SQLSTATEs), SQL_SUCCESS_WITH_INFO est retourné si une erreur se produit sur une ou plusieurs lignes, mais pas toutes, d’une opération multirow, et SQL_ERROR est retourné si une erreur se produit sur une opération à une seule ligne.

Commentaires

Une application utilise SQLBulkOperations pour effectuer les opérations suivantes sur la table ou la vue de base qui correspond à la requête actuelle :

• Ajoutez de nouvelles lignes.

• Mettez à jour un ensemble de lignes où chaque ligne est identifiée par un signet.

• Supprimez un ensemble de lignes où chaque ligne est identifiée par un signet.

• Récupérez un ensemble de lignes où chaque ligne est identifiée par un signet.

Après un appel à SQLBulkOperations, la position du curseur de bloc n’est pas définie. L’application doit appeler SQLFetchScroll pour définir la position du curseur. Une application doit appeler SQLFetchScroll uniquement avec un argument FetchOrientation de SQL_FETCH_FIRST, SQL_FETCH_LAST, SQL_FETCH_ABSOLUTE ou SQL_FETCH_BOOKMARK. La position du curseur n’est pas définie si l’application appelle SQLFetch ou SQLFetchScroll avec un argument FetchOrientation de SQL_FETCH_PRIOR, SQL_FETCH_NEXT ou SQL_FETCH_RELATIVE.

Une colonne peut être ignorée dans les opérations en bloc effectuées par un appel à SQLBulkOperations en définissant la longueur de colonne/la mémoire tampon d’indicateur spécifiée dans l’appel à SQLBindCol sur SQL_COLUMN_IGNORE.

Il n’est pas nécessaire que l’application définisse l’attribut d’instruction SQL_ATTR_ROW_OPERATION_PTR lorsqu’elle appelle SQLBulkOperations , car les lignes ne peuvent pas être ignorées lors de l’exécution d’opérations en bloc avec cette fonction.

La mémoire tampon pointée par l’attribut d’instruction SQL_ATTR_ROWS_FETCHED_PTR contient le nombre de lignes affectées par un appel à SQLBulkOperations.

Lorsque l’argument Opération est SQL_ADD ou SQL_UPDATE_BY_BOOKMARK et que la liste de sélection de la spécification de requête associée au curseur contient plusieurs références à la même colonne, il est défini par le pilote si une erreur est générée ou si le pilote ignore les références dupliquées et effectue les opérations demandées.

Pour plus d’informations sur l’utilisation de SQLBulkOperations, consultez Mise à jour des données avec SQLBulkOperations.

Exécution d’insertions en bloc

Pour insérer des données avec SQLBulkOperations, une application effectue la séquence d’étapes suivante :

1. Exécute une requête qui retourne un jeu de résultats.

2. Définit l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE sur le nombre de lignes qu’il souhaite insérer.

3. Appelle SQLBindCol pour lier les données qu’il souhaite insérer. Les données sont liées à un tableau dont la taille est égale à la valeur de SQL_ATTR_ROW_ARRAY_SIZE.

   Notes

   La taille du tableau pointé par l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR doit être égale à SQL_ATTR_ROW_ARRAY_SIZE ou SQL_ATTR_ROW_STATUS_PTR doit être un pointeur Null.

4. Appelle SQLBulkOperations(StatementHandle, SQL_ADD) pour effectuer l’insertion.

5. Si l’application a défini l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR, elle peut inspecter ce tableau pour voir le résultat de l’opération.

Si une application lie la colonne 0 avant d’appeler SQLBulkOperations avec un argument Operation de SQL_ADD, le pilote met à jour les mémoires tampons de colonne 0 liée avec les valeurs de signet pour la ligne nouvellement insérée. Pour cela, l’application doit avoir défini l’attribut d’instruction SQL_ATTR_USE_BOOKMARKS sur SQL_UB_VARIABLE avant d’exécuter l’instruction. (Cela ne fonctionne pas avec odbc 2. pilote x .)

Les données longues peuvent être ajoutées en parties par SQLBulkOperations, à l’aide d’appels à SQLParamData et SQLPutData. Pour plus d’informations, consultez « Fourniture de données longues pour les insertions en bloc et les Mises à jour » plus loin dans cette référence de fonction.

Il n’est pas nécessaire pour l’application d’appeler SQLFetch ou SQLFetchScroll avant d’appeler SQLBulkOperations (sauf en cas de comparaison avec ODBC 2). pilote x ; consultez Compatibilité descendante et conformité aux normes).

Le comportement est défini par le pilote si SQLBulkOperations, avec l’argument Opération SQL_ADD, est appelé sur un curseur qui contient des colonnes en double. Le pilote peut retourner un SQLSTATE défini par le pilote, ajouter les données à la première colonne qui apparaît dans le jeu de résultats ou effectuer un autre comportement défini par le pilote.

Exécution de Mises à jour en bloc à l’aide de signets

Pour effectuer des mises à jour en bloc à l’aide de signets avec SQLBulkOperations, une application effectue les étapes suivantes dans l’ordre :

1. Définit l’attribut d’instruction SQL_ATTR_USE_BOOKMARKS sur SQL_UB_VARIABLE.

2. Exécute une requête qui retourne un jeu de résultats.

3. Définit l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE sur le nombre de lignes qu’il souhaite mettre à jour.

4. Appelle SQLBindCol pour lier les données qu’il souhaite mettre à jour. Les données sont liées à un tableau d’une taille égale à la valeur de SQL_ATTR_ROW_ARRAY_SIZE. Il appelle également SQLBindCol pour lier la colonne 0 (colonne signet).

5. Copie les signets pour les lignes qu’il souhaite mettre à jour dans le tableau lié à la colonne 0.

6. Mises à jour les données dans les mémoires tampons liées.

   Notes

   La taille du tableau pointé vers l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR doit être égale à SQL_ATTR_ROW_ARRAY_SIZE ou SQL_ATTR_ROW_STATUS_PTR doit être un pointeur null.

7. Appelle SQLBulkOperations(StatementHandle, SQL_UPDATE_BY_BOOKMARK).

   Notes

   Si l’application a défini l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR, elle peut inspecter ce tableau pour voir le résultat de l’opération.

8. Appelle éventuellement SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK) pour extraire des données dans les mémoires tampons d’application liées afin de vérifier que la mise à jour s’est produite.

9. Si les données ont été mises à jour, le pilote modifie la valeur dans le tableau d’état des lignes pour les lignes appropriées en SQL_ROW_UPDATED.

Les mises à jour en bloc effectuées par SQLBulkOperations peuvent inclure des données longues à l’aide d’appels à SQLParamData et SQLPutData. Pour plus d’informations, consultez « Fourniture de données longues pour les insertions en bloc et les Mises à jour » plus loin dans cette référence de fonction.

Si les signets persistent entre les curseurs, l’application n’a pas besoin d’appeler SQLFetch ou SQLFetchScroll avant de procéder à la mise à jour par signets. Il peut utiliser des signets qu’il a stockés à partir d’un curseur précédent. Si les signets ne sont pas persistants entre les curseurs, l’application doit appeler SQLFetch ou SQLFetchScroll pour récupérer les signets.

Le comportement est défini par le pilote si SQLBulkOperations, avec un argument Operation de SQL_UPDATE_BY_BOOKMARK, est appelé sur un curseur qui contient des colonnes en double. Le pilote peut retourner un SQLSTATE défini par le pilote, mettre à jour la première colonne qui apparaît dans le jeu de résultats ou effectuer un autre comportement défini par le pilote.

Exécution d’extractions en bloc à l’aide de signets

Pour effectuer des extractions en bloc à l’aide de signets avec SQLBulkOperations, une application effectue les étapes suivantes dans l’ordre :

1. Définit l’attribut d’instruction SQL_ATTR_USE_BOOKMARKS sur SQL_UB_VARIABLE.

2. Exécute une requête qui retourne un jeu de résultats.

3. Définit l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE sur le nombre de lignes qu’il souhaite extraire.

4. Appelle SQLBindCol pour lier les données qu’il souhaite extraire. Les données sont liées à un tableau d’une taille égale à la valeur de SQL_ATTR_ROW_ARRAY_SIZE. Il appelle également SQLBindCol pour lier la colonne 0 (colonne signet).

5. Copie les signets pour les lignes qu’il souhaite extraire dans le tableau lié à la colonne 0. (Cela suppose que l’application a déjà obtenu les signets séparément.)

   Notes

   La taille du tableau pointé vers l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR doit être égale à SQL_ATTR_ROW_ARRAY_SIZE ou SQL_ATTR_ROW_STATUS_PTR doit être un pointeur null.

6. Appelle SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK).

7. Si l’application a défini l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR, elle peut inspecter ce tableau pour voir le résultat de l’opération.

Si les signets persistent entre les curseurs, l’application n’a pas besoin d’appeler SQLFetch ou SQLFetchScroll avant d’effectuer l’extraction par signets. Il peut utiliser des signets qu’il a stockés à partir d’un curseur précédent. Si les signets ne sont pas persistants entre les curseurs, l’application doit appeler SQLFetch ou SQLFetchScroll une fois pour récupérer les signets.

Exécution de suppressions en bloc à l’aide de signets

Pour effectuer des suppressions en bloc à l’aide de signets avec SQLBulkOperations, une application effectue les étapes suivantes dans l’ordre :

1. Définit l’attribut d’instruction SQL_ATTR_USE_BOOKMARKS sur SQL_UB_VARIABLE.

2. Exécute une requête qui retourne un jeu de résultats.

3. Définit l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE sur le nombre de lignes qu’il souhaite supprimer.

4. Appelle SQLBindCol pour lier la colonne 0 (colonne signet).

5. Copie les signets pour les lignes qu’il souhaite supprimer dans le tableau lié à la colonne 0.

   Notes

   La taille du tableau pointé vers l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR doit être égale à SQL_ATTR_ROW_ARRAY_SIZE ou SQL_ATTR_ROW_STATUS_PTR doit être un pointeur null.

6. Appelle SQLBulkOperations(StatementHandle, SQL_DELETE_BY_BOOKMARK).

7. Si l’application a défini l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR, elle peut inspecter ce tableau pour voir le résultat de l’opération.

Si les signets persistent entre les curseurs, l’application n’a pas besoin d’appeler SQLFetch ou SQLFetchScroll avant de supprimer par signets. Il peut utiliser des signets qu’il a stockés à partir d’un curseur précédent. Si les signets ne sont pas persistants entre les curseurs, l’application doit appeler SQLFetch ou SQLFetchScroll une fois pour récupérer les signets.

Fourniture de données longues pour les insertions en bloc et les Mises à jour

Les données longues peuvent être fournies pour les insertions et mises à jour en bloc effectuées par des appels à SQLBulkOperations. Pour insérer ou mettre à jour des données longues, une application effectue les étapes suivantes en plus des étapes décrites dans les sections « Exécution d’insertions en bloc » et « Exécution d’un Mises à jour en bloc à l’aide de signets » plus haut dans cette rubrique.

1. Lorsqu’elle lie les données à l’aide de SQLBindCol, l’application place une valeur définie par l’application, telle que le numéro de colonne, dans la mémoire tampon *TargetValuePtr pour les colonnes data-at-execution. La valeur peut être utilisée ultérieurement pour identifier la colonne.

   L’application place le résultat de la macro SQL_LEN_DATA_AT_EXEC(length) dans la mémoire tampon *StrLen_or_IndPtr . Si le type de données SQL de la colonne est SQL_LONGVARBINARY, SQL_LONGVARCHAR ou un type de données long spécifique à la source de données et que le pilote retourne « Y » pour le type d’informations SQL_NEED_LONG_DATA_LEN dans SQLGetInfo, la longueur correspond au nombre d’octets de données à envoyer pour le paramètre ; sinon, il doit s’agir d’une valeur non négative et est ignoré.

2. Quand SQLBulkOperations est appelé, s’il existe des colonnes data-at-execution, la fonction retourne SQL_NEED_DATA et passe à l’étape 3, qui suit. (S’il n’existe aucune colonne data-at-execution, le processus est terminé.)

3. L’application appelle SQLParamData pour récupérer l’adresse de la mémoire tampon *TargetValuePtr pour la première colonne data-at-execution à traiter. SQLParamData retourne SQL_NEED_DATA. L’application récupère la valeur définie par l’application à partir de la mémoire tampon *TargetValuePtr .

   Notes

   Bien que les paramètres data-at-execution ressemblent à des colonnes data-at-execution, la valeur retournée par SQLParamData est différente pour chacune d’elles.

   Les colonnes data-at-execution sont des colonnes d’un ensemble de lignes pour lesquelles des données sont envoyées avec SQLPutData lorsqu’une ligne est mise à jour ou insérée avec SQLBulkOperations. Ils sont liés à SQLBindCol. La valeur retournée par SQLParamData est l’adresse de la ligne dans la mémoire tampon *TargetValuePtr en cours de traitement.

4. L’application appelle SQLPutData une ou plusieurs fois pour envoyer des données pour la colonne. Plusieurs appels sont nécessaires si toutes les valeurs de données ne peuvent pas être retournées dans la mémoire tampon *TargetValuePtr spécifiée dans SQLPutData ; plusieurs appels à SQLPutData pour la même colonne sont autorisés uniquement lors de l’envoi de données de caractère C à une colonne avec un type de données spécifique à la source de données, ou lors de l’envoi de données binaires C à une colonne avec un type de données caractère, binaire ou spécifique à la source de données.

5. L’application appelle à nouveau SQLParamData pour signaler que toutes les données ont été envoyées pour la colonne.

   • S’il existe davantage de colonnes de données à l’exécution, SQLParamData retourne SQL_NEED_DATA et l’adresse de la mémoire tampon TargetValuePtr pour la colonne de données à l’exécution suivante à traiter. L’application répète les étapes 4 et 5.

   • S’il n’y a plus de colonnes de données à l’exécution, le processus est terminé. Si l’instruction a été exécutée correctement, SQLParamData retourne SQL_SUCCESS ou SQL_SUCCESS_WITH_INFO ; si l’exécution a échoué, elle retourne SQL_ERROR. À ce stade, SQLParamData peut retourner n’importe quel SQLSTATE qui peut être retourné par SQLBulkOperations.

Si l’opération est annulée ou si une erreur se produit dans SQLParamData ou SQLPutData après que SQLBulkOperations retourne SQL_NEED_DATA et avant que les données ne soient envoyées pour toutes les colonnes de données à l’exécution, l’application peut appeler uniquement SQLCancel, SQLGetDiagField, SQLGetDiagRec, SQLGetFunctions, SQLParamData ou SQLPutData pour l’instruction ou la connexion associée à l’instruction. Si elle appelle une autre fonction pour l’instruction ou la connexion associée à l’instruction, la fonction retourne SQL_ERROR et SQLSTATE HY010 (erreur de séquence de fonction).

Si l’application appelle SQLCancel alors que le pilote a toujours besoin de données pour les colonnes de données à l’exécution, le pilote annule l’opération. L’application peut ensuite appeler à nouveau SQLBulkOperations ; l’annulation n’affecte pas l’état du curseur ou la position actuelle du curseur.

Tableau d’état des lignes

Le tableau d’état des lignes contient des valeurs d’état pour chaque ligne de données de l’ensemble de lignes après un appel à SQLBulkOperations. Le pilote définit les valeurs d’état dans ce tableau après un appel à SQLFetch, SQLFetchScroll, SQLSetPos ou SQLBulkOperations. Ce tableau est initialement rempli par un appel à SQLBulkOperations si SQLFetch ou SQLFetchScroll n’a pas été appelé avant SQLBulkOperations. Ce tableau est pointé vers l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR. Le nombre d’éléments dans les tableaux d’état de ligne doit être égal au nombre de lignes dans l’ensemble de lignes (tel que défini par l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE). Pour plus d’informations sur ce tableau d’état de ligne, consultez SQLFetch.

Exemple de code

L’exemple suivant extrait 10 lignes de données à la fois à partir de la table Customers. Il invite ensuite l’utilisateur à effectuer une action. Pour réduire le trafic réseau, l’exemple de mémoire tampon met à jour, supprime et insère localement dans les tableaux liés, mais à des décalages au-delà des données de l’ensemble de lignes. Lorsque l’utilisateur choisit d’envoyer des mises à jour, des suppressions et des insertions à la source de données, le code définit le décalage de liaison de manière appropriée et appelle SQLBulkOperations. Par souci de simplicité, l’utilisateur ne peut pas mettre en mémoire tampon plus de 10 mises à jour, suppressions ou insertions.

// 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);  
}  

Fonctions connexes

Voir aussi

Informations de référence sur l’API ODBC
Fichiers d’en-tête ODBC