Récupération de ligne avec un curseur

Db2 dispose d'un mécanisme appelé curseur. Utiliser un curseur revient à maintenir le doigt sur une ligne de texte particulière sur une page imprimée.

Dans l' Db2, un programme d'application utilise un curseur pour pointer vers une ou plusieurs lignes dans un ensemble de lignes récupérées à partir d'une table. Vous pouvez également utiliser un curseur pour récupérer des lignes d'un jeu de résultats renvoyé par une procédure stockée. Votre programme d'application peut utiliser un curseur pour récupérer des lignes dans une table.

Vous pouvez récupérer et traiter un ensemble de lignes qui satisfont la condition de recherche d'une instruction SQL. Lorsque vous utilisez un programme pour sélectionner les lignes, le programme traite une ou plusieurs lignes à la fois.

L'instruction SELECT doit être contenue dans une instruction DECLARE CURSOR et ne peut pas inclure de clause INTO. L'instruction DECLARE CURSOR définit et nomme le curseur, identifiant l'ensemble des lignes à récupérer avec l'instruction SELECT du curseur. Cet ensemble de lignes est appelé la table des résultats.

Après l'exécution de l'instruction DECLARE CURSOR, vous traitez la table de résultats d'un curseur comme suit :

Ouvrez le curseur avant de récupérer des lignes.
Pour indiquer à l' Db2 que vous êtes prêt à traiter la première ligne de la table de résultats, demandez à votre programme d'émettre l'instruction OPEN. Db2 utilise ensuite l'instruction SELECT dans l'instruction DECLARE CURSOR pour identifier un ensemble de lignes. Si vous utilisez des variables hôtes dans cette instruction SELECT, l' Db2 e utilise la valeur actuelle des variables pour sélectionner les lignes.
Utilisez une instruction FETCH pour récupérer une ou plusieurs lignes.
La forme la plus simple de l'instruction FETCH permet de récupérer une seule ligne du tableau de résultats à l'aide d'un curseur positionné sur la ligne. À tout moment, un curseur positionné sur une ligne récupère au maximum une seule ligne du tableau de résultats dans les variables hôtes. Vous pouvez utiliser une instruction FETCH pour récupérer plus d'une ligne de la table de résultats en utilisant un curseur qui est activé pour traiter des jeux de lignes. Un ensemble de lignes est un ensemble de lignes récupérées par une extraction de plusieurs lignes.

Lorsque votre programme émet une instruction FETCH positionnée sur une ligne, l' Db2 e utilise le curseur pour pointer vers une ligne dans la table de résultats, ce qui en fait la ligne actuelle. Db2 puis déplace le contenu de la ligne en cours dans les variables hôtes du programme que vous avez spécifiées dans la clause INTO de l'instruction FETCH. L'instruction FETCH déplace le curseur. Vous pouvez utiliser des tableaux de variables hôtes et renvoyer plusieurs lignes de données avec une seule instruction FETCH.
Fermer le curseur lorsque la condition de fin de données se produit.
Si vous avez fini de traiter les lignes de la table de résultats et que vous souhaitez réutiliser le curseur, exécutez une instruction CLOSE pour le fermer.

Recommandation : Fermez explicitement le curseur lorsque vous avez fini de l'utiliser.

Votre programme peut avoir plusieurs curseurs. Chaque curseur doit répondre aux exigences suivantes :

DECLARE CURSOR instruction pour définir le curseur
Déclarations OPEN et CLOSE pour ouvrir et fermer le curseur
Instructions FETCH pour récupérer des lignes de la table de résultats du curseur

Vous devez déclarer les variables hôte avant de les mentionner dans une instruction DECLARE CURSOR. Pour définir et identifier un ensemble de lignes auxquelles il faut accéder avec un curseur, émettez une instruction DECLARE CURSOR. L'instruction DECLARE CURSOR nomme un curseur et spécifie une instruction SELECT. L'instruction SELECT définit les critères des lignes qui appartiennent à la table de résultats.

Vous pouvez utiliser les curseurs pour récupérer, mettre à jour ou supprimer une ou plusieurs lignes d'un tableau, mais vous ne pouvez pas les utiliser pour insérer une ligne dans un tableau.

Exemples

