SQLSetPos, fonction

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

Résumé
SQLSetPos définit la position du curseur dans un ensemble de lignes et permet à une application d’actualiser les données dans l’ensemble de lignes ou de mettre à jour ou de supprimer des données dans le jeu de résultats.

Syntaxe

  
SQLRETURN SQLSetPos(  
      SQLHSTMT        StatementHandle,  
      SQLSETPOSIROW   RowNumber,  
      SQLUSMALLINT    Operation,  
      SQLUSMALLINT    LockType);  

Arguments

StatementHandle
[Entrée] Handle d’instruction.

RowNumber
[Entrée] Position de la ligne dans l’ensemble de lignes sur laquelle effectuer l’opération spécifiée avec l’argument Opération . Si RowNumber est 0, l’opération s’applique à chaque ligne de l’ensemble de lignes.

Pour plus d’informations, consultez « Commentaires ».

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

SQL_POSITION SQL_REFRESH SQL_UPDATE SQL_DELETE

Pour plus d’informations, consultez « Commentaires ».

LockType
[Entrée] Spécifie comment verrouiller la ligne après avoir effectué l’opération spécifiée dans l’argument Opération .

SQL_LOCK_NO_CHANGE SQL_LOCK_EXCLUSIVE SQL_LOCK_UNLOCK

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 SQLSetPos 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 couramment retournées par SQLSetPos et explique chacune d’elles dans le contexte de cette fonction ; la notation « (DM) » précède les descriptions des 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 SQL_SUCCESS_WITH_INFO ou SQL_ERROR (sauf 01xxx SQLSTATEs), SQL_SUCCESS_WITH_INFO est retourné si une erreur se produit sur une ou plusieurs lignes, mais pas toutes, les lignes d’une opération multirow et SQL_ERROR est retournée si une erreur se produit sur une opération à une seule ligne.

Commentaires

RowNumber, argument

L’argument RowNumber spécifie le nombre de lignes de l’ensemble de lignes sur lequel effectuer l’opération spécifiée par l’argument Opération . Si RowNumber est 0, l’opération s’applique à chaque ligne de l’ensemble de lignes. RowNumber doit être une valeur comprise entre 0 et le nombre de lignes de l’ensemble de lignes.

Toutes les opérations positionnent le curseur sur la ligne spécifiée par RowNumber. Les opérations suivantes nécessitent une position de curseur :

• Instructions de mise à jour et de suppression positionnées.

• Appels à SQLGetData.

• Appels à SQLSetPos avec les options SQL_DELETE, SQL_REFRESH et SQL_UPDATE.

Par exemple, si RowNumber est 2 pour un appel à SQLSetPos avec une opération de SQL_DELETE, le curseur est positionné sur la deuxième ligne de l’ensemble de lignes et cette ligne est supprimée. L’entrée dans le tableau d’état de ligne d’implémentation (pointée par l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR) pour la deuxième ligne est remplacée par SQL_ROW_DELETED.

Une application peut spécifier une position de curseur lorsqu’elle appelle SQLSetPos. En règle générale, il appelle SQLSetPos avec l’opération SQL_POSITION ou SQL_REFRESH pour positionner le curseur avant d’exécuter une instruction de mise à jour ou de suppression positionnée ou d’appeler SQLGetData.

Argument d’opération

L’argument Opération prend en charge les opérations suivantes. Pour déterminer les options prises en charge par une source de données, une application appelle SQLGetInfo avec le type d’informations SQL_DYNAMIC_CURSOR_ATTRIBUTES1, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, SQL_KEYSET_CURSOR_ATTRIBUTES1 ou SQL_STATIC_CURSOR_ATTRIBUTES1 (selon le type du curseur).

LockType, argument

L’argument LockType permet aux applications de contrôler l’accès concurrentiel. Dans la plupart des cas, les sources de données qui prennent en charge les niveaux d’accès concurrentiel et les transactions prennent uniquement en charge la valeur SQL_LOCK_NO_CHANGE de l’argument LockType . L’argument LockType est généralement utilisé uniquement pour la prise en charge basée sur les fichiers.

