ISAMM

PL/SQL
Laboratoire RIADI-ENSI
 Avantages du PL/SQL
Portabilité
Déclaration des variables
Programmer avec des structures de
contrôle des langages procéduraux
(traitement conditionnel, traitement
répétitif, …)
Gestion des erreurs.
Déclarer des variables
 Structure d’un bloc
PL/SQL
DECLARE
DECLARE -Optionnel
-Optionnel
–Variables,
–Variables,curseurs,
curseurs,exceptions
exceptionsdéfinies
définiespar
parl’utilisateur.
l’utilisateur.
••BEGIN
BEGIN -Obligatoire
-Obligatoire
–Insructions
–InsructionsSQL
SQL
–Instuctions
–InstuctionsPL/SQL
PL/SQL
•EXCEPTION
•EXCEPTION -Optionnel
-Optionnel
–Actions
–Actionsààréaliser
réaliserlorsqu’une
lorsqu’uneerreur
erreurse
seproduit
produit
•END;
•END; -Obligatoire
-Obligatoire
 Structure d’un bloc
PL/SQL
DECLARE
DECLARE
v_variable
v_variable VARCHAR2(5);
VARCHAR2(5);
BEGIN
BEGIN
SELECT
SELECT nom_colonne
nom_colonne
INTO
INTO v_variable
v_variable
FROM
FROM nom_table;
nom_table;
•EXCEPTION
•EXCEPTION -Optionnel
-Optionnel
WHEN
WHENnom_exception
nom_exceptionTHEN
THEN
……
•END;
•END;
Utilisation des Variables
On utilise les variables pour :
Le stockage temporaire de données
La manipulation de valeurs stockées
La possibilité de réutilisation
Une maintenance plus facile
 Déclarer des Variables
PL/SQL
Syntaxe
Identifiant
Identifiant[CONSTANT]
[CONSTANT]datatype
datatype[NOT
[NOTNULL]
NULL]
[:=
[:=| |DEFAULT
DEFAULTexpr];
expr];

Exemples
Declare
Declare
v_hiredate
v_hiredate DATE;
DATE;
v_deptno
v_deptno NUMBER(2)
NUMBER(2)NOT
NOTNULL:=10;
NULL:=10;
v_location
v_location VARCHAR2(13)
VARCHAR2(13):=
:=‘Atlanta’;
‘Atlanta’;
c_comm
c_comm CONSTATNT
CONSTATNTNUMBER:=1400:
NUMBER:=1400:
 Déclarer des Variables
PL/SQL
Règles à suivre
Suivre des conventions de dénomination
Initialiser des variables définies avec la
contrainte NOT NULL
Initialisation à l’aide de l’opérateur
d’affectation (:=) ou du mot réservé
DEFAULT
Déclarer un seul identifiant par ligne.
 Types de données
Scalaires
VARCHAR2 (maximum_length)
NUMBER
DATE
CHAR [(maximum_length)]
LONG
BOOLEAN
BINARY_INTEGER
Déclaration des Variables
Scalaires
Exemples
v_job
v_job VARCHAR2(9);
VARCHAR2(9);
v_count
v_count BINARY_INTEGER
BINARY_INTEGER:= :=0;
0;
v_total_sal
v_total_sal NUMBER(9,2)
NUMBER(9,2):=0;
:=0;
V_orderdate
V_orderdate DATE
DATE:=
:=SYSDATE
SYSDATE+7;+7;
C_tax_rate
C_tax_rate CONSTANT
CONSTANTNUMBER(3,2)
NUMBER(3,2):= :=8.25;
8.25;
V_valid
V_valid BOOLEAN
BOOLEANNOT
NOTNULL
NULL:= :=TRUE;
TRUE;
 L’Attribut %TYPE
Déclarer une variable à partir de :
z La définition d’une colonne de la base de
données
z La définition d’une variable précédemment
déclarée
Préfixer %TYPE avec :
z La table et la colonne de la base
z Le nom de la variable précédemment
déclarée
 Déclarer des Variables
avec l’Attribut %TYPE

Exemples
…
…
v_name
v_name emp.ename%TYPE;
emp.ename%TYPE;
v_balance
v_balance NUMBER(7,2);
NUMBER(7,2);
v_min_balance
v_min_balance v_balance%TYPE
v_balance%TYPE:=
:=10;
10;
…
…
Référencer des Variables
non-PL/SQL

