3
Les structures
de contrôles
Structures de contrôle
Les structures de contrôle sont utilisées pour modifier le déroulement logique
des instructions. Il existe deux types:
• Structures de contrôle conditionnelles
• Structures de contrôle itératives
Structure de
contrôle
Conditionnelle Itérative
IF…THEN …END IF Loop…END LOOP
IF…THEN…ELSE…END IF WHILE…LOOP …END LOOP
IF…THEN…ELSIF…ELSE…END IF FOR…LOOP…END LOOP
Les structures
conditionnellles
Les structures conditionnelles exigent que le programmeur spécifie une ou
plusieurs conditions à évaluer ou à tester par le programme, ainsi qu’une
instruction ou des instructions à exécuter si la condition est vérifiée, et
éventuellement d’autres instructions à exécuter si la condition est déterminée
comme étant fausse
Structures conditionnelles
IF CASE
IF … THEN IF … THEN ELSE IF … THEN ELSEIF … SIMPLE CASE SEARCHED CASE
Les structures
conditionnellles
Syntaxe:
Exemple
SIMPLE CASE
• A l'instar de l'instruction IF, l'instruction CASE sélectionne une séquence d'instructions à exécuter.
Syntaxe:
La clause CASE simple permet de comparer une variable/colonne à un set de résultat possible
SEARCHED CASE
• L'instruction searched CASE n'a pas de sélecteur et ses clauses WHEN contiennent des conditions
de recherche générant des valeurs booléennes.
Syntaxe:
L’instruction searched CASE permet d’élaborer une série de conditions booléennes pour déterminer un
résultat
Exemple
Les structures itératives
(boucles)
• Une instruction de boucle nous permet d’exécuter plusieurs fois une instruction ou
un groupe d’instructions.
• PL/SQL fournit différents type de boucle :
• variable de compteur de
• LOOP boucle
• WHILE LOOP • Condition de sortie
• FOR
Condition
Code au sein de la
logique
boucle
Satisfaite?
Suite du programme
La boucle LOOP
A chaque itération, la séquence d'instructions est exécutée puis le contrôle reprend en haut de la boucle.
Une instruction EXIT ou une instruction EXIT WHEN est nécessaire pour rompre la boucle.
Syntaxe:
Exemple:
La boucle WHILE
L’instruction cible est exécutée tant qu'une condition donnée est vraie.
Syntaxe:
Exemple:
La boucle FOR
• La boucle FOR est une structure de contrôle de répétition qui permet d'écrire efficacement une boucle
devant s'exécuter un nombre de fois spécifique.
• Inutile de déclarer la variable ‘indice’
• Indice varie de initial_value à final_value avec un pas de 1
• Si ‘REVERSE’ est précisé alors ‘indice’ varie avec un pas de –1
Syntaxe:
Exemple:
4
Les curseurs
Qu’est ce qu’un curseur?
Comme cité précédemment, le SGBD Oracle utilise des zones mémoires
dédiées au traitement et l’exécution des requêtes SQL.
Ces zones mémoire de taille fixe contenant le résultat de requêtes SQL
sont utilisées pour interpréter et analyser les ordres SQL.
Le curseur (Cursor) permet de nommer ces zones appelées aussi zone de
contexte pour pouvoir accéder aux données résultantes et les traiter ainsi
ligne par ligne.
Plus précisément, un curseur permet de "récupérer" un ensemble de
tuples, résultat d'une requête d'interrogation sur la base de données et de
les manipuler d’une manière procédurale, en balayant un par un les
tuples/enregistrements.
Qu’est ce qu’un curseur?
Lorsqu'une application ou un utilisateur lance une instruction SQL, elle
effectue un appel d'analyse (parse call) à la base de données pour préparer
l'exécution de l'instruction faite par le processus serveur. Ce dernier crée
un curseur et alloue une zone SQL privée dans le PGA (Private Sql Area)
pour stocker les données spécifiques à la session pour l'instruction SQL,
telles que les valeurs des variables de liaison, l'état du curseur et le
contexte d'exécution.
Un curseur est un nom ou un pointeur
vers cette zone SQL privée.
Partage de curseur (Cursor
Sharing)
La zone Sql Privée pointe vers une zone Sql partagée située dans la zone
SQL partagée qui contient l’arbre d'analyse (soft / hard parse) et le plan
d'exécution de l'instruction.
Plusieurs zones SQL privées dans la même session ou dans des sessions
différentes peuvent faire référence à une seule zone SQL partagée, Ceci est
connu sous le nom de partage de curseur.
Par exemple, une exécution de SELECT * FROM employees dans une
session et une exécution de SELECT * FROM employees (accédant à la
même table) dans une session différente
peuvent utiliser le même plan d'analyse et
le même plan d’exécution. Une zone SQL
partagée à laquelle accèdent plusieurs
instructions est nommée curseur partagé.
Les types de curseurs
Il existe deux types de curseurs:
• Curseurs explicites: sont créés au cas ou le développeur a besoin de
traiter ligne par ligne le résultat des requêtes ayant un résultat sur
plusieurs lignes
• Curseurs Implicites : ce type de curseurs est créé implicitement par
le SGBD Oracle pour les autres cas, chaque ordre Sql (INSERT, DELETE
et UPDATE) et pour chaque requête SELECT qui ne ramène qu’une
seule ligne.
• N.B: Si on utilise la clause bulk collect avec l’ordre sql select into, un
cureur est créé implicitement ( même si le résultat est sur plusieurs
lignes). Ceci dans le but d’optimiser le traitement.
Utilisation d’un curseur
explicite
L’utilisation d’un curseur passe par quatre étapes:
1. Déclaration (DECLARE): Pour pouvoir manipuler un curseur explicite
il faut tout d’abord le déclarer dans le bloc DECLARE.
2. Ouverture (OPEN): Pour pouvoir travailler avec ce type de curseur il
faut l’ouvrir en utilisant la méthode OPEN.
3. Traitement (FETCH): On peut manipuler les données contenant dans
un curseur en utilisant la méthode FETCH
4. Fermeture (CLOSE): Après avoir fini le traitement des données
contenu dans le curseur on peut le fermer explicitement à l’aide de la
méthode CLOSE.
Déclaration d’un curseur
La déclaration d’un curseur permet de le nommer et de lui associer ainsi le
résultat d’une requête SELECT. Il est définit dans la partie DECLARE d’un
bloc Pl/Sql en suivant la syntaxe suivante:
CURSOR <nom_curseur> [ ( <nom_parametre> TYPE := <valeur_par_défaut> [ , . . . ])] IS
<requête_Select_SQL>;
Exemple:
Curseur simple sans arguments:
CURSOR cur_clients IS select * from clients;
Curseur avec arguments
CURSOR cur_clients (var_ville clients.ville%type) IS select * from clients where ville=var_ville;
Ouverture d’un curseur
L’ouverture du curseur permet d’exécuter l’ordre SQL associé à ce
dernier et d’allouer ainsi la zone mémoire nécessaire. Elle est faite dans la
partie BEGIN d’un bloc Pl/Sql en suivant la syntaxe suivante:
OPEN <nom_curseur> [ ( <parametre_entrée> [ , . . . ] ) ];
Exemple:
DECLARE
CURSOR cur_clients (var_ville clients.ville%type) IS select * from clients where ville=var_ville
BEGIN
OPEN cur_clients (var_ville =>’TETOUAN’);
…
END;/
L’ordre des paramètres d’un
curseur
Il existe deux types d’affectation de valeur aux paramètres:
1. Affectation par position: le paramètre effectif est substitué par la
valeur formelle
2. Affectation par nom: le paramètre actuel est substitué par la valeur
formelle à l'aide du symbole de flèche (=>)
L’ordre spécifié dans la déclaration des paramètres de curseur doit être
respecté lors de l’ouverture du curseur.
On peut mélanger les deux types d’affectation; cependant, la notation de
position doit précéder la notation nommée.
Exemple:
Exemple
Manipulation d’un curseur
Pour pouvoir manipuler les données extraites de l’exécution de la
requête, on utilise la méthode FETCH INTO qui permet de traiter une seule
ligne à la fois en suivant la syntaxe ci-dessous:
FETCH <nom_curseur> INTO { <nom_variable> | <nom_enregistrement> [ , . . . ] };
nom_variable correspond à une seule colonne et nom_enregistrement corresponds à toute la
ligne
Pour pouvoir récupérer toutes les lignes du curseur à la fois on peut
utiliser la méthode FETCH BULK COLLECT INTO en suivant la syntaxe ci-
dessous:
FETCH <nom_curseur> BULK COLLECT INTO <variable_enregistrement>;
variable_enregistrement corresponds à une tableau d’enregistrement.
Exemple:
Exemple
Etat d’un curseur
Pour pouvoir obtenir des informations sur les curseurs, il existe
quelques attributs propres à ces dernier:
• %ISOPEN: est un attribut de type booléen qui renvoie la valeur true si
le curseur est ouvert.
• %FOUND: est un attribut de type booléen qui renvoie la valeur true
tant que le FETCH ramène des lignes.
• %NOTFOUND: est un attribut de type booléen qui renvoie la valeur true
si le dernier FETCH n’a ramené aucune ligne.
• %ROWCOUNT: : est un attribut de type numérique qui renvoie le
nombre total ramenés jusqu’à présent.
Ces attributs sont conservés par Pl/Sql après l'exécution du curseur.
Fermeture d’un curseur
Après le traitement de données et pour pouvoir libérer l’espace
mémoire alloué au curseur il faut le fermer explicitement. Elle est faite
dans la partie BEGIN d’un bloc Pl/Sql en suivant la syntaxe suivante:
Close <nom_curseur>;
Exemple:
DECLARE
CURSOR cur_clients (var_ville clients.ville%type IS select * from clients where ville=var_ville;
BEGIN
OPEN cur_clients;
… Traitemet des lignes de données….
Close cur_clients;
END;/
Gestion automatique d’un
curseur
L’utilisation explicite d’un curseur peut se faire automatiquement par le
système via la boucle FOR et suivant la syntaxe ci-dessous:
FOR <nom_variable> IN <nom_curseur>
LOOP <liste_instructions> END LOOP ;
Pour ce cas de gestion automatique :
• L'ouverture et la fermeture du curseur sont implicites et il est
interdit de faire appel aux méthode OPEN et CLOSE.
• Les ordres FETCH sont inutiles
• les données manipulées sont référencées par :
<nom_variable>.<nom_attribut>
Exemple:
Exemple
Mise à jour des lignes d’un
curseur
Il est possible de modifier les enregistrements d’un curseur en utilisant
l’option FOR UPDATE, ce mot clé permet de verrouiller les enregistrements
d’un curseur pour les modifier. Ceci en suivant la syntaxe Ci-dessous:
CURSOR <nom_curseur> [ ( <nom_parametre> TYPE := <valeur_par_default> [ , . . . ] ) ]
IS <requête_SELECT_SQL> FOR UPDATE [ OF <nom_colonne> [ , . . . ] ]
Cela garantit que les lignes sont verrouillées pour empêcher leur
modification par d'autres sessions tant que la transaction en cours n'est
pas terminée, en garantissant ainsi l'intégrité et la cohérence des données.
On parle de verrou exclusif sur les lignes récupérées par le curseur
Exemple