L’argument LockType spécifie l’état de verrouillage de la ligne après l’exécution de SQLSetPos . Si le pilote ne parvient pas à verrouiller la ligne pour effectuer l’opération demandée ou pour satisfaire l’argument LockType , il retourne SQL_ERROR et SQLSTATE 42000 (erreur de syntaxe ou violation d’accès).

Bien que l’argument LockType soit spécifié pour une instruction unique, le verrou accorde les mêmes privilèges à toutes les instructions sur la connexion. En particulier, un verrou acquis par une instruction sur une connexion peut être déverrouillé par une autre instruction sur la même connexion.

Une ligne verrouillée via SQLSetPos reste verrouillée jusqu’à ce que l’application appelle SQLSetPos pour la ligne avec LockType défini sur SQL_LOCK_UNLOCK, ou jusqu’à ce que l’application appelle SQLFreeHandle pour l’instruction ou SQLFreeStmt avec l’option SQL_CLOSE. Pour un pilote qui prend en charge les transactions, une ligne verrouillée via SQLSetPos est déverrouillée lorsque l’application appelle SQLEndTran pour valider ou restaurer une transaction sur la connexion (si un curseur est fermé lorsqu’une transaction est validée ou restaurée, comme indiqué par l’SQL_CURSOR_COMMIT_BEHAVIOR et SQL_CURSOR_ROLLBACK_BEHAVIOR types d’informations retournés par SQLGetInfo).

L’argument LockType prend en charge les types de verrous suivants. Pour déterminer quels verrous sont pris en charge par une source de données, une application appelle SQLGetInfo avec les SQL_DYNAMIC_CURSOR_ATTRIBUTES1, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, SQL_KEYSET_CURSOR_ATTRIBUTES1 ou SQL_STATIC_CURSOR_ATTRIBUTES1 type d’informations (selon le type du curseur).

Si un pilote prend en charge SQL_LOCK_EXCLUSIVE mais ne prend pas en charge SQL_LOCK_UNLOCK, une ligne verrouillée reste verrouillée jusqu’à ce qu’un des appels de fonction décrits dans le paragraphe précédent se produise.

Si un pilote prend en charge SQL_LOCK_EXCLUSIVE mais ne prend pas en charge SQL_LOCK_UNLOCK, une ligne verrouillée reste verrouillée jusqu’à ce que l’application appelle SQLFreeHandle pour l’instruction ou SQLFreeStmt avec l’option SQL_CLOSE. Si le pilote prend en charge les transactions et ferme le curseur lors de la validation ou de la restauration de la transaction, l’application appelle SQLEndTran.

Pour les opérations de mise à jour et de suppression dans SQLSetPos, l’application utilise l’argument LockType comme suit :

• Pour garantir qu’une ligne ne change pas après sa récupération, une application appelle SQLSetPos avec l’opération définie sur SQL_REFRESH et LockType définie sur SQL_LOCK_EXCLUSIVE.

• Si l’application définit LockType sur SQL_LOCK_NO_CHANGE, le pilote garantit qu’une opération de mise à jour ou de suppression réussit uniquement si l’application spécifiée SQL_CONCUR_LOCK pour l’attribut d’instruction SQL_ATTR_CONCURRENCY.

• Si l’application spécifie SQL_CONCUR_ROWVER ou SQL_CONCUR_VALUES pour l’attribut d’instruction SQL_ATTR_CONCURRENCY, le pilote compare les versions ou valeurs de ligne et rejette l’opération si la ligne a changé depuis l’extraction de la ligne par l’application.

• Si l’application spécifie SQL_CONCUR_READ_ONLY pour l’attribut d’instruction SQL_ATTR_CONCURRENCY, le pilote rejette toute opération de mise à jour ou de suppression.

Pour plus d’informations sur l’attribut d’instruction SQL_ATTR_CONCURRENCY, consultez SQLSetStmtAttr.

Tableaux d’état et d’opération

Les tableaux d’état et d’opération suivants sont utilisés lors de l’appel de SQLSetPos :