Stocker le salaire annuel dans une

variable hôte SQL*Plus
:g_monthly_sal
:g_monthly_sal:=
:=v_sal
v_sal//12;
12;
Référencer les variables non-PL/SQL
en tant que variables hôtes.
Préfixer les références de deux points
(:).
Exemple: calculer le salaire mensuel, basé sur le
salaire annuel fourni par l’utilisateur.
VARIABLE
VARIABLE g_monthly_sal
g_monthly_salNUMBER;
NUMBER;
ACCEPT
ACCEPT p_annual_sal
p_annual_sal PROMPT
PROMPT ‘Entrer
‘Entrerlelesalaire
salaireannuel
annuel: :‘‘

DECLARE
DECLARE
v_sal
v_sal NUMBER(9,2)
NUMBER(9,2):= :=&p_annual_sal;
&p_annual_sal;
BEGIN
BEGIN
:g_monthly_sal
:g_monthly_sal:=
:=v_sal
v_sal/ /12;
12;
END;
END;
//

PRINT
PRINT g_monthly_sal
g_monthly_sal
Opérateurs en PL/SQL

Logiques
Arithmétiques Identiques à
Concaténation ceux de SQL

Parenthèses pour contrôler l’ordre des

opérations
Opérateur exponentiel (**)
Opérateurs en PL/SQL
Incrémenter l’index pour une boucle.
V_count
V_count :=
:=v_count
v_count++1;
1;
Définir la valeur d’un indicateur
booléen. :=:=(v_n1
V_equal
V_equal (v_n1==v_n2);
v_n2);

Valider le numéro d’un employé s’il

contient une
V_valid
V_valid := valeurISISNOT
:=(v_empno
(v_empno NOTNULL);
NULL);
 Instructions SQL en
PL/SQL
Extraire une ligne de la base de données
grâce à la commande SELECT.Un seul jeu
de valeurs peut être retourné.
Modifier des lignes dans la base en utilisant
des commandes LMD.
Contrôler une transaction avec les
commandes COMMIT, ROLLBACK
Déterminer l’issue d’une commande LMD
avec des curseurs implicites.
Instructions SELECT en
PL/SQL
Extraire une ligne de la base de données
avec select
Syntaxe
SELECT
SELECT select_list
select_list
INTO
INTO {{variable_name
variable_name[,[,variable_name]
variable_name]…
…
| |record_name}
record_name}
FROM
FROM table
table
WHERE
WHERE condition;
condition;
Instructions SELECT en
PL/SQL
La clause INTO est obligatoire
Exemple
DECLARE
DECLARE
v_deptno
v_deptno NUMBER(2);
NUMBER(2);
v_loc
v_loc VARCHAR2(15);
VARCHAR2(15);
BEGIN
BEGIN
SELECT
SELECT deptno,
deptno,loc
loc
INTO
INTO v_deptno,
v_deptno,v_loc
v_loc
FROM
FROM dept
dept
WHERE
WHERE dname
dname== ‘SALES’;
‘SALES’;
…
…
END;
END;
Extraire des données en
PL/SQL
Extraire la date de commande et la date
d’expédition pour la commande spécifiée.
DECLARE
DECLARE
v_orderdate
v_orderdate ord.orderdate%TYPE;
ord.orderdate%TYPE;
v_shipdate
v_shipdate ord.shipdate%TYPE;
ord.shipdate%TYPE;
BEGIN
BEGIN
SELECT
SELECT orderdate,
orderdate,shipdate
shipdate
INTO
INTO v_orderdate
v_orderdatev_shipdate
v_shipdate
FROM
FROM ord
ord
WHERE
WHERE idid== 620;
620;
…
…
END;
END;
Extraire des données en
PL/SQL
Retourner la somme des salaires de
tous les employés du service spécifié.
DECLARE
DECLARE
v_sum_sal
v_sum_sal emp.sal%TYPE;
emp.sal%TYPE;
v_deptno
v_deptno NUMBER
NUMBERNOTNOTNULL
NULL:=
:=10;
10;
BEGIN
BEGIN
SELECT
SELECT SUM(SAL)
SUM(SAL) ----group
groupfunction
function
INTO
INTO v_sum_sal
v_sum_sal
FROM
FROM emp
emp
WHERE
WHERE deptno
deptno==v_deptno;
v_deptno;
…
…
END;
END;
Manipuler des données en
PL/SQL

