Share via

  • Article

Traitement des résultats (ODBC)

Après qu'une application a soumis une instruction SQL, SQL Server retourne les données obtenues sous forme d'un ou plusieurs jeux de résultats. Un jeu de résultats est un ensemble de lignes et colonnes qui correspondent aux critères de la requête. Les instructions SELECT, les fonctions de catalogue et certaines procédures stockées produisent un jeu de résultats sous forme de tableau, accessible par une application. Si l'instruction SQL exécutée est une procédure stockée, un lot contenant plusieurs commandes ou une instruction SELECT avec des mots clés, tels que COMPUTE ou COMPUTE BY, il y aura plusieurs jeux de résultats à traiter.

Les fonctions de catalogue ODBC peuvent aussi extraire les données. Par exemple, SQLColumns extrait les données relatives aux colonnes de la source de données. Ces jeux de résultats peuvent contenir zéro ou plusieurs lignes.

D'autres instructions SQL, telles que GRANT ou REVOKE, ne retournent pas de jeux de résultats. Pour ces instructions, le code de retour de SQLExecute ou SQLExecDirect est généralement la seule indication que l'instruction a réussi.

Chaque instruction INSERT, UPDATE et DELETE retourne un jeu de résultats qui contient uniquement le nombre de lignes concernées par la modification. Ce nombre est rendu disponible lorsque l'application appelle SQLRowCount. Les applications ODBC 3.x doivent appeler SQLRowCount pour extraire le jeu de résultats ou SQLMoreResults pour l'annuler. Quand une application exécute un lot ou une procédure stockée qui contient plusieurs instructions INSERT, UPDATE ou DELETE, le jeu de résultats de chaque instruction de modification doit être traité à l'aide de SQLRowCount ou annulé à l'aide de SQLMoreResults. Ces nombres peuvent être annulés en incluant une instruction SET NOCOUNT ON dans le lot ou la procédure stockée.

Transact-SQL inclut l'instruction SET NOCOUNT. Lorsque l'option NOCOUNT est activée, SQL Server ne retourne pas les nombres de lignes affectées par une instruction et SQLRowCount retourne 0. La version du pilote ODBC SQL Server Native Client introduit une option SQLGetStmtAttr spécifique au pilote, SQL_SOPT_SS_NOCOUNT_STATUS, pour signaler si l'option NOCOUNT est activée ou non. Chaque fois que SQLRowCount retourne 0, l'application doit tester SQL_SOPT_SS_NOCOUNT_STATUS. Si SQL_NC_ON est retourné, la valeur 0 de SQLRowCount indique seulement que SQL Server n'a pas retourné de nombre de lignes. Si SQL_NC_OFF est retourné, cela signifie que l'option NOCOUNT est désactivée et la valeur 0 de SQLRowCount indique que l'instruction n'a affecté aucune ligne. Les applications ne doivent pas afficher la valeur de SQLRowCount quand SQL_SOPT_SS_NOCOUNT_STATUS a la valeur SQL_NC_OFF. Comme les lots ou procédures stockées importants peuvent contenir plusieurs instructions SET NOCOUNT, les programmeurs ne peuvent pas en déduire que SQL_SOPT_SS_NOCOUNT_STATUS demeure constant. L'option doit être testée à chaque fois que SQLRowCount retourne 0.

Plusieurs autres instructions Transact-SQL retournent leurs données dans des messages plutôt que dans des jeux de résultats. Lorsque le pilote ODBC SQL Server Native Client reçoit ces messages, il retourne SQL_SUCCESS_WITH_INFO pour permettre à l'application de savoir que des messages d'information sont disponibles. L'application peut alors appeler SQLGetDiagRec pour extraire ces messages. Les instructions Transact-SQL qui fonctionnent ainsi sont :

  • DBCC

  • SET SHOWPLAN (disponible avec les versions antérieures de SQL Server)

  • SET STATISTICS

  • PRINT

  • RAISERROR

Le pilote ODBC SQL Server Native Client retourne SQL_ERROR sur une instruction RAISERROR ayant une gravité supérieure ou égale à 11. Si la gravité de RAISERROR est supérieure ou égale à 19, la connexion est également abandonnée.

Pour traiter les jeux de résultats d'une instruction SQL, l'application :

  • détermine les caractéristiques du jeu de résultats ;

  • lie les colonnes aux variables de programme ;

  • extrait une valeur unique, une ligne entière de valeurs ou plusieurs lignes de valeurs ;

  • effectue un test pour voir s'il y a plusieurs jeux de résultats, et si tel est le cas, effectue une nouvelle boucle pour déterminer les caractéristiques du nouveau jeu de résultats.

Le processus de récupération des lignes de la source de données et leur renvoi à l'application est appelé extraction.

Récupération des jeux de résultats COMPUTE et COMPUTE BY

La clause COMPUTE BY génère des sous-totaux au sein d'un jeu de résultats ; la clause COMPUTE génère un total à la fin du jeu de résultats. Le pilote ODBC SQL Server Native Client présente ces totaux et sous-totaux à l'application appelante en générant plusieurs jeux de résultats pour chaque instruction SELECT.

L'exemple suivant utilise COMPUTE BY pour générer des sous-totaux et COMPUTE pour générer un total :

SELECT Title = CONVERT(char(20), title), type, price, advance
FROM Titles
WHERE ytd_sales IS NOT NULL
  AND type LIKE '%cook%'
ORDER BY type DESC
COMPUTE AVG(price), SUM(advance) BY type
COMPUTE SUM(price), SUM(advance)

Ces instructions provoquent un calcul de sous-total pour le prix moyen et la somme des avances pour chaque type de livre, puis calculent la somme totale des prix et des avances. Le pilote présente le premier jeu de résultats pour les lignes des livres correspondant au premier type de livre. Il crée alors un deuxième jeu de résultats avec les deux colonnes COMPUTE BY pour AVG(price) et SUM(advance) pour ce premier ensemble de livres. Puis, il produit un troisième jeu de résultats pour le groupe de livres suivant, et un quatrième jeu de résultats avec les sous-totaux COMPUTE BY de ce groupe. Le pilote entrelace ces jeux de résultats jusqu'à ce qu'il produise le jeu de résultats final avec le total pour la clause COMPUTE SUM(price), SUM(advance).