• Le tableau d’état de ligne (comme indiqué par le champ SQL_DESC_ARRAY_STATUS_PTR dans l’IRD et l’attribut d’instruction SQL_ATTR_ROW_STATUS_ARRAY) contient des valeurs d’état pour chaque ligne de données de l’ensemble de lignes. Le pilote définit les valeurs d’état dans ce tableau après un appel à SQLFetch, SQLFetchScroll, SQLBulkOperations ou SQLSetPos. Ce tableau est pointé par l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR.

• Le tableau d’opérations de ligne (comme indiqué par le champ SQL_DESC_ARRAY_STATUS_PTR dans l’attribut ARD et l’attribut d’instruction SQL_ATTR_ROW_OPERATION_ARRAY) contient une valeur pour chaque ligne de l’ensemble de lignes qui indique si un appel à SQLSetPos pour une opération en bloc est ignoré ou effectué. Chaque élément du tableau est défini sur SQL_ROW_PROCEED (valeur par défaut) ou SQL_ROW_IGNORE. Ce tableau est pointé par l’attribut d’instruction SQL_ATTR_ROW_OPERATION_PTR.

Le nombre d’éléments dans les tableaux d’état et d’opération doit être égal au nombre de lignes de l’ensemble de lignes (tel que défini par l’attribut d’instruction SQL_ATTR_ROW_ARRAY_SIZE).

Pour plus d’informations sur le tableau d’état de ligne, consultez SQLFetch. Pour plus d’informations sur le tableau d’opérations de ligne, consultez « Ignorer une ligne dans une opération en bloc », plus loin dans cette section.

Utilisation de SQLSetPos

Avant qu’une application appelle SQLSetPos, elle doit effectuer la séquence d’étapes suivante :

1. Si l’application appelle SQLSetPos avec l’opération définie sur SQL_UPDATE, appelez SQLBindCol (ou SQLSetDescRec) pour chaque colonne afin de spécifier son type de données et de lier des mémoires tampons pour les données et la longueur de la colonne.

2. Si l’application appelle SQLSetPos avec l’opération définie sur SQL_DELETE ou SQL_UPDATE, appelez SQLColAttribute pour vous assurer que les colonnes à supprimer ou à mettre à jour sont mises à jour.

3. Appelez SQLExecDirect, SQLExecute ou une fonction de catalogue pour créer un jeu de résultats.

4. Appelez SQLFetch ou SQLFetchScroll pour récupérer les données.

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

Suppression de données à l’aide de SQLSetPos

Pour supprimer des données avec SQLSetPos, une application appelle SQLSetPos avec RowNumber défini sur le nombre de lignes à supprimer et l’opération définie sur SQL_DELETE.

Une fois les données supprimées, le pilote modifie la valeur dans le tableau d’état de ligne d’implémentation pour que la ligne appropriée soit SQL_ROW_DELETED (ou SQL_ROW_ERROR).

Mise à jour des données à l’aide de SQLSetPos

Une application peut transmettre la valeur d’une colonne dans la mémoire tampon de données liée ou avec un ou plusieurs appels à SQLPutData. Les colonnes dont les données sont transmises avec SQLPutData sont appelées colonnes data-at-execution. Elles sont couramment utilisées pour envoyer des données pour SQL_LONGVARBINARY et SQL_LONGVARCHAR colonnes et peuvent être mélangées à d’autres colonnes.

Pour mettre à jour des données avec SQLSetPos, une application :

1. Place les valeurs dans les mémoires tampons de données et de longueur/indicateur liées à SQLBindCol :

   • Pour les colonnes normales, l’application place la nouvelle valeur de colonne dans la mémoire tampon *TargetValuePtr et la longueur de cette valeur dans la mémoire tampon *StrLen_or_IndPtr . Si la ligne ne doit pas être mise à jour, l’application place SQL_ROW_IGNORE dans l’élément de cette ligne du tableau d’opérations de ligne.

   • Pour les colonnes de données au niveau de l’exécution, l’application place une valeur définie par l’application, telle que le numéro de colonne, dans la mémoire tampon *TargetValuePtr . 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 spécifique à une source de données longue 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, elle doit être une valeur non négative et est ignorée.