Modifier le contenu des tables de la

base de données à l’aide des
commandes LMD suivantes:

INSERT
UPDATE
DELETE
 Insérer des données
Ajouter les informations concernant un
nouvel employé à la table emp.
Exemple

BEGIN
BEGIN
INSERT
INSERTINTO
INTOemp(empno,
emp(empno,ename,
ename,job,
job,deptno)
deptno)
VALUES
VALUES(50,’HARDING’,
(50,’HARDING’,‘CLERK’,
‘CLERK’,10);
10);
End;
End;
 Mettre à jour des
données
Augmenter le salaire de tous les
employés de la table emp dont la
fonction est analyste.
Exemple
DECLARE
DECLARE
v_sal_increase
v_sal_increase emp.sal%TYPE
emp.sal%TYPE:=
:=2000;
2000;
BEGIN
BEGIN
UPDATE
UPDATE emp
emp
SET
SET sal
sal==sal
sal++v_sal_increase
v_sal_increase
WHERE
WHERE job
job==‘ANALYST’;
‘ANALYST’;
END;
END;
Supprimer des données
Supprimer les enregistrements dont le
département est le 10 dans la table
emp.
Exemple
DECLARE
DECLARE
v_deptno
v_deptno emp.deptno%TYPE
emp.deptno%TYPE:= :=10;
10;
BEGIN
BEGIN
DELETE
DELETE FROM
FROM emp
emp
WHERE
WHERE deptno
deptno==v_
v_deptno;
deptno;
END;
END;
 Instructions
COMMIT et ROLLBACK

Une transaction est initialisée par la

première commande LMD, et doit être
suivi d’un COMMIT ou d’un
ROLLBACK.
Utilisez les instructions SQL COMMIT
ou ROLLBACK pour terminer de façon
explicite une transaction.
Structures de Contrôle
 Le processus
d’exécution PL/SQL
Vous pouvez modifier l’enchaînement
logique des instructions en utilisant des
instructions conditionnelles IF ou des
structures de boucles.
Instructions conditionnelles IF:
IF-THEN-END-IF
IF-THEN-ELSE-END-IF
IF-THEN-ELSIF-END-IF
 Instructions IF
Syntaxe
IF
IFcondition
conditionTHEN
THEN instructions;
instructions;
[ELSIF
[ELSIFcondition
conditionTHEN
THEN instructions;]
instructions;]
[ELSE
[ELSE instructions;]
instructions;]
END
ENDIF;
IF;
Instruction IF simple:
Si le nom de l’employé est Osborne, lui associer le numéro
de manager 22.
IF v_ename = ‘OSBORNE’ THEN
v_mgr := 22;
END IF;
 Contrôles Itératifs:
instructions LOOP

Les boucles permettent de réaliser

plusieurs fois une instruction ou une
séquence d’instructions.
Il y a trois types de boucles :
z La boucle Basique
z La boucle FOR

z La boucle WHILE
 Boucles Basiques
Syntaxe
LOOP
LOOP
instruction1;
instruction1;
......
EXIT
EXIT [WHEN
[WHENcondition];
condition];
END
ENDLOOP;
LOOP;

Où
Où:: condition
conditionest
estune
unevariable
variablebooléenne
booléenneou
ouune
uneexpression
expression
 Boucles Basiques
Exemple
DECLARE
DECLARE
v_ordid
v_ordid item.ordid.%TYPE
item.ordid.%TYPE:= :=601;
601;
v_counter
v_counter NUMBER(2)
NUMBER(2) := :=1;
1;
BEGIN
BEGIN
LOOP
LOOP
INSERT
INSERTINTO
INTOitem(ordid,
item(ordid,itemid)
itemid)
VALUES
VALUES(v_ordid,
(v_ordid,v_counter);
v_counter);
v_counter
v_counter:=
:=v_counter
v_counter++1;1;
EXIT
EXITWHEN
WHENv_counter
v_counter>>10;
10;
END
ENDLOOP;
LOOP;
END;
END;
 Boucles FOR
Syntaxe