Supposons que votre programme examine les données relatives aux personnes du département D11 et conserve les données dans la table EMP. Les exemples suivants montrent les instructions SQL que vous devez inclure dans un programme COBOL pour définir et utiliser un curseur. Dans ces exemples, le programme utilise le curseur pour traiter un ensemble de lignes de la table EMP.

Début des informations sur l'interface de programmation à usage général.

Exemple : définir le curseur

La déclaration suivante définit un curseur nommé THISEMP :

EXEC SQL
  DECLARE THISEMP CURSOR FOR
    SELECT EMPNO, LASTNAME,
    DEPT, JOB
    FROM EMP
    WHERE DEPT = 'D11'
  FOR UPDATE OF JOB
END-EXEC.

Exemple : ouvrir le curseur

La déclaration suivante ouvre le curseur :

EXEC SQL
  OPEN THISEMP
END-EXEC.

Exemple : utiliser le curseur pour récupérer une ligne

L'instruction suivante utilise le curseur THISEMP pour récupérer une ligne :

EXEC SQL
  FETCH THISEMP
  INTO :EMP-NUM, :NAME2,
  :DEPT, :JOB-NAME
END-EXEC.

Exemple : Mettre à jour la ligne courante à l'aide du curseur

L'instruction suivante utilise le curseur THISEMP pour mettre à jour la valeur JOB de certains employés du service D11:

EXEC SQL
  UPDATE EMP
  SET JOB = :NEW-JOB
  WHERE CURRENT OF THISEMP
END-EXEC.

Exemple fermer le curseur

La déclaration suivante ferme le curseur :

EXEC SQL
  CLOSE THISEMP
END-EXEC.

En savoir plus sur les curseurs

Fin des informations sur l'interface de programmation à usage général.

Si le curseur n'est pas défilant, chaque appel positionne le curseur sur la ligne ou le groupe de lignes suivant. Un curseur défilant peut se déplacer vers l'avant et vers l'arrière, et peut être repositionné au début, à la fin ou à un point de décalage relatif. Les applications peuvent utiliser un ensemble puissant d'instructions SQL pour récupérer des données en utilisant un curseur dans un ordre aléatoire. Les curseurs défilants sont particulièrement utiles pour les applications sur écran. Vous pouvez spécifier que les données du tableau de résultats doivent rester statiques. Par exemple, une application comptable peut exiger que les données restent constantes, alors qu'une application de système de réservation d'une compagnie aérienne doit afficher les dernières informations disponibles sur les vols.

Vous pouvez également définir des options sur l'instruction DECLARE CURSOR qui spécifient la sensibilité d'un curseur défilant aux modifications des données sous-jacentes en cas d'insertions, de mises à jour ou de suppressions.

Un curseur sensible est sensible aux modifications apportées à la base de données après la génération du tableau des résultats. Par exemple, lorsqu'une application exécute des instructions UPDATE et DELETE positionnées avec le curseur, ces modifications sont visibles dans la table de résultats.
Un curseur insensible n'est pas sensible aux insertions, mises à jour ou suppressions effectuées dans les lignes sous-jacentes d'une table de résultats après la génération de la table de résultats. Par exemple, l'ordre des lignes et les valeurs de chaque ligne du tableau de résultats ne changent pas après l'ouverture du curseur par l'application.

Pour indiquer qu'un curseur est défilant, vous le déclarez avec le mot-clé SCROLL.

Par exemple, l'exemple suivant montre une déclaration pour un curseur défilant insensible :

EXEC SQL DECLARE C1 INSENSITIVE SCROLL CURSOR FOR
  SELECT DEPTNO, DEPTNAME, MGRNO
  FROM DEPT
  ORDER BY DEPTNO
END-EXEC.

Pour utiliser ce curseur afin de récupérer la cinquième ligne du tableau de résultats, vous pouvez utiliser une instruction FETCH comme dans l'exemple suivant :

EXEC SQL FETCH ABSOLUTE +5 C1 INTO :HVDEPTNO, :DEPTNAME, :MGRNO;

Db2 for z/OS® fournit un autre type de curseur appelé curseur dynamique défilant. Grâce à un curseur dynamique, les applications peuvent faire défiler directement une table de base tout en accédant aux données les plus récentes.