2. Appelle SQLSetPos avec l’argument Operation défini sur SQL_UPDATE pour mettre à jour la ligne de données.

   • S’il n’existe aucune colonne de données au niveau de l’exécution, le processus est terminé.

   • S’il existe des colonnes de données au niveau de l’exécution, la fonction retourne SQL_NEED_DATA et passe à l’étape 3.

3. Appelle SQLParamData pour récupérer l’adresse de la mémoire tampon *TargetValuePtr pour que la première colonne de données à l’exécution soit traitée. SQLParamData retourne SQL_NEED_DATA. L’application récupère la valeur définie par l’application à partir de la mémoire tampon *TargetValuePtr .

   Remarque

   Bien que les paramètres de données à l’exécution soient similaires aux colonnes data-at-execution, la valeur retournée par SQLParamData est différente pour chacune d’elles.

   Remarque

   Les paramètres de données au niveau de l’exécution sont des paramètres dans une instruction SQL pour laquelle les données seront envoyées avec SQLPutData lorsque l’instruction est exécutée avec SQLExecDirect ou SQLExecute. Ils sont liés à SQLBindParameter ou en définissant des descripteurs avec SQLSetDescRec. La valeur retournée par SQLParamData est une valeur 32 bits passée à SQLBindParameter dans l’argument ParameterValuePtr .

   Remarque

   Les colonnes data-at-execution sont des colonnes dans un ensemble de lignes pour lequel les données seront envoyées avec SQLPutData lorsqu’une ligne est mise à jour avec SQLSetPos. Elles sont liées à SQLBindCol. La valeur retournée par SQLParamData est l’adresse de la ligne dans la mémoire tampon *TargetValuePtr en cours de traitement.

4. 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 C de caractère à une colonne avec un type de données spécifique à une source de données, ou lors de l’envoi de données C binaires à une colonne avec un caractère, type de données binaire ou spécifique à la source de données.

5. 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 que la colonne de données à l’exécution suivante soit traitée. L’application répète les étapes 4 et 5.

   • S’il n’y a plus de colonnes de données au niveau de 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 SQLSetPos.

Si des données ont été mises à jour, le pilote modifie la valeur dans le tableau d’état de ligne d’implémentation pour que la ligne appropriée soit SQL_ROW_UPDATED.

Si l’opération est annulée ou qu’une erreur se produit dans SQLParamData ou SQLPutData, après que SQLSetPos 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 SQLSetPos ; l’annulation n’affecte pas l’état du curseur ou la position actuelle du curseur.

Lorsque la liste SELECT de la spécification de requête associée au curseur contient plusieurs références à la même colonne, qu’une erreur soit générée ou que le pilote ignore les références dupliquées et effectue les opérations demandées est définie par le pilote.

Exécution d’opérations en bloc

Si l’argument RowNumber est 0, le pilote effectue l’opération spécifiée dans l’argument Opération pour chaque ligne de l’ensemble de lignes dont la valeur est SQL_ROW_PROCEED dans son champ dans le tableau d’opérations de ligne pointée par SQL_ATTR_ROW_OPERATION_PTR attribut d’instruction. Il s’agit d’une valeur valide de l’argument RowNumber pour un argument Operation de SQL_DELETE, de SQL_REFRESH ou de SQL_UPDATE, mais pas SQL_POSITION. SQLSetPos avec une opération de SQL_POSITION et un numéro de ligne égal à 0 retourne SQLSTATE HY109 (position de curseur non valide).

Si une erreur se produit qui se rapporte à l’ensemble de lignes entier, tel que SQLSTATE HYT00 (délai d’expiration), le pilote retourne SQL_ERROR et le SQLSTATE approprié. Le contenu des mémoires tampons d’ensemble de lignes n’est pas défini et la position du curseur n’est pas modifiée.

Si une erreur se produit qui se rapporte à une seule ligne, le pilote :

• Définit l’élément de la ligne dans le tableau d’état de ligne pointé par l’attribut d’instruction SQL_ATTR_ROW_STATUS_PTR sur SQL_ROW_ERROR.

• Publie un ou plusieurs SQLSTATEs supplémentaires pour l’erreur dans la file d’attente d’erreurs et définit le champ SQL_DIAG_ROW_NUMBER dans la structure des données de diagnostic.