FOR
FORcounter
counterin
in[REVERSE]
[REVERSE]
borne_inférieure..borne_supérieure
borne_inférieure..borne_supérieureLOOP
LOOP
instruction1;
instruction1;
instruction2;
instruction2;
......
END
ENDLOOP; LOOP;

Le compteur est déclaré implicitement

 Boucles WHILE
Syntaxe

WHILE
WHILEcondition
condition LOOP
LOOP
instruction1;
instruction1;
instruction2;
instruction2;
......
END
ENDLOOP; LOOP;
Travailler avec des
types de données
Composés
 PL/SQL Records
Ils sont composés d’un ou plusieurs
champs de types: scalaire, RECORD
Ils traitent un ensemble de Champs
comme une unité logique.
Ils sont pratiques pour extraire et
manipuler une ligne d’une table de la
base.
Créer un Record PL/SQL
Syntaxe
TYPE
TYPEtype_nom
type_nomIS ISRECORD
RECORD
(field_declaration
(field_declaration[,[,field_declaration]…);
field_declaration]…);
Identifier
Identifiertype_name;
type_name;

Où field_declaration est
Field_name
Field_name{field_type
{field_type| |variable%TYPE
variable%TYPE
| |table.column%TYPE
table.column%TYPE| |table%ROWTYPE}
table%ROWTYPE}
[[NOT
[[NOTNULL]
NULL]{:=
{:=| |DEFAULT}
DEFAULT}expr]
expr]
Créer un Record PL/SQL
Exemple
……
TYPE
TYPEemp_record_type
emp_record_typeIS
ISRECORD
RECORD
(ename
(ename VARCHAR2(10)
VARCHAR2(10),,
job
job VARCHAR2(9),
VARCHAR2(9),
sal
sal NUMBER(7,2));
NUMBER(7,2));
emp_record
emp_record emp_record_type;
emp_record_type;
……
 L’attribut %ROWTYPE
Il permet de définir une variable à partir d’un
ensemble de colonnes d’une table ou d’une
vue de la base de données.
Préfixer %ROWTYPE par le nom de la table
ou de la vue.
Les champs du Record prennent les Noms et
les Types des colonnes de la table ou de la
vue.
DECLARE
DECLARE
emp_record
emp_record emp%ROWTYPE;
emp%ROWTYPE;
Écrire des curseurs
Explicites
 A propos des Curseurs
Chaque instruction SQL exécutée a son
propre curseur individuel qui lui est
associé :
Curseurs implicites : déclarés pour
toutes les instructions LMD et SELECT
PL/SQL
Curseurs explicites : déclarés et
nommés par le programmeur.
 Fonctionnement des
curseurs Explicites

Ensemble actif de lignes

(Active Set)

7369
7369 SMITH
SMITH CLERK
CLERK
7566
7566 JONES
JONES MANAGER
MANAGER Ligne
Curseur
Curseur 7788
7788 SCOTT
SCOTT ANALYST
ANALYST
7876
7876 ADAMS
ADAMSCLERK
CLERK courante
7902
7902 FORD
FORD ANALYST
ANALYST
 Contrôler les Curseurs
Explicites
oui

non

OPEN

EX
DECLARE FETCH CLOSE

IS
T?
Créer une Identifier Charger la -Tester Linérer
zone SQL l’ensmble ligne courante l’existence l’ ensemble
nommée actif de dans les de lignes actif
lignes variables - si OUI,
Retourner à FETCH
 Ouvrir un Curseur
Syntaxe
OPEN
OPEN cursor_name;
cursor_name;
Ouvrir le curseur pour exécuter la requête et
identifier l’Ensemble de lignes actif.
Si la requête ne retourne pas de lignes,
aucune exception n’est signalée.
Utilisez les attributs du curseur pour tester le
résultat après affectation.
 Ramener les données à
