Introduction aux curseurs en PL / SQL
PL / SQL est l'un des langages de programmation les plus utilisés en matière de programmation de bases de données. Certains concepts importants de PL / SQL doivent apprendre et comprendre clairement par un programmeur PL / SQL pour les utiliser correctement. Le curseur en fait partie. Dans le programme PL / SQL, les instructions SQL doivent être exécutées à la fin. Le curseur est comme un pointeur qui est utilisé pour pointer la zone de contexte, créée par Oracle pour exécuter l'instruction SQL. Un curseur contient toutes les lignes renvoyées après le traitement des instructions SQL. L'ensemble de la ligne qui est détenue par le curseur est appelé ensemble actif. Le curseur peut également être nommé pour l'utiliser plus loin dans le programme par un programmeur. Dans cette rubrique, nous allons découvrir les curseurs en PL / SQL.
Types de curseurs
Il existe 2 types de curseurs utilisés dans la programmation PL / SQL:
1. Curseurs implicites
Comme son nom l'indique, les curseurs implicites sont les curseurs créés automatiquement par Oracle lorsque des instructions DML telles que INSERT, DELETE, UPDATE sont exécutées. Lorsque le programmeur ne crée aucun curseur, Oracle le crée lui-même pour contenir les lignes affectées par les instructions DML. Ces curseurs ne peuvent pas être nommés par le programmeur et ne peuvent donc pas être référés et utilisés à un autre endroit du code. Bien qu'Oracle fournisse certains attributs pour effectuer certaines opérations comme
% TROUVE, % NON TROUVE, % ROWCOUNT, % ISOPEN.
| S.No. | Attribut | La description |
| 1. | %A TROUVÉ | Renvoie True si les instructions DML comme INSERT,
DELETE, UPDATE affectent une ou plusieurs lignes ou l'instruction SELECT renvoie une ou plusieurs lignes. Sinon, elle renvoie False |
| 2. | %PAS TROUVÉ | C'est l'opposé de l'attribut% FOUND. Il renvoie True si aucune des lignes n'est affectée par l'instruction DML ou l'instruction SELECT ne renvoie aucun résultat. Sinon, elle renvoie False. |
| 3. | %EST OUVERT | Dans le cas des curseurs implicites, il renvoie toujours False car Oracle ferme le curseur juste après l'exécution des instructions SQL. |
| 4. | % ROWCOUNT | Il renvoie le nombre de lignes. C'est-à-dire le nombre de lignes qui sont affectées par le DML mentionné |
| les instructions du programmeur dans le code PL / SQL comme INSERT, DELETE et UPDATE ou le nombre de lignes qui sont retournées par l'instruction SELECT INTO. |
Exemple
Scénario: Pour mettre à jour les notes de tous les élèves dans un tableau «étudiant» en anglais Sujet ayant la colonne «sujet» par 10.
DECLARE
affected_rows number(4);
BEGIN
UPDATE students SET marks = marks+10 where subject = 'English';
IF sql%NOTFOUND THEN dbms_output.put_line ('No records of English subject are updated');
ELSIF sql%FOUND THEN affected rows: = affected rows%rowcount
dbms_output.put_line('Congrats ..Records Updated' || affected_rows);
END IF;
END;
/
2. Curseurs explicites
Les curseurs explicites sont les curseurs définis par les programmeurs pour avoir plus de contrôle sur la zone de contexte (où sont stockés les résultats des requêtes SQL). Ces curseurs doivent d'abord être définis dans le bloc de déclaration du programme PL / SQL. Il est créé pour les instructions SQL qui renvoient plusieurs lignes après leur traitement. Il existe une procédure spécifique qui doit être suivie pour utiliser un curseur explicite. Les étapes pour utiliser le curseur explicite sont mentionnées ci-dessous:
1. Déclarez le curseur: il est utilisé pour donner un nom à la zone de contexte / curseur avec l'instruction select qui doit être exécutée.
Syntaxe
CURSOR cursor_name IS SELECT statement;
2. Ouvrez le curseur: en ouvrant un curseur, lui alloue la mémoire et la rend disponible pour récupérer les enregistrements renvoyés par l'instruction SQL.
Syntaxe
OPEN cursor_name;
3. Récupérez le curseur: dans ce processus, une ligne est accessible à la fois. L'instruction SELECT est exécutée et les lignes extraites sont stockées dans la zone de contexte. Il récupère les enregistrements et les affecte à une variable définie.
Syntaxe
FETCH cursor_name INTO variable;
4. Fermer le curseur: Cette étape est utilisée pour fermer le curseur ouvert ci-dessus pour désallouer la mémoire une fois que toutes les lignes stockées sont récupérées avec succès.
Syntaxe
CLOSE cursor_name;
Exemple
Scénario: récupérer le nom, l'adresse et le pourcentage global d'élèves dans un tableau
'étudiant' ayant des colonnes 'nom', 'adresse' et 'pourcentage'
DECLARE
stud_name student.name%type; stud_address student.address%type;
stud_percentage student.percentage%type;
CURSOR stud IS SELECT name, address, percentage FROM student; BEGIN
Open stud;
LOOP
FETCH stud into stud_name, stud_address, stud_percentage;
EXIT when stud%NOTFOUND;
dbms_ouput.put_line(stud_name || ' ' || stud_address || ' ' || stud_percentage);
END LOOP;
CLOSE stud;
END
/
Actions du curseur
Contrairement à SQL qui fonctionne sur toutes les lignes d'un jeu de résultats à la fois, le curseur est principalement utilisé dans les scénarios lorsque le programmeur souhaite traiter et récupérer les données d'une ligne à la fois.
Ci-dessous sont mentionnées certaines des actions du curseur:
- Déclarez un curseur: il est important de déclarer un curseur avant de l'utiliser. Un curseur est déclaré en définissant l'instruction SQL qui doit être traitée.
- Ouvrir un curseur: Après la déclaration, un curseur est ouvert et rempli par le retour de données par le traitement de l'instruction SQL.
- Récupérer un curseur: Une fois le curseur ouvert, les lignes de sortie doivent être récupérées une par une pour effectuer toute manipulation si nécessaire.
- Fermer un curseur: après toutes les manipulations de données. Un curseur créé doit être fermé
- Désallouer: Cette étape comprend la suppression du curseur et libère toutes les ressources qu'il détient.
Importance du curseur en PL / SQL
Pointer vers l'emplacement de la mémoire et effectuer des actions en conséquence est l'une des tâches importantes de tout langage de programmation. En PL / SQL, cela se fait par les curseurs. Les curseurs jouent un rôle crucial lorsqu'il s'agit d'effectuer les différentes tâches en donnant un nom à la zone de mémoire (zone de contexte) où le résultat des requêtes SQL est enregistré. Nous pouvons accéder aux enregistrements un par un et y effectuer des manipulations si nécessaire ou les afficher en conséquence sur la console. Les curseurs explicites sont plus efficaces, offrent plus de contrôle programmatique et sont moins vulnérables aux erreurs de données, ils sont donc très utiles dans la programmation PL / SQL que les implicites.
Conclusion
La programmation de bases de données est très populaire de nos jours et PL / SQL est l'un des langages qui devraient être très bien utilisés. Les curseurs donnent plus de contrôle au programmeur pour accéder aux données récupérées. Pour qu'un programmeur puisse travailler sur PL / SQL, il est important de connaître l'utilisation et l'importance du curseur pour fonctionner efficacement.
Articles recommandés
Ceci est un guide des curseurs en PL / SQL. Nous discutons ici des types de curseurs utilisés dans la programmation PL / SQL avec des actions de curseur et de l'importance du curseur. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Types de jointures dans SQL
- Requête d'insertion SQL
- Table en SQL
- Caractère générique dans SQL
- 6 principaux types de jointures dans MySQL avec des exemples