Après avoir traité l’erreur ou l’avertissement, si le pilote termine l’opération pour les lignes restantes de l’ensemble de lignes, elle retourne SQL_SUCCESS_WITH_INFO. Ainsi, pour chaque ligne qui a retourné une erreur, la file d’attente d’erreurs contient zéro ou plusieurs SQLSTATEs supplémentaires. Si le pilote arrête l’opération après avoir traité l’erreur ou l’avertissement, il retourne SQL_ERROR.

Si le pilote retourne des avertissements, tels que SQLSTATE 01004 (données tronquées), il retourne des avertissements qui s’appliquent à l’ensemble de lignes entier ou à des lignes inconnues dans l’ensemble de lignes avant de renvoyer les informations d’erreur qui s’appliquent à des lignes spécifiques. Elle retourne des avertissements pour des lignes spécifiques ainsi que d’autres informations d’erreur sur ces lignes.

Si RowNumber est égal à 0 et que l’opération est SQL_UPDATE, SQL_REFRESH ou SQL_DELETE, le nombre de lignes sur lesquelles SQLSetPos opère est pointé par l’attribut d’instruction SQL_ATTR_ROWS_FETCHED_PTR.

Si RowNumber est égal à 0 et que l’opération est SQL_DELETE, SQL_REFRESH ou SQL_UPDATE, la ligne actuelle après l’opération est identique à la ligne actuelle avant l’opération.

Ignorer une ligne dans une opération en bloc

Le tableau d’opérations de ligne peut être utilisé pour indiquer qu’une ligne dans l’ensemble de lignes actuel doit être ignorée pendant une opération en bloc à l’aide de SQLSetPos. Pour diriger le pilote pour ignorer une ou plusieurs lignes pendant une opération en bloc, une application doit effectuer les étapes suivantes :

1. Appelez SQLSetStmtAttr pour définir l’attribut d’instruction SQL_ATTR_ROW_OPERATION_PTR pour qu’il pointe vers un tableau de SQLUSMALLINTs. Ce champ peut également être défini en appelant SQLSetDescField pour définir le champ d’en-tête SQL_DESC_ARRAY_STATUS_PTR de l’ARD, ce qui nécessite qu’une application obtienne le handle de descripteur.