partir du Curseur
Syntaxe
FETCH
FETCHcursor_name
cursor_nameINTO
INTO[variable1,
[variable1,variable2,
variable2,…]
…]
| |record_name];
record_name];
Chargez les valeurs de la ligne courante dans
des variables de sortie.
Prévoir le même nombre de variables.
Ajuster la position des variables par rapport
aux colonnes.
Tester si le curseur contient des lignes.
Ramener les données à
partir du Curseur
Exemple: ramener les 10 premiers employés
DECLARE
DECLARE
v_empno
v_empnoemp.empno%TYPE;
emp.empno%TYPE;
v_ename
v_ename emp.ename%TYPE;
emp.ename%TYPE;
CURSOR
CURSORemp_cursor
emp_cursorIS
IS
SELECT empno,ename
SELECT empno,ename
FROM
FROM emp; emp;
BEGIN
BEGIN
OPEN
OPENemp_cursor;
emp_cursor;
FOR
FOR i i IN
IN 1..10
1..10 LOOP
LOOP
FETCH
FETCH emp_cursor
emp_cursor INTO
INTOv_empno,
v_empno,v_ename;
v_ename;
……
END
ENDLOOP;
LOOP;
END;
END;
 Fermer un Curseur
Syntaxe
CLOSE
CLOSE cursor_name;
cursor_name;

Fermer le curseur après avoir terminé le

traitement des lignes.
N’essayer pas de ramener les données
d’un curseur s’il a été fermé.
Attributs d’un curseur SQL
Grâce aux attributs d’un curseur SQL, vous
pouvez tester l’issue de vos instructions SQL.
SQL%ROWCOUNT Nombre d’enregistrements traités
par la dernière instruction SQL
(une valeur entière)

SQL%FOUND Attribut booléen qui vaut TRUE si

la dernière instruction SQL a
traité un ou plusieurs
enregistrements

SQL%NOTFOUND Attribut booléen qui vaut TRUE si

la dernière instruction SQL n’ a
traité aucun enregistrements

SQL%ISOPEN Vaut toujours FALSE car PL/SQL

ferme les curseurs implicites
immédiatement après leur
exécution
 Attributs d’un curseur
SQL
Exemple : ramener les 10 premiers employés
DECLARE
DECLARE
v_empno
v_empnoemp.empno%TYPE;
emp.empno%TYPE;
v_ename
v_ename emp.ename%TYPE;
emp.ename%TYPE;
CURSOR
CURSORemp_cursor
emp_cursorISIS
SELECT
SELECTempno,ename
empno,ename
FROM
FROM emp; emp;
BEGIN
BEGIN
OPEN
OPENemp_cursor;
emp_cursor;
FOR
FOR i i IN
IN 1..10
1..10 LOOP
LOOP
FETCH
FETCH emp_cursor
emp_cursor INTO
INTOv_empno,
v_empno,v_ename;
v_ename;
EXIT
EXITWHEN
WHENemp_cursor%ROWCOUNT
emp_cursor%ROWCOUNT>>10 10
OR
OR emp_cursor%NOTFOUND;
emp_cursor%NOTFOUND;
……
END
ENDLOOP;
LOOP;
CLOSE
CLOSE emp_cursor;
emp_cursor;
END;
END;
 Curseurs et Records
Traiter les lignes de l’ensemble actif en
ramenant les valeurs dans un RECORD
PL/SQL
DECLARE
DECLARE
CURSOR
CURSORemp_cursor
emp_cursorIS
IS
SELECT
SELECTempno,ename
empno,ename
FROM
FROM emp;
emp;
emp_recored
emp_recored emp_cursor%ROWTYPE;
emp_cursor%ROWTYPE;
BEGIN
BEGIN
OPEN
OPENemp_cursor;
emp_cursor;
LOOP
LOOP
FETCH
FETCH emp_cursor
emp_cursor INTO
INTO emp_record;
emp_record;
……
END
ENDLOOP.
LOOP.
END;
END;
 Curseur dans une boucle
FOR
Syntaxe
FOR
FORrecord_name
record_nameIN INcursor_name
cursor_nameLOOP
LOOP
statement1;
statement1;
statement2;
statement2;
......
END
ENDLOOP;
LOOP;

Simplification d’écriture pour les curseurs

implicites.
Ouverture, fetch et fermeture implicite du
curseur.
Le record est déclaré implicitement.
Curseur dans une boucle
FOR
Exemple
DECLARE : ramener tous employés un à
DECLARE
CURSOR
CURSORemp_cursor
emp_cursorIS
IS
un SELECT
SELECTempno,ename
empno,ename
FROM
FROM emp;
emp;
BEGIN
BEGIN
FOR
FOR emp_record
emp_record IN
INemp_cursor
emp_cursorLOOP
LOOP
IF ……….
IF ………. … …
…..
…..
END
ENDLOOP;
LOOP;

END;
END;