2. Définissez chaque élément du tableau d’opérations de ligne sur l’une des deux valeurs suivantes :

   • SQL_ROW_IGNORE, pour indiquer que la ligne est exclue pour l’opération en bloc.

   • SQL_ROW_PROCEED, pour indiquer que la ligne est incluse dans l’opération en bloc. (Il s'agit de la valeur par défaut.)

3. Appelez SQLSetPos pour effectuer l’opération en bloc.

Les règles suivantes s’appliquent au tableau d’opérations de ligne :

• SQL_ROW_IGNORE et SQL_ROW_PROCEED affectent uniquement les opérations en bloc à l’aide de SQLSetPos avec une opération de SQL_DELETE ou de SQL_UPDATE. Ils n’affectent pas les appels à SQLSetPos avec une opération de SQL_REFRESH ou de SQL_POSITION.

• Le pointeur est défini sur Null par défaut.

• Si le pointeur a la valeur Null, toutes les lignes sont mises à jour comme si tous les éléments étaient définis sur SQL_ROW_PROCEED.

• La définition d’un élément sur SQL_ROW_PROCEED ne garantit pas que l’opération se produira sur cette ligne particulière. Par exemple, si une ligne donnée dans l’ensemble de lignes a l’état SQL_ROW_ERROR, le pilote peut ne pas être en mesure de mettre à jour cette ligne, que l’application spécifiée SQL_ROW_PROCEED. Une application doit toujours vérifier le tableau d’état de ligne pour déterminer si l’opération a réussi.

• SQL_ROW_PROCEED est défini comme 0 dans le fichier d’en-tête. Une application peut initialiser le tableau d’opérations de ligne sur 0 pour traiter toutes les lignes.

• Si le numéro d’élément « n » dans le tableau d’opérations de ligne est défini sur SQL_ROW_IGNORE et SQLSetPos est appelé pour effectuer une opération de mise à jour ou de suppression en bloc, la nième ligne de l’ensemble de lignes reste inchangée après l’appel à SQLSetPos.

• Une application doit définir automatiquement une colonne en lecture seule sur SQL_ROW_IGNORE.

Ignorer une colonne dans une opération en bloc

Pour éviter les diagnostics de traitement inutiles générés par une tentative de mise à jour vers une ou plusieurs colonnes en lecture seule, une application peut définir la valeur dans la mémoire tampon de longueur/indicateur liée sur SQL_COLUMN_IGNORE. Pour plus d’informations, consultez SQLBindCol.

Exemple de code

Dans l’exemple suivant, une application permet à un utilisateur de parcourir la table ORDERS et de mettre à jour l’état de l’ordre. Le curseur est piloté par un jeu de clés avec une taille d’ensemble de lignes de 20 et utilise un contrôle d’accès concurrentiel optimiste comparant les versions de lignes. Une fois chaque ensemble de lignes récupéré, l’application l’imprime et permet à l’utilisateur de sélectionner et de mettre à jour l’état d’une commande. L’application utilise SQLSetPos pour positionner le curseur sur la ligne sélectionnée et effectuer une mise à jour positionnée de la ligne. (La gestion des erreurs est omise pour plus de clarté.)

#define ROWS 20  
#define STATUS_LEN 6  
  
SQLCHAR        szStatus[ROWS][STATUS_LEN], szReply[3];  
SQLINTEGER     cbStatus[ROWS], cbOrderID;  
SQLUSMALLINT   rgfRowStatus[ROWS];  
SQLUINTEGER    sOrderID, crow = ROWS, irow;  
SQLHSTMT       hstmtS, hstmtU;  
  
SQLSetStmtAttr(hstmtS, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);  
SQLSetStmtAttr(hstmtS, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) SQL_CURSOR_KEYSET_DRIVEN, 0);  
SQLSetStmtAttr(hstmtS, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) ROWS, 0);  
SQLSetStmtAttr(hstmtS, SQL_ATTR_ROW_STATUS_PTR, (SQLPOINTER) rgfRowStatus, 0);  
SQLSetCursorName(hstmtS, "C1", SQL_NTS);  
SQLExecDirect(hstmtS, "SELECT ORDERID, STATUS FROM ORDERS ", SQL_NTS);  
  
SQLBindCol(hstmtS, 1, SQL_C_ULONG, &sOrderID, 0, &cbOrderID);  
SQLBindCol(hstmtS, 2, SQL_C_CHAR, szStatus, STATUS_LEN, &cbStatus);  
  
while ((retcode == SQLFetchScroll(hstmtS, SQL_FETCH_NEXT, 0)) != SQL_ERROR) {  
   if (retcode == SQL_NO_DATA_FOUND)  
      break;  
   for (irow = 0; irow < crow; irow++) {  
      if (rgfRowStatus[irow] != SQL_ROW_DELETED)  
         printf("%2d %5d %*s\n", irow+1, sOrderID, NAME_LEN-1, szStatus[irow]);  
   }  
   while (TRUE) {  
      printf("\nRow number to update?");  
      gets_s(szReply, 3);  
      irow = atoi(szReply);  
      if (irow > 0 && irow <= crow) {  
         printf("\nNew status?");  
         gets_s(szStatus[irow-1], (ROWS * STATUS_LEN));  
         SQLSetPos(hstmtS, irow, SQL_POSITION, SQL_LOCK_NO_CHANGE);  
         SQLPrepare(hstmtU,  
          "UPDATE ORDERS SET STATUS=? WHERE CURRENT OF C1", SQL_NTS);  
         SQLBindParameter(hstmtU, 1, SQL_PARAM_INPUT,  
            SQL_C_CHAR, SQL_CHAR,  
            STATUS_LEN, 0, szStatus[irow], 0, NULL);  
         SQLExecute(hstmtU);  
      } else if (irow == 0) {  
         break;  
      }  
   }  
}  

Pour plus d’exemples, consultez Instructions de mise à jour et de suppression positionnées et mise à jour des lignes dans l’ensemble de lignes avec SQLSetPos.

Fonctions connexes

Voir aussi

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