Cours PLSQL +++

Bases de Données Avancées
PL/SQL
Thierry Hamon
Bureau H202
Institut Galilée - Université Paris 13
&
LIMSI-CNRS
hamon@limsi.fr
https://perso.limsi.fr/hamon/Teaching/P13/BDA-INFO2-2018-2019/
INFO2 – BDA
1/185
Communication avec un SGBD utilisant SQL
2/185
Solution complète Oracle
3/185
Clauses SQL
SELECT Interrogation des données
INSERT
UPDATE Langage de Manipulation de Données (LMD)
DELETE
CREATE
ALTER
DROP Langage de Définition de Données (LDD)
RENAME
TRUNCATE
GRANT Langage de Contrôle de Données (LCD)
REVOKE
COMMIT
ROLLBACK Contrôle de transaction
SAVEPOINT
4/185
PL/SQL
Procedural Language for Structured Query Language
Langage fournissant une interface procédurale au SGBD

Oracle
Intègration du langage SQL en lui apportant une dimension
procédurale
Réalisation de traitements algorithmiques (ce que ne permet
pas SQL)
Mise à disposition de la plupart des mécanismes classiques de
programmation des langages hôtes tels que C, COBOL,
PASCAL, C++, JAVA ...
5/185
Environnement PL/SQL
6/185
Avantages de PL/SQL
PL/SQL complément de SQL (qui n’est pas procédural)
Mécanismes offerts par PL/SQL :
Structures itératives : WHILE *** LOOP, FOR *** LOOP,
LOOP ***
Structures conditionnelles :
IF *** THEN *** ELSE | ELSEIF *** ENDIF, CASE ***
Déclaration des curseurs et des tableaux
Déclaration de variables
Affectation de valeurs aux variables
Branchements : GOTO, EXIT
Exceptions : EXCEPTION
7/185
Avantages de PL/SQL
Intégration
Meilleure cohérence du code avec les données
Utilisation de librairies standards prédéfinies (bibliothèques
partagées)
8/185
Avantages de PL/SQL
Blocs SQL
Traitement par/de blocs SQL dans un énoncé PL/SQL
(optimisation des transactions réseaux)
9/185
Avantages de PL/SQL
Exécution de programmes modulaires
Traitements complexes (cas particuliers, erreurs)
Traitements des exceptions
...
10/185
Avantages de PL/SQL
Résumé
Langage portable
Utilisation de variable de stockage
Utilisation de type simple ou de type structuré
dynamiquement (%TYPE, %ROWTYPE, etc.)
Utilisation des structures de contrôle des langages procéduraux
Gestion et manipulation des erreurs
Création d’ordre SQL dynamique
11/185
Utilisation de PL/SQL
3 formes :
Bloc de code, executé comme une commande SQL (utilisation
d’un interpréteur standard SQL+ ou iSQL*PLus)
Fichier de commandes PL/SQL
Programme stocké : procédure, fonction, package ou trigger
12/185
Structure d’un bloc PL/SQL
−− S e c t i o n d é c l a r a t i v e , o p t i o n n e l l e
DECLARE
Variables , curseurs , exceptions , ...
−− S e c t i o n e x é c u t a b l e , o b l i g a t o i r e
BEGIN
I n s t r u c t i o n s SQL e t PL/SQL
P o s s i b i l i t é s de b l o c s f i l s ( i m b r i c a t i o n de b l o c s )
−− S e c t i o n de t r a i t e m e n t d e s e x c e p t i o n s , o p t i o n n e l l e
EXCEPTION o p t i o n n e l l e
Traitement des e x c e p t i o n s ( g e s t i o n des e r r e u r s )
−− T e r m i n a i s o n du b l o c , o b l i g a t o i r e
END ;
/
13/185
Type de blocs
Bloc anonyme
Procédure
Fonction
14/185
Type de blocs
Bloc anonyme
Structure classique (1 à 3 sections)

Un bloc ne peut être vide. Il doit contenir une instruction (il
peut donc contenir l’instruction NULL)
[ DECLARE ]
BEGIN
Instructions
[ EXCEPTION]
END;
/
15/185
Type de blocs
Bloc anonyme – Exemple 1
DECLARE x INTEGER ;
BEGIN
x := 1 ;
END;
16/185
Type de blocs
Bloc anonyme – Exemple 2
DECLARE
var x VARCHAR2( 5 ) .
BEGIN
SELECT n o m c o l o n n e
INTO var x
FROM nom table
EXCEPTION
WHEN n o m e x c e p t i o n THEN
...
END ;
/
17/185
Type de blocs
Procédure
Bloc PL/SQL nommé

puis compilé et stocké dans la base
PROCEDURE nom IS
BEGIN
Instructions
[ EXCEPTION]
END;
/
18/185
Type de blocs
Procédure – Exemple
PROCEDURE p r o c e x e m p l e IS
var x VARCHAR2( 5 ) ;
BEGIN
SELECT n o m c o l o n n e
INTO var x
FROM nom table
EXCEPTION
WHEN n o m e x c e p t i o n THEN
...
END ;
/
→ Commande SQL qui
crée la procédure PL/SQL
compile et stocke dans la base le bloc PL/SQL compris entre le BEGIN et
le END, référencé par ’proc exemple’
19/185
Type de blocs
Procédure
Remarques :
Exécution (auto) de la procédure :
SQL> EXECUTE proc_exemple
Pas d’exécution de procédure (ou d’instructions) en fin de
transaction (COMMIT, ROLLBACK, Ordre DDL)
Décision d’enregistrement ou d’annulation de la transaction en
cours : à réaliser par le programme appelant la procédure
20/185
Type de blocs
Fonction
Fonction : procédure retournant une valeur

FUNCTION nom RETURN t y p e d o n n é e s I S
BEGIN
Instructions
RETURN v a l e u r ;
[ EXCEPTION]
END;
/
21/185
Type de blocs
Fonction – exemple
SQL> CREATE OR REPLACE FUNCTION s o l d e ( no INTEGER)

RETURN REAL I S l e s o l d e REAL ;
BEGIN
SELECT s o l d e INTO l e s o l d e FROM c l i e n t s
WHERE n o c l i = no ;
RETURN l e s o l d e ;
END;
/
22/185
Type de blocs
Fonction
Remarques :
Utilisation de fonction au sein d’une requête SQL
Exemple :
SQL> SELECT solde(1000) FROM dual ;
Solde(1000)
-----------
12024,50
Appel d’une fonction comme une procédure provoque une erreur
Exemple : fonction mdp(INTEGER)
SQL> execute mdp(2);
BEGIN mdp(2); END;
*
ERREUR a la ligne 1 :
ORA-06550: line 1, column 7:
PLS-00221: ’MDP’ is not a procedure or is undefined
ORA-06550: line 1, column 7:
23/185
Types de variables
Variables locales
Constantes
Composites
Références
Variables de l’environnement extérieur à PL/SQL
Attachées (Bind)
Hôtes (Host)
24/185
Déclaration des variables en PL/SQL
Syntaxe
I d e n t i f i c a t e u r [CONSTANT] t y p e d o n n é e s [NOT NULL]
[:= e x p r e s s i o n ] ;
Exemple
DECLARE
v datenaissance DATE;
v departement NUMBER( 2 ) NOT NULL := 1 0 ;
v ville VARCHAR2( 1 3 ) := ’ P a r i s ’ ;
c cumul CONSTANT NUMBER := 1 0 0 0 ;
25/185
Assignation des variables
Syntaxe
Identificateur := expr ;
Exemples
Affecter la date de naissance du fils d’un employés
v datenaissance := ’ 23−SEP−2004 ’ ;
Fixer le nom d’un employé à ’Clément’
v nom := ’ Clément ’ ;
26/185
Types de données scalaires
Types de base – chaı̂nes de caractères
VARCHAR2(n)/NVARCHAR2(n) : Chaı̂ne de n caractères

(n < 4000octets) – longueur variable
(préfixe N : prise en compte de la localisation – NLS/National
Language Support)
CHAR(n)/NCHAR(n) : Chaı̂ne de n caractères
(n < 2000octets) – longueur fixe, rempli par des espaces
LONG/RAW/LONG RAW : Chaı̂ne de caractère ou de données
binaires (raw ) de longueur variable ( < 2000octets)
27/185
Types de données scalaires
Types de base – nombres et date
NUMBER (n , m) : Réel avec n chiffres significatifs et m décimals
INTERGER/FLOAT : Nombre entier/réel signé
BINARY_INTEGER : Nombre entier signé sur 32 bits (utilisation de la
librairie mathématique)
DATE : date entre le 1 janvier -4712 et le 21 décembre 9999
BOOLEAN : booléen
NB : pas d’équivalent en SQL.
Il n’est donc pas possible
de stocker un booléen dans une table
de sélectionner un élément de table dans un variable booléenne
d’utiliser un booléen dans une requête SQL ou une fonction
PL/SQL appelée dans une requête SQL (paramètre en entrée ou
valeur de retour)
28/185
Déclaration des variables scalaires
Exemples
v job VARCHAR2( 9 ) .
v count BINARY INTEGER := 0 ;
v sal total NUMBER( 9 , 2 ) .
v date DATE := SYSDATE +7;
v tauxtaxe CONSTANT NUMBER( 3 , 2 ) := 8 . 2 5 ;
v valide BOOLEAN NOT NULL := TRUE;
29/185
Attribut %TYPE
Définition : déclaration d’une variable associée à

Une colonne d’une table dans la BD
Une variable précédemment définie
Exemples :
v nom emp . nom%TYPE ;
v sal annuel NUMBER( 7 , 2 ) ;
v sal mensuel v s a l a n n u e l %TYPE := 2 0 0 0 ;
30/185
Types de données composites
Types :
Les tables PL/SQL
Les records PL/SQL

(voir plus loin)
31/185
Variables attachées/Bind variables
Variables de substitution dans les requêtes SQL
Variable référençant des variables non-PL/SQL
Economie d’analyse de la requête, donc gain de temps pour
Oracle
→ Mécanisme considéré par certains comme le point clé de
performance d’Oracle
32/185
Déclaration
Déclaration, en SQL*Plus, d’une variable attachée : utilisation de

la commande VARIABLE
Exemple :
VARIABLE n o m v a r i a b l e t y p e v a r i a b l e ;
VARIABLE g s a l m e n s u e l NUMBER( 7 , 2 ) ;
33/185
Référence aux variables non-PL/SQL
Exemple :
Stocker le salaire mensuel dans une variable globale SQL*Plus
: g s a l m e n s u e l := v s a l a n n u e l / 1 2 ;
Faire référence aux variables non-PL/SQL comme des variables

hôte
Précéder la référence par un ’ : ’
34/185
Exemple d’utilisation – optimisation
Exemple de requête SELECT générées des milliers de fois :

SELECT fname , lname , pcode FROM c u s t WHERE i d = 6 7 4 ;
...
A chaque soumission d’un requête,
Vérification si la requête a déjà été été soumise
Si oui, récupération du plan d’exécution de la requête, et
exécution de la requête
35/185
Exemple d’utilisation – optimisation
Si non,
analyse syntaxique de la requête
définition des différentes possibilités d’exécution
définition du plan d’exécution optimal
→ Processus coûteux en temps CPU, alors que seule la valeur
de id change !
Solution : réutiliser le plan d’exécution existant
→ Nécessite d’utiliser des variables attachées :
Substitution de la valeur par la variable attaché
Envoi de la même requête pour toutes les valeurs de id
Exemple :
SELECT fname , lname , p c o d e FROM c u s t WHERE i d = : c u s t n o ;
36/185
Bloc PL/SQL
syntaxe et directives
Les instructions peuvent être écrites sur plusieurs lignes.

Les unités lexicales peuvent être séparées par des espaces :
Délimiteurs
Identificateurs
Littéraux (ou constantes)
Commentaires
37/185
Bloc PL/SQL
syntaxe et directives
Les littéraux
Les dates et les chaı̂nes de caractères délimitées par deux
simples cotes
V nom := ’ T h i e r r y ’ ;
v a n n e e := t o n u m b e r ( t o c h a r ( v D a t e F i n P e r i o d e , ’YY ’ ) ) ;
Les nombres peuvent être des valeurs simples ou des

expressions
V s a l a i r e := 1500 + 300 ;
38/185
Commentaires dans le code
Précéder un commentaire écrit sur une seule ligne par ’--’.

Placer un commentaire écrit sur plusieurs lignes entre les
symboles ’/*’ et ’*/’.
Exemple :
v sal NUMBER( 9 , 2 ) ;
BEGIN
/∗ C e c i e s t un c o m m e n t a i r e q u i p e u t
e t r e e c r i t s u r p l u s i e u r s l i g n e s ∗/
ENd ; −− C e c i e s t un c o m m e n t a i r e s u r une l i g n e
39/185
Les Fonctions SQL en PL/SQL
Les fonctions sur les nombres

Les fonctions sur les chaı̂nes de caractères
Les fonctions de conversion de type de données
Les fonctions de dates
40/185
Exemples de fonctions SQL en PL/SQL
Exemples :
Recomposer l’adresse d’un employé :
V A drC om pl et e : = V Rue | | CHR( 3 2 ) | | V V i l l e | | CHR( 3 2 ) | |
V CodePostal ;
Convertir le nom en majuscule

V Nom := UPPER ( V Nom ) ;
Extraction d’une partie de la chaı̂ne

V c h r := Substr ( ’ PL/SQL ’ , 4 , 3 ) ;
Replacement d’une chaı̂ne par une autre

V c h r := R e p l a c e ( ’ S e r v 1 / Prod / t b c l i e n t ’ , ’ Prod , ’ V a l i d ’ ) ;
41/185
Blocs imbriqués et porté des variables
...
x BINARY INTEGER ;
BEGIN −− Debut de l a p o r t e e de x
...
DECLARE
y NUMBER;
BEGIN −− d e b u t de l a p o r t e de y
...
END; −− f i n de l a p o r t e e de y
...
END; −− f i n de l a p o r t e e de x
42/185
Opérateurs dans PL/SQL
Identique à SQL
Logique
Arithmétique
Concaténation
Parenthèses pour contrôler l’ordre des opérations
Opérateur supplémentaire : Opérateur d’exponentiation **
43/185
Utilisation des variables liées
Pour référencer une variable en PL/SQL, on doit préfixer son

nom par un ’:’
Exemple :
: c o d e r e t o u r := 0 ;
I F v é r i f i e r c r é d i t o k ( compt no ) THEN
: c o d e r e t o u r := 1 ;
END I F ;
44/185
Instructions SQL dans PL/SQL
Extraire une ligne de données à partir de la BD par la

commande SELECT. Un seul ensemble de valeurs peut être
retourné
Effectuer des changements aux lignes dans la BD par les
commandes du LMD
Contrôler des transactions avec les commandes COMMIT,
ROLLBACK et SAVEPOINT
Déterminer les résultats du LMD avec des curseurs implicites
(voir plus loin)
45/185
Instruction SELECT dans PL/SQL
Récupérer une donnée de la BD avec SELECT.

Syntaxe
SELECT l i s t e s é l e c t i o n
INTO { nom var [ , nom var ] . . .
| nom record }
FROM table
WHERE condition ;
46/185
La clause INTO est obligatoire
Exemple
DECLARE
v deptno NUMBER( 2 ) ;
v loc VARCHAR2( 1 5 ) ;
BEGIN
SELECT deptno , l o c
INTO v deptno , v l o c
FROM dept
WHERE nom d = ’INFORMATIQUE ’ ;
...
END;
47/185
Retourne la somme des salaires de tous les employés d’un

département donné.
Exemple
DECLARE
v som sal emp . s a l%TYPE ;
v deptno NUMBER NOT NULL := 1 0 ;
BEGIN
SELECT sum ( s a l ) −−f o n c t i o n d ’ a g r é g a t
INTO v som sal
FROM emp
WHERE deptno = v deptno ;
END;
48/185
Manipulation de données en PL/SQL
Effectuer des mises à jour des tables de la BD utilisant les

commandes du LMD :
INSERT
UPDATE
DELETE
49/185
Insertion de données
Ajouter les informations d’un nouvel employé à la table emp

Exemple
DECLARE
v empno NUMBER NOT NULL := 1 0 5 ;
BEGIN
INSERT INTO emp ( empno , emp nom , p o s t e , d e p t n o )
VALUES ( v empno , ’ C lé m e n t ’ , ’ D i r e c t e u r ’ , 1 0 ) ;
END;
50/185
Mise à jour de données
Augmenter le salaire de tous les employés dans la table emp

qui ont le poste d’enseignant.
Exemple
DECLARE
v augm sal emp . s a l%TYPE := 2 0 0 0 ;
BEGIN
UPDATE emp
SET s a l := s a l + v a u g m s a l
WHERE job = ’ Enseignant ’ ;
END; 1
51/185
Suppression de données
Suppression des lignes appartenant au département 10 de la

table emp
Exemple
DECLARE
v deptno emp . d e p t n o%TYPE := 1 0 ;
BEGIN
DELETE FROM emp
WHERE deptno = v deptno ;
END;
52/185
Structure de contrôle dans PL/SQL
IF conditionnel :
IF THEN END I F ;
IF THEN ELSE END I F ;
IF THEN ELSIF END I F ;
Les boucles :
LOOP END LOOP ;
FOR LOOP END LOOP ;
WHILE LOOP END LOOP ;
53/185
Instruction IF
Syntaxe
I F c o n d i t i o n THEN
é n o n cé s ;
[ ELSIF c o n d i t i o n THEN
é n o n cé s ; ]
[ ELSE
é n o n cé s ; ]
END I F ;
54/185
Instruction IF
Exemple de IF simple
Mettre le ID de l’employé ’MARK’ à 101.

I F v nom = ’MARK ’ THEN
v I D := 1 0 1 ;
END I F ;
55/185
IF simple
Si le nom de l’employé est ’CLEMENT’, lui attribuer le poste

’Enseignant’, le département n◦ 102 et une commission de 25
% sur son salaire actuel
Exemple
...
I F v nom = ’ Clément ’ THEN
v p o s t e := ’ E n s e i g n a n t ’ ;
v d e p t n o := 1 0 2 ;
v nouv comm := s a l ∗ 0 . 2 5 ;
END I F ;
...
56/185
IF-THEN-ELSE
Si le nom de l’employé est ’CLEMENT’, lui attribuer le poste
’Enseignant’, le département n◦ 102 et une commission de 25
% sur son salaire actuel, sinon afficher le message ’Employé
inexistant’
Exemple
...
I F v nom = ’ Clément ’ THEN
v p o s t e := ’ E n s e i g n a n t ’ ;
v d e p t n o := 1 0 2 ;
v nouv comm := s a l ∗ 0 . 2 5 ;
ELSE
DBMS OUTPUT . PUT LINE ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
...
57/185
IF-THEN-ELSIF
Pour une valeur donnée en entrée, retourner une valeur

calculée
Exemple
...
IF v d e b u t > 100 THEN RETURN ( 2 ∗ v d e b u t ) ;
ELSIF v d e b u t >= 50 THEN RETURN ( 5 ∗ v d e b u t ) ;
ELSE RETURN ( 1 ∗ v d e b u t ) ;
END I F ;
...
58/185
CASE
Exemple :
s e l e c t i d b c r e x p o , i d g e s t f i n , rownum ,
c a s e when rownum <= 50 t h e n ’ 1−50 rownum ’ | | rownum
when rownum <= 100 t h e n ’ 51−100 rownum ’ | | rownum
e l s e ’ p l u s de 100 ’ end
from b c r i . t b g s t f i n a n c e m e n t
where rownum <= 100
Cette requête permet de retourner un contenu dans une colonne en

fonction d’une condition
59/185
Boucle de base
Syntaxe
LOOP −− d é l i m i t e u r
é n o n cé 1 ; −− é n o n cé
....
EXIT [ WHEN c o n d i t i o n ] ; −− é n o n cé EXIT
END LOOP ;
When : condition est une variable booléenne ou expression (TRUE,

FALSE, ou NULL);
60/185
Boucle de base
Exemple
Insérer 10 articles avec la date d’aujourd’hui.
...
v Date DATE;
v compteur NUMBER( 2 ) := 1 ;
BEGIN
...
v D a t e := SYSDATE ;
LOOP
INSERT INTO a r t i c l e ( Artno , ADate )
VALUES ( v c o m p t e u r , v D a t e ) ;
v c o m p t e u r := v c o m p t e u r + 1 ;
EXIT WHEN v c o m p t e u r > 1 0 ;
END LOOP ;
...
61/185
Boucle FOR
Syntaxe
FOR i n d i c e IN [ REVERSE ]
b o r n e i n f . . B o r n e s u p LOOP
é n o n cé 1 ;
é n o n cé 2 ;
.....
END LOOP ;
Utiliser la boucle FOR pour raccourcir le test d’un nombre

d’itérations
Ne pas déclarer l’indice, il est déclaré implicitement
62/185
Boucle FOR
exemple
Insérer Nb articles indexés de 1 à Nb avec la date du système en
utilisant la boucle FOR
ACCEPT Nb PROMPT ’ Donner l e nombre a r t i c l e : ’
...
v D a t e DATE;
BEGIN
...
FOR i IN 1 . . &Nb LOOP
VALUES ( i , v D a t e ) ;
END LOOP ;
...
63/185
Boucle WHILE
Syntaxe
WHILE condition LOOP

é n o n cé 1 ;
é n o n cé 2 ;
.....
END LOOP ;
La condition est évaluée au début de chaque itération

Utiliser la boucle WHILE pour répéter des énoncés tant que la
condition est vraie
64/185
Boucle WHILE
Exemple
ACCEPT p i t e m t o t PROMPT ’ Donner l e t o t a l max de l ’ ’ a c h a t

d ’ ’ un a r t i c l e ’
DECLARE
v Date DATE ;
v compteur NUMBER( 2 ) := 1 ;
BEGIN
...
WHILE v c o m p t e u r <= &p i t e m t o t LOOP
VALUES ( v c o m p t e u r , v D a t e ) ;
END LOOP ;
65/185
Boucles imbriquées et Labels
Imbriquer les boucles à niveaux multiples

Utiliser les labels pour distinguer les blocs et les boucles
Quitter la boucle extérieure avec un EXIT référençant le label
66/185
Boucles imbriquées et Labels
....
BEGIN
<< b o u c e x t >>
LOOP
EXIT WHEN v c o m p t e u r > 1 0 ;
<<b o u c i n t >>
LOOP
...
EXIT b o u c e x t WHEN t o t a l f a i t = ’ OUI ’ ;
−− q u i t t e r l e s deux b o u c l e s
EXIT WHEN i n t f a i t = ’ OUI ’ ;
−− q u i t t e r l a u n i q u e m e n t l a b o u c l e i n t e r n e
...
END LOOP b o u c i n t ;
...
END LOOP b o u c e x t ;
END;
...
67/185
Types de données complexes
Types :
RECORDS
TABLES
Contiennent des composants internes
Sont réutilisables
68/185
Records PL/SQL
Contiennent des champs qui sont soit des scalaires, des

records ou des tables PL/SQL
Structure similaire à des enregistrements dans les langages de
programmation classiques
Très utiles pour rechercher des lignes de données dans une
table et les traiter
69/185
Création d’un record PL/SQL
Syntaxe
TYPE <Nom Enreg> I S RECORD
( Champ1 Type1
.
.
ChampN TypeN ) ;
Exemple
TYPE TProd I S RECORD
(
VRefPro NUMBER( 4 ) ,
VDesPro VARCHAR2( 3 0 ) ,
VPriUni NUMBER( 7 , 2 )
);
70/185
Attribut %ROWTYPE
Déclaration d’une variable associée à une collection de

colonnes dans une table ou une vue de la BD
le nom de la table doit précéder %ROWTYPE
Les champs dans le record prennent leurs noms et types des
colonnes de la table ou la vue en question
71/185
Attribut %ROWTYPE
Exemples
Déclarer une variable pour stocker les mêmes informations

concernant une personne telles qu’elles sont stockées dans la
table PERS
personne P e r s%ROWTYPE;
Déclarer une variable pour stocker les mêmes informations

concernant un article telles qu’elles sont stockées dans la table
ART
article A r t%ROWTYPE;
72/185
Tables PL/SQL
Le type de données complexe TABLE offre au développeur un

mécanisme pour traiter les tableaux
Il se compose de deux colonnes :
Une clé primaire de type BINARY_INTEGER
Une colonne de type scalaire ou record
73/185
Création d’une table PL/SQL
Syntaxe
TYPE <Nom table> I S TABLE OF <t y p e >
INDEX BY BINARY INTEGER ;
Exemple
TYPE type etud nom I S TABLE OF e t u d . nom%TYPE
etud nom type etud nom ;
74/185
Structure d’une table PL/SQL
en mémoire
Clé primaire Colonne

1 Ritchie
2 Marvin
3 Dennis
... ...
... ...
BINARY INTEGER Scalaire
75/185
Créer une table PL/SQL
SQL> DECLARE
2 TYPE type etud nom I S TABLE OF v a r c h a r 2 ( 1 0 )
3 etud nom type etud nom ;
4 BEGIN
5 s e l e c t nom
6 i n t o etud nom ( 1 )
7 from e t u d
8 where e t u d i d = 6 ;
9 d b m s o u t p u t . p u t l i n e ( etud nom ( 1 ) ) ;
10 d b m s o u t p u t . p u t l i n e ( etud nom ( 2 ) ) ;
11 end ;
12 /
mark
DECLARE
∗
ERREUR à l a l i g n e 1 :
ORA−01403: Aucune d o n né e t r o u v é e
ORA−06512: à l i g n e 10
76/185
TABLE de RECORDS en PL/SQL
Définit une table dont la deuxième colonne est un

enregistrement au lieu d’un scalaire
Pour définir la deuxième colonne :
Soit en utilisant l’attribut %ROWTYPE
Soit en utilisant un record déjà défini
77/185
TABLE de RECORDS PL/SQL
Exemple 1
DECLARE
TYPE type etud nom I S TABLE OF e t u d%r o w t y p e
BEGIN
SELECT nom
INTO etud nom ( 1 ) . nom
FROM etud
...
END;
78/185
TABLE de RECORDS PL/SQL
Exemple 2
DECLARE
TYPE r e c e t u d I S RECORD( i d e t u d . e t u d i d%TYPE ,
nom e t u d . nom%TYPE ) ;
TYPE type etud nom I S TABLE OF r e c e t u d%ROWTYPE
BEGIN
SELECT nom
INTO etud nom ( 1 ) . nom
FROM etud
...
END;
79/185
Les curseurs dans SQL
Un curseur est une zone de travail privée de SQL (zone

tampon)
Il y a deux types de curseurs:
Curseurs implicites
Curseurs explicites
Oracle utilise les curseurs implicites pour analyser et exécuter
les énoncés de SQL
Les curseurs explicites sont déclarés explicitement pas le
programmeur
80/185
Les attributs des curseurs SQL
Les attributs des curseurs SQL permettent de tester les résultats
des énoncés SQL
SQL%ROWCOUNT Nombre de lignes affecté par l’énoncé

SQL le plus récent (renvoie un entier).
SQL%FOUND attribut booléen qui prend la valeur TRUE
si l’énoncé SQL le plus récent affecte une
ou plusieurs lignes.
SQL%NOTFOUND attribut booléen qui prend la valeur TRUE
si l’énoncé SQL le plus récent n’affecte
aucune ligne.
SQL%ISOPEN Prend toujours la valeur FALSE parce que
PL/SQL ferment les curseurs implicites
immédiatement après leur exécution.
81/185
Les attributs des curseurs SQL
Supprimer de la table ITEM des lignes ayant un ordre spécifié.
Afficher le nombre de lignes supprimées.
Exemple
DECLARE
v ordid NUMBER := 6 0 5 ;
BEGIN
DELETE FROM i t e m
WHERE ordid = v ordid ;
DBMS OUTPUT . PUT LINE ( SQL%ROWCOUNT
| | ’ L i g n e s s u p p r i m é e s ’ ) ;
END;
Remarque : ne pas oublier Set ServerOutput on (sous

SQLPLUS)
82/185
Les curseurs
Chaque énoncé SQL exécuté par Oracle a son propre curseur :

Curseurs implicites : déclarés pour tout énoncé SELECT du
LMD ou PL/SQL
Curseurs explicites : déclarés et nommés par le programmeur
83/185
Contrôle des curseurs explicites
84/185
Contrôle des curseurs explicites
85/185
Déclaration des curseurs
Syntaxe
CURSOR nom du curseur IS

un é n o n cé SELECT ;
Ne pas inclure la clause INTO dans la déclaration du curseur

Si le traitement des lignes doit être fait dans un ordre
spécifique, on utilise la clause ORDER BY dans la requête
86/185
Déclaration des curseurs
Exemple
DECLARE
CURSOR C1 I S
SELECT RefArt , NomArt , QteArt
FROM Article
WHERE QteArt < 5 0 0 ;
87/185
Ouverture du curseur
Syntaxe
OPEN nom du curseur ;
Ouvrir le curseur pour exécuter la requête et identifier

l’ensemble actif
Si la requête ne renvoie aucune ligne, aucune exception n’aura
lieu
Utiliser les attributs des curseurs pour tester le résultat du
FETCH
88/185
Recherche des données dans le curseur
Syntaxe
FETCH nom du curseur

INTO [ v a r i a b l e 1 , [ v a r i a b l e 2 , . . . ]
| nom de record ] ;
Rechercher les informations de la ligne en cours et les mettre dans
des variables.
89/185
Recherche des données dans le curseur
Exemples
FETCH c1 INTO v R e f A r t , v NomArt , v Q t e A r t ;
....
OPEN Cur Etud ;
LOOP
FETCH C u r E t u d INTO Rec Etud ;
{ t r a i t e m e n t s d e s d o n né e s r e c h e r c h é e s }
...
END LOOP ;
...
90/185
Fermeture du curseur
Syntaxe
CLOSE nom du curseur ;
Fermer le curseur après la fin du traitement des lignes

Rouvrir le curseur si nécessaire
On ne peut pas rechercher des informations dans un curseur si
ce dernier est fermé
91/185
Les attributs du curseur explicite
Obtenir les informations d’état du curseur (CUR EXP)
Attribut Type Description

CUR EXP%ISOPEN BOOLEAN Prend la valeur TRUE
si le curseur est ouvert
CUR EXP%NOTFOUND BOOLEAN Prend la valeur TRUE
si le FETCH le plus récent
ne retourne aucune ligne
CUR EXP%FOUND BOOLEAN Prend la valeur TRUE
si le FETCH le plus récent
retourne une ligne
CUR EXP%ROWCOUNT NUMBER Retourne le nombre de lignes
traitées jusqu’ici
92/185
Contrôle des recherches multiples
Traitement de plusieurs lignes d’un curseur en utilisant une

boucle
Rechercher une seule ligne à chaque itération
Utiliser les attributs du curseur explicite pour tester le succès
de chaque FETCH
93/185
Attribut %ISOPEN
La recherche des lignes n’est possible que si le curseur est

ouvert
Utiliser l’attribut %ISOPEN avant un FETCH pour tester si le
curseur est ouvert ou non
Exemple :
I F NOT C1%ISOPEN THEN
OPEN C1
END I F ;
LOOP
FETCH C1 . . .
94/185
Attributs %FOUND, %NOTFOUND et %ROWCOUNT
Utiliser l’attribut %ROWCOUNT pour fournir le nombre exact des

lignes traitées
Utiliser les attributs %FOUND et %NOT FOUND pour formuler le
test d’arrêt de la boucle
95/185
Attributs %FOUND, %NOTFOUND et NOTFOUND%ROWCOUNT
Exemple
LOOP
FETCH c u r s 1 INTO v e t u d i d , v nom ;
IF c u r s 1%ROWCOUNT > 20 THEN
...
EXIT WHEN c u r s 1%NOTFOUND;
...
END LOOP ;
96/185
Obtenir les informations d’état du curseur
Exemple complet
DECLARE
nom emp . ename%TYPE ;
s a l a i r e emp . s a l%TYPE ;
CURSOR C1 I S SELECT ename , NVL( s a l , 0 ) FROM emp ;
BEGIN
OPEN C1 ;
LOOP
FETCH C1 INTO nom , s a l a i r e ;
EXIT WHEN C1%NOTFOUND;
DBMS OUTPUT . PUT LINE ( nom | | ’ gagne ’ | |
salaire || ’ dollars ’ );
END LOOP ;
CLOSE C1 ;
END;
97/185
Les curseurs et les Records
Traitement des lignes de l’ensemble actif par l’affectation des
valeurs à des records PL/SQL.
Exemple
...
CURSOR Etud Curs IS
SELECT etudno , nom , age , a r d
FROM etud
WHERE age < 2 6 ;
Etud Record E t u d C u r s%ROWTYPE;
BEGIN
OPEN Etud Curs ;
...
FETCH E t u d C u r s INTO Etud Record ;
...
END;
98/185
Les boucles FOR des curseurs
Syntaxe
FOR nom record IN nom curseur LOOP

−− t r a i t e m e n t d e s i n f o r m a t i o n s
−− u t i l i s e r d e s o r d r e s SQL
−− u t i l i s e r d e s o r d r e s PL / SQL
END LOOP ;
...
Un raccourci pour le traitement des curseurs explicites

OPEN, FETCH et CLOSE se font de façon implicite
Ne pas déclarer le record, il est déclaré implicitement
99/185
Les boucles FOR des curseurs
Exemple
DECLARE
CURSOR C u r E t u d I S
SELECT ∗ FROM Etud ;
BEGIN
FOR R e c E t u d IN Cur Etud LOOP
DBMS OUTPUT . PUT LINE ( R e c E t u d . e t u d i d | | ’
’ | | R e c E t u d . nom | | ’ ’ | | R e c E t u d . a d r ) ;
END LOOP ;
END;
/
100/185
Manipulation des exceptions en PL/SQL
Le traitement des exceptions PL/SQL : mécanisme pour

manipuler les erreurs rencontrées lors de l’exécution
Possibilité de continuer l’exécution si l’erreur n’est pas
suffisamment importante pour produire la terminaison de la
procédure
Décision de continuer une procédure après erreur : décision
que le développeur doit faire en fonction des erreurs possibles
101/185
Types des exceptions
Déclenchées implicitement
Exceptions Oracle prédéfinies
Exceptions Oracle Non-prédéfinies
Déclenchées explicitement
Exceptions définies par l’utilisateur
102/185
Capture des exceptions
Syntaxe
EXCEPTION
WHEN e x c e p t i o n 1 [OR e x c e p t i o n 2 . . . ] THEN
é n o n cé 1 ;
é n o n cé 2 ;
...
[WHEN e x c e p t i o n 2 [OR e x c e p t i o n 4 . . . ] THEN
é n o n cé 3 ;
é n o n cé 4 ;
...]
[WHEN OTHERS THEN

é n o n cé 5 ;
é n o n cé 6 ;
...]
103/185
Capture des exceptions prédéfinies
Faire référence au nom dans la partie traitement des

exceptions
Quelques exceptions prédéfinies :
NO DATA FOUND
TOO MANY ROWS
INVALID CURSOR
ZERO DIVIDE
DUP VAL ON INDEX
104/185
Exceptions prédéfinies
Exemple
BEGIN
...
EXCEPTION
WHEN NO DATA FOUND THEN
é n o n cé 1 ; é n o n cé 2 ;
DBMS OUTPUT . PUT LINE (TO CHAR ( e t u d n o ) | |
’ Non v a l i d e ’ ) ;
WHEN TOO MANY ROWS THEN
é n o n cé 3 ; é n o n cé 4 ;
DBMS OUTPUT . PUT LINE ( ’ Données i n v a l i d e s ’ ) ;
WHEN OTHERS THEN

é n o n cé 5 ; é n o n cé 6 ;
DBMS OUTPUT . PUT LINE ( ’ A u t r e s e r r e u r s ’ ) ;
105/185
Capture des exceptions définies par l’utilisateur
106/185
Capture des exceptions non-prédéfinies
Exemple
Capture de l’erreur n◦ 2291 (violation de la contrainte intégrité).
DECLARE
cont integrit viol EXCEPTION;
PRAGMA EXCEPTION INIT ( c o n t i n t e g r i t v i o l , −2291);
...
BEGIN
...
EXCEPTION
WHEN c o n t i n t e g r i t v i o l THEN
DBMS OUTPUT . PUT LINE ( ’ v i o l a t i o n de c o n t r a i n t e
d ’ i n t é g r i t é ’ ) ;
...
END ;
107/185
Capture des exceptions définies par l’utilisateur
108/185
Exceptions définies par l’utilisateur
Exemple
DECLARE
x number : = . . . ;
x trop petit EXCEPTION;
...
BEGIN
...
IF x < 5 THEN RAISE x t r o p p e t i t ;
END I F ;
...
EXCEPTION
WHEN x t r o p p e t i t THEN
DBMS OUTPUT . PUT LINE ( ’ l a v a l e u r de x
est trop pe tite ! ! ’ ) ;
...
END;
109/185
Fonctions pour capturer les exceptions
SQLCODE : Retourne la valeur numérique du code de l’erreur

SQLERRM : Retourne le message associé au numéro de l’erreur
110/185
Fonctions pour capturer les exceptions
Exemple
...
v code erreur NUMBER;
v message erreur VARCHAR2( 2 5 5 ) ;
BEGIN
...
EXCEPTION
...
WHEN OTHERS THEN
...
v c o d e e r r e u r := SQLCODE ;
v m e s s a g e e r r e u r := SQLERRM ;
INSERT INTO e r r e u r s VALUES ( v c o d e e r r e u r ,
v message erreur );
END;
111/185
Les sous-programmes
Un sous programme est une séquence d’instruction PL/SQL

qui possède un nom
On distingue deux types de sous programmes :
Les procédures
Les fonctions
112/185
Les sous-programmes
Une procédure : sous programme qui ne retourne des résultats

seulement dans ses paramètres
Une fonction : sous programme qui retourne des résultats
dans :
Le nom de la fonction
Les paramètres de la fonction
113/185
Les procédures
Syntaxe
DECLARE
...
PROCEDURE <Nom Proc >[( P1 , . . . , Pn ) ] I S
[ D é c l a r a t i o n s l o c a l e s ]
BEGIN
...
EXCEPTION
...
END;
BEGIN
/∗ A p p e l de l a p r o c é d u r e ∗/
...
EXCEPTION
...
END ;
/
114/185
Les procédures
Syntaxe des paramètres
P1,...,Pn suivent la syntaxe :

<Nom Arg> [ IN | OUT | IN OUT] <Type>
Où :
IN : Paramètre d’entrée
OUT : Paramètre de sortie
IN OUT : Paramètre d’entrée/Sortie
Par défaut le paramètre est IN
115/185
Les procédures
Exemple
DECLARE
PROCEDURE NouvSal (PNum IN Emp . Emp Id %Type , PAug NUMBER ) I S
VSal NUMBER ( 7 , 2 ) ;
BEGIN
SELECT S a l INTO VSal FROM Emp
WHERE e m p I d=PNum ;
UPDATE Emp SET S a l = VSal+PAug WHERE Emp Id=PNum ;
COMMIT;
EXCEPTION
WHEN NO DATA FOUND THEN
DBMS OUTPUT . PUT LINE ( ’ Employé i n e x i s t a n t ’ ) ;
END;
BEGIN
NouvSal ( 7 5 5 0 , 5 0 0 ) ;
EXCEPTION
WHEN OTHERS THEN DBMS OUTPUT . PUT LINE ( ’ E r r e u r ’ ) ;
END ;
/
116/185
Les procédures
Exemple
DECLARE
VErr NUMBER ;
PROCEDURE NouvSal (PNum Emp . Emp Id %TYPE , PAug NUMBER,
P E r r OUT NUMBER ) I S
VSal NUMBER ( 7 , 2 ) ;
BEGIN
SELECT S a l INTO VSal FROM Emp WHERE e m p I d=PNum ;
UPDATE Emp SET S a l = VSal+PAug WHERE Emp Id=PNum ;
COMMIT; P E r r :=0
EXCEPTION
WHEN NO DATA FOUND THEN P E r r :=1 ;
END;
117/185
Les procédures
Exemple
BEGIN
NouvSal ( 7 5 5 0 , 5 0 0 , VErr ) ;
I F VErr = 0 THEN
DBMS OUTPUT . PUT LINE ( ’ O p é r a t i o n E f f e c t u é e ’ ) ;
ELSE DBMS OUTPUT . PUT LINE ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
EXCEPTION
END ;
/
118/185
Les fonctions
Syntaxe
DECLARE
[ D é c l a r a t i o n s g l o b a l e s ]
FUNCTION <Nom fonc >[( P1 , . . . , Pn ) ] RETURN Type I S
[ D é c l a r a t i o n s l o c a l e s ]
BEGIN
...
RETURN v a l e u r ;
EXCEPTION
...
END;
BEGIN
−− A p p e l a l a f o n c t i o n
....
EXCEPTION
...
END ;
/
119/185
Les fonctions
Exemple
DECLARE
VNomComplet VARCHAR2 ( 4 0 ) ;
FUNCTION NomComplet (PNum Emp . Emp I d%TYPE , P E r r OUT NUMBER )
RETURN VARCHAR2 I S
VLastName Emp . Last Name %Type ;
VFirstName Emp . F i r s t N a m e %Type ;
BEGIN
SELECT Last Name , F i r s t N a m e
INTO VLastName , VFirstName
WHERE Emp Id=PNum ; P E r r : = 0 ;
RETURN VLastName | | ’ ’ | | VFirstName ;
EXCEPTION
WHEN NO DATA FOUND THEN P E r r : = 1 ; RETURN N u l l ;
END ;
120/185
Les fonctions
Exemple
BEGIN
VNomComplet:= NomComplet(&Num, VErr ) ;
I F VErr = 0 THEN
DBMS OUTPUT . PUT LINE ( ’Nom Complet e s t : ’ | | VNomComplet ) ;
ELSE DBMS OUTPUT . PUT LINE ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
EXCEPTION
END ;
121/185
Le paramètre IN OUT
Paramètre jouant le rôle des deux paramètres IN et OUT

Obligatoire de le spécifier
Exemple :
SQL> C r e a t e o r r e p l a c e p r o c e d u r e a f f n o m ( v nom IN OUT v a r c h a r 2 ) I S
2 BEGIN
3 v nom := UPPER ( v nom ) ;
4 END a f f n o m ;
5 /
P r o c é d u r e c r é é e .
122/185
Appel de affnom de SQL*Plus
Définition d’une variable liée

Initialisation de la variable
SQL> v a r name v a r c h a r 2 ( 1 0 ) ;
SQL> begin : name := ’ mark ’ ; end ;
/
P r o cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s
SQL> p r i n t name
NAME
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mark
123/185
Appel de affnom de SQL*Plus
Exécution de la procédure avec un paramètre IN OUT

Affichage la nouvelle valeur de la variable
SQL> execute a ff no m ( : name ) ;

P r o cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s .
SQL> p r i n t name
NAME
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
MARK
124/185
Passage de paramètres
Il y a plusieurs façons de passage de paramètres :

Appel de la procédure en spécifiant les paramètres
Appel de la procédure sans paramètre si ce dernier est un
paramètre d’entrée initialisé
Appel de la procédure en changeant la position des
paramètres (il faut spécifier le nom du paramètre)
125/185
Exemple
CREATE OR REPLACE PROCEDURE r e n s e i g n e t u d

( v nom IN e t u d . nom%t y p e d e f a u l t ’ i n c o n n u ’ ,
v adr IN e t u d . a d r%t y p e d e f a u l t ’ inconnu ’ )
IS
BEGIN
INSERT INTO e t u d
VALUES ( e t u d e t u d i d . n e x t v a l , v nom , v a d r ) ;
END;
126/185
Exemple
SQL> begin
2 r e n s e i g n e t u d ( ’ mark ’ , ’ p a r i s ’ ) ;
3 renseign etud ;
4 r e n s e i g n e t u d ( v a d r => ’ l y o n ’ ) ;
5 end ;
6 /
SQL> s e l e c t ∗ from e t u d ;
ETUDID NOM ADR

−−−−−−−−−− −−−−−−−−−− −−−−−−−−−−
6 mark paris
7 inconnu inconnu
8 inconnu lyon
SQL>
127/185
Les procédures et les fonctions stockées
Sont des blocs PL/SQL qui possèdent un nom

Consistent à ranger le block PL/SQL compilé dans la base de
données (CREATE)
Peuvent être réutilisées sans être recompilées (EXECUTE)
Peuvent être appelées de n’importe bloc PL/SQL
Peuvent être regroupées dans un package
128/185
Les procédures stockées
Syntaxe
CREATE [ OR REPLACE ] PROCEDURE <Nom Proc >[( P1 , . . . , Pn ) ]
[ D é c l a r a t i o n s d e s v a r i a b l e s l o c a l e s ]
BEGIN
...
EXCEPTION
...
END;
/
Procedure Created : La procédure est correcte

Ou
Procedure Created with compilation errors : Corriger
les erreurs → SHOW ERRORS;
129/185
Les procédures stockées
Exemple
CREATE [ OR REPLACE ] PROCEDURE
A j o u t P r o d ( P r e f P r o Prod . R e f P r o%TYPE , . . . P P r i U n i
Prod . P r i U n i% TYPE, PErr OUT Number ) I S
BEGIN
INSERT INTO Prod VALUES( P r e f P r o , . . . , P P r i U n i ) ;
COMMIT;
PErr : = 0 ;
EXCEPTION
WHEN DUP VAL ON INDEX THEN
PErr : = 1 ;
END;
/
130/185
Appel des procédures stockées
Syntaxe
La procédure stockée est appelée par les applications soit :
En utilisant son nom dans un bloc PL/SQL (autre procédure)
Par execute dans SQL*Plus
Dans un bloc PL/SQL :
DECLARE
BEGIN
<Nom Procedure >[<P1 > , . . . , < Pn > ] ;
END;
Sous SQL*PLUS :
EXECUTE <Nom Procedure >[<P1 > , . . . , < Pn > ] ;
131/185
Appel des procédures stockées
Exemple
ACCEPT VRefPro . . .
ACCEPT V P r i U n i . . .
DECLARE
VErr NUMBER;
BEGIN
A j o u t P r o d (&VRefPro , . . . , & VPriUni , VErr ) ;
I F VErr=0 THEN
DBMS OUTPUT . PUT LINE ( ’ O pé r a t i o n E f f e c t u e r ’ ) ;
ELSE DBMS OUTPUT . PUT LINE ( ’ E r r e u r ’ ) ;
END I F ;
END ;
/
132/185
Les fonctions stockées
Syntaxe
CREATE [ OR REPLACE ] FUNCTION <Nom Fonc >[( P1 , . . . , Pn ) ]
RETURN Type I S
[ D é c l a r a t i o n s d e s v a r i a b l e s l o c a l e s ]
BEGIN
I n s t r u c t i o n s SQL e t PL/ S q l
RETURN( V a l e u r )
EXCEPTION
Traitement des e x c e p t i o n s
END;
/
function Created : La fonction est correcte
Ou
function Created with compilation errors :
Corriger les erreurs → SHOW ERRORS;
133/185
Les fonctions stockées
Exemple
CREATE [ OR REPLACE ] FUNCTION NbEmp (PNumDep Emp . D e p t I d%Type ,
P E r r Out Number ) R e t u r n Number
IS
VNb Number ( 4 ) ;
BEGIN
S e l e c t Count ( ∗ ) I n t o VNb From Emp Where D e p t I d=PNumDep ;
P E r r :=0
R e t u r n VNb ;
Exception
When No Data Found Then
PErr :=1;
Return Null ;
END;
/
134/185
Appel des fonctions stockées
Syntaxe
La fonction stockée est appelée par les applications soit :
Dans une expression dans un bloc PL/SQL
Dans une expression dans par la commande EXECUTE (dans
SQL*PLUS)
Dans un bloc PL/SQL :
DECLARE
BEGIN
<v a r > := <N o m f o n c t i o n >[<P1 > , . . . , < Pn>]
END;
Sous SQL*PLUS :
EXECUTE :< v a r > := <N o m f o n c t i o n > [<P1 > , . . . , < Pn>]
135/185
Exemple
A c c e p t VDep . . .
Declare
VErr Number ;
VNb Number ( 4 ) ;
Begin
VNb :=NbEmp(&VDep , VErr ) ;
I f VErr=0 Then
DBMS Output . P u t L i n e ( ’ Le nombre
d ’ e m p l o yé e s e s t : ’ | | VNb ) ;
Else
DBMS Output . P u t L i n e ( ’ E r r e u r ’ ) ;
End I f ;
End ;
/
136/185
Exemple
SQL> VARIABLE VNb

SQL> EXECUTE : VNb:=NbEmp(&VDep , VErr ) ;
SQL> PRINT VNb
VNB
−−−−−−−−−−
300
137/185
Suppression des procédures et des fonctions stockées
Syntaxe
Comme tout objet manipulé par Oracle, les procédures et les

fonctions peuvent être supprimées si nécessaire
Cette suppression est assurée par la commande suivante :
DROP PROCEDURE nomprocedure ;
DROP FUNCTION nomfonction ;
138/185
Suppression des procédures et des fonctions stockées
Exemple
SQL> DROP PROCEDURE AjoutProd ;

Procedure dropped .
SQL> DROP FUNCTION NbEmp ;

Function dropped .
139/185
Les procédures et les fonctions stockées
Quelques commandes utiles :

SELECT o b j e c t n a m e , o b j e c t t y p e from o b j ;
DESC n o m p r o c e d u r e
DESC n o m f o n c t i o n
140/185
Les packages
Un objet PL/SQL qui stocke d’autres types d’objet :

procédures, fonctions, curseurs, variables, ...
Consiste en deux parties :
Spécification (déclaration)
Corps (implémentation)
Ne peut pas être appelé, ni paramétré ni imbriqué
Permet à Oracle de lire plusieurs objets à la fois en mémoire
141/185
Développement des packages
Sauvegarder l’énoncé de CREATE PACKAGE dans deux

fichiers différents (ancienne/dernière version) pour faciliter de
éventuelles modifications
Le corps du package ne peut pas être compilé s’il n’est pas
déclaré (spécifié)
Restreindre les privilèges pour les procédures à une personne
donnée au lieu de lui donner tous les droits sur toutes les
procédures
142/185
La spécification du package
Syntaxe
Contient la déclaration des curseurs, variables, types, procédures,

fonctions et exceptions
CREATE [OR REPLACE ] PACKAGE <Nom Package>
I S [ D é c l a r a t i o n d e s v a r i a b l e s e t Types ]
[ D é c l a r a t i o n d e s c u r s e u r s ]
[ D é c l a r a t i o n d e s p r o c é d u r e s e t f o n c t i o n s ]
[ D é c l a r a t i o n d e s e x c e p t i o n s ]
END[<Nom Package > ] ;
/
143/185
La spécification du package
Exemple
Create Or R e p l a c e Package PackProd

I s C u r s o r CProd I s S e l e c t RefPro , DesPro
From P r o d u i t ;
P r o c e d u r e A j o u t P r o d ( P r e f P r o Prod . R e f P r o%Type ,
. . . , PErr Out Number ) ;
P r o c e d u r e ModifProd ( P r e f P r o Prod . R e f P r o%Type ,
P r o c e d u r e SuppProd ( P r e f P r o Prod . R e f P r o%Type ,
Procedure AffProd ;
EndPackProd ;
/
144/185
Le corps du package
Syntaxe
On implémente les procédures et fonctions déclarées dans la

spécification
Create [ Or R e p l a c e ] Package Body <Nom Package> Is
[ I m p l é m e n t a t i o n p r o c é d u r e s | f o n c t i o n s ]
End [<Nom Package > ] ;
/
145/185
Le corps du package
Syntaxe
Create Or R e p l a c e Package Body PackProd

Is
P r o c e d u r e A j o u t P r o d ( P r e f P r o Prod . R e f P r o%Type ,
. . . , PErr Out Number)
Is
Begin
I n s e r t I n t o Prod Values ( P r e f P r o , . . . , P P r i U n i ) ;
Commit ;
PErr : = 0 ;
Exception
When D u p V a l O n I n d e x Then PErr : = 1 ;
When O t h e r s Then PErr := 1 ;
End ;
146/185
Le corps du package
Syntaxe
P r o c e d u r e ModifProd ( P r e f P r o Prod . R e f P r o%Type ,

. . . , PErr Out Number)
I s B Boolean ;
Begin
...
EndPackProd ;
/
147/185
Appels des procédures / fonctions du package
Syntaxe
Les procédures et les fonctions définies dans un package sont

appelées de la façon suivante :
<NomPackage>.<NomProcedure >[( P a r a mè t r e s ) ] ;
Var := <NomPackage>.<NomFonction >[( P a r a mè t r e s ) ] ;
148/185
Appels des procédures / fonctions du package
Exemple
A c c e p t VRef Prompt ’ . . . . . . ’ ;
A c c e p t V P r i Prompt ’ . . . . . . ’ ;
Declare
VErr Number ;
Begin
PackProd . ModifProd (&VRef , . . . , &VPri , VErr ) ;
I f VErr= 0 Then
DBMS Output . P u t L i n e ( ’ T r a i t e m e n t e f f e c t u é ’ ) ;
Else
DBMS Output . P u t L i n e ( ’ E r r e u r ’ ) ;
End I f ;
End ;
/
149/185
Packages : Exemples
Création le corps du package suivant en mode interactif :

SQL> c r e a t e or r e p l a c e p a c k a g e body pack1 i s
2 f u n c t i o n d o u b l e x ( x number ) r e t u r n number i s
3 begin
4 r e t u r n (2∗ x ) ;
5 end ;
6 end ;
7 /
A v e r t i s s e m e n t : C o r p s de p a c k a g e c r é é a v e c e r r e u r s
de c o m p i l a t i o n .
150/185
Packages : Exemples
Pour afficher les erreurs on utilise la commande SHOW ERRORS

SQL> show e r r o r s
E r r e u r s p o u r PACKAGE BODY PACK1 :
LINE /COL ERROR

−−−−−−−− −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
0/0 PL/SQL : C o m p i l a t i o n u n i t a n a l y s i s t e r m i n a t e d
1/14 PLS −00201: l ’ i d e n t i f i c a t e u r ’PACK1 ’ d o i t ê t r e d é c l a r é
1/14 PLS −00304: i m p o s s i b l e de c o m p i l e r l e c o r p s de ’PACK1 ’
s a n s s a s p é c i f i c a t i o n
SQL>
151/185
Les triggers (Déclencheurs)
Un trigger est un programme PL/SQL qui s’exécute

automatiquement avant ou après une opération LMD
(Insert, Update, Delete)
Contrairement aux procédures, un trigger est déclenché
automatiquement suite à un ordre LMD
152/185
Evénement-Condition-Action
Un trigger est activé par un événement

Insertion, suppression ou modification sur une table
Si le trigger est activé, une condition est évaluée
Prédicat qui doit retourner vrai
Si la condition est vraie, l’action est exécutée
Insertion, suppression ou modification de la base de données
153/185
Composants du trigger
À quel moment se déclenche le trigger ?

BEFORE : le code dans le corps du trigger s’exécute avant les
évènements de déclenchement LMD
AFTER : le code dans le corps du trigger s’exécute avant les
évènements de déclenchement LMD
154/185
Les évènements du déclenchement :

Quelles sont les opérations LMD qui causent l’exécution du
trigger ?
INSERT
UPDATE
DELETE
La combinaison des ces opérations
155/185
Le corps du trigger est défini par un bloc PL/SQL anonyme

[DECLARE]
BEGIN
[ EXEPTION ]
END;
156/185
Syntaxe
Create [ Or R e p l a c e ] T r i g g e r <Nom Trigger>

[ B e f o r e | A f t e r ] <O pé r a t i o n DML> On <Nom Table>
[ For Each Row ] [ When <C o n d i t i o n >]
Declare
Begin
Exception
End ;
/
157/185
Exemple
Création d’un trigger qui remplit la table statistique
(Nom Table → Nb Insert) lors d’une insertion dans la table facture
C r e a t e Or R e p l a c e T r i g g e r S t a r t F a c t u r e
A f t e r I n s e r t On F a c t u r e
F o r Each Row
Declare
V N b I n s e r t Number ;
Begin
Select Nb Insert Into VNbInsert
From S t a t i s t i q u e Where Nom Table= ’ F a c t u r e ’ ;
Update S t a t i s t i q u e
Set N b I n s e r t = V N b I n s e r t+1
Where Nom Table= ’ F a c t u r e ’ ;
Exception
When No Data Found Then
I n s e r t Into S t a t i s t i q u e Values (1 , ’ Facture ’ ) ;
End ;
/
158/185
Manipulation des triggers
Activer ou désactiver un Trigger:

A l t e r T r i g g e r <Nom Trigger> [ E n a b l e | D i s a b l e ] ;
Supprimer un Trigger:
Drop T r i g g e r <Nom Trigger >;
Déterminer les triggers de votreBD:

S e l e c t T r i g g e r N a m e From U s e r T r i g g e r s
159/185
Les attributs :Old et :New
Ces deux attributs permettent de gérer l’ancienne et la nouvelle

valeurs manipulées
Insert(...) ... → New
Delete ...
Where(...) ... → Old
Update ...
Set ( ...) ... → New
Where(...) ... → Old
160/185
Les attributs :Old et :New
Exemple :
E t u d i a n t ( Matr Etu , Nom , . . . , C o d C l a )
C l a s s e ( Cod Cla , N b r E t u )
Trigger mettant à jour la table classe suite à une insertion d’un
nouvel étudiant
Create or R e p l a c e T r i g g e r MajNbEtud
A f t e r I n s e r t On E t u d i a n t
For Each Row
Begin
Update C l a s s e
Set Nbr Etud = Nbr Etud+1
Where C o d C l a =:New . C o d C l a ;
End ;
/
161/185
Les prédicats inserting, updating et deleting
Inserting:
True: Le trigger est déclenché suite à une insertion
False: Sinon
Updating:
True: le trigger est déclenché suite à une mise à jour
False: sinon
Deleting:
True: le trigger est déclenché suite à une suppression
False: sinon
162/185
Les prédicats inserting, updating et deleting
Exemple
Create Or R e p l a c e T r i g g e r MajNbEtud
A f t e r I n s e r t Or Delete On E t u d i a n t
For Each Row
Begin
I f I n s e r t i n g Then
Update C l a s s e Set Nbr Etud = Nbr Etud+1
Where C o d C l a =:New . C o d C l a ;
End I f ;
I f D e l e t i n g Then
Update C l a s s e Set Nbr Etud = Nbr Etud −1
Where C o d C l a =: Old . C o d C l a ;
End I f ;
End ;
/
163/185
Séquences
Syntaxe
Auto-incrémentation d’une colonne (évite les doublons)
Définition :
CREATE SEQUENCE s e q u e n c e n a m e
[ INCREMENT BY #]
[ START WITH #]
[MAXVALUE # | NOMAXVALUE]
[ MINVALUE # | NOMINVALUE ]
[ CYCLE | NOCYCLE ]
Suppression
DROP SEQUENCE s e q u e n c e n a m e
Pseudo-colonne CURRVAL : Valeur courante de la séquence
Pseudo-colonne NEXTVAL : Incrémentation de la séquence et
retourne la nouvelle valeur
164/185
Séquences
Exemple
drop s e q u e n c e SEQ ANNOTATION ;

c r e a t e s e q u e n c e SEQ ANNOTATION
s t a r t with 1
i n c r e m e n t by 1
nocycle
m a x v a l u e 30000
INSERT INTO p r o f ( prof num , prof nom , p r o f p r e n o m )

VALUES (SEQ ANNOTATION . NEXTVAL, ’ Dupond ’ ’ M i c h e l ’ )
SELECT s e q a n n o t a t i o n . CURRVAL from d u a l ;
165/185
SQL dynamique
Construction dans un programme une requête SQL avant de

l’exécuter
Possibilité de création d’un code générique et réutilisable
(sinon simple paramètrage de valeur de remplacement de la
clause where)
Execute immediate chaine_de_caractères ;
chaine_de_caractères est une commande sql donnée entre
’...’
166/185
SQL dynamique
Exemple 1 :
Begin
E x e c u t e immediate ’ c r e a t e t a b l e t e s t ( c o l 1 : number ) ; ’ ;
End ;
Exemple 2 :
Declare
W req v a r c h a r 2 ( 4 0 0 0 ) ;
Begin
w r e q := ’ c r e a t e t a b l e t e s t ( c o l 1 : number ) ; ’ ;
Execute immediate w r e q ;
End ;
167/185
Gestion des transactions
Une transaction est une unité logique de travail, un ensemble

d’instructions de mise à jour des données que SQL traité comme
une seule entité :
soit toutes les instructions sont exécutées ensemble,
soit aucune ne l’est.
Exemple :
si une somme d’argent doit transiter d’un compte à un autre, les
deux opérations (crédit et débit) de mise à jour doivent
absolument s’effectuer toutes les deux (ou ne pas s’effectuer du
tout) pour que la cohérence des données soit respectée.
168/185
Le mécanisme des transactions est nécessaire parce que divers

événements peuvent interrompre l’exécution d’une séquence
d’instructions :
défaillance du système,
panne de courant, micro-coupure,
le désir de revenir en arrière et abandonner les modifications
faites jusqu’alors.
169/185
Dans Oracle, le début d’une transaction est implicitement

défini par le début de la session, ou par la dernière instruction
COMMIT ou ROLLBACK.
Les instructions du DDL et du DCL exécutent
automatiquement des COMMIT.
Les modifications (INSERT, DELETE, UPDATE) d’une table ne
sont rendues permanentes que si l’on quitte la session ou si
l’on exécute la commande COMMIT.
170/185
Tant que les changements à la base n’ont pas eu lieu de façon

permanente :
l’utilisateur peut voir ces changements par des ordres SELECT,
les autres utilisateurs ne voient pas les modifications,
l’utilisateur peut défaire les modifications par l’instruction
ROLLBACK.
Un ROLLBACK automatique a lieu en cas de panne du système
171/185
Contrôle de transactions
Commandes COMMIT et ROLLBACK
Lancer une transaction avec la première commande du LMD à

la suite d’un COMMIT ou un ROLLBACK
Utiliser le COMMIT ou le ROLLBACK de SQL pour terminer une
transaction
172/185
Commande ROLLBACK
173/185
Contrôle de transactions
Exemple de traitement des transactions dans un bloc PL/SQL
BEGIN
INSERT INTO temp ( num col1 , num col2 , c h a r c o l )
VALUES ( 1 , 1 , ’ROW 1 ’ ) ;
SAVEPOINT a ;
VALUES ( 2 , 2 , ’ROW 2 ’ ) ;
SAVEPOINT b ;
VALUES ( 3 , 3 , ’ROW 3 ’ ) ;
SAVEPOINT c ;
ROLLBACK TO SAVEPOINT b ;
COMMIT;
END;
Quel est l’état de la table à la fin de l’exécution du bloc ?
174/185
Exemple de transactions en parallèle
CREATE TABLE T ( A NUMBER,
B NUMBER, PRIMARY KEY (A));
INSERT INTO T VALUES ( 1, 1);

SELECT * FROM T ;
Le résultat obtenu est :

A B
-------- ---------
1 1
2 2
COMMIT ;
Validation effectuée.
175/185
SELECT * FROM T ;
A B
--------- ---------
1 1
2 2
3 3
4 4
ROLLBACK ;
Annulation (ROLLBACK) effectuée.
SELECT * FROM T ;
A B
--------- ---------
1 1
2 2
176/185
SAVEPOINT A ;
1 ligne créée.
Point de sauvegarde (SAVEPOINT) créé.

1 ligne créée.
SELECT * FROM T ;
A B
--------- ---------
1 1
2 2
3 3
4 4
177/185
ROLLBACK TO SAVEPOINT A;
Annulation (ROLLBACK) effectuée.
SELECT * FROM T ;
A B
--------- ---------
1 1
2 2
3 3
COMMIT;
178/185
Blocage des tuples et des tables
Transaction T1 Transaction T2
SELECT * FROM T ; SELECT * FROM T ;

Le résultat obtenu est : Le résultat obtenu est :
A B A B
--------- --------- --------- ---------
1 1 1 1
2 2 2 2
3 3 3 3
179/185
update t set b = b - 2 ;
1 ligne mise à jour. select * from t ;
select * from t;
A B A B
--------- --------- --------- ---------
1 -1 1 1
2 0 2 2
3 1 3 3
update t set b = b - 2 ;
-- blocage tant que T1 n’a pas fait de COMMIT
180/185
Transaction T1
COMMIT;
Transaction T2
1 ligne mise à jour.
select * from t;
A B
--------- ---------
1 -3
2 -2
3 -1
COMMIT;
181/185
Transaction T1
select * from t;
A B
--------- ---------
1 -3
2 -2
3 -1
Transaction T2
select * from t;
A B
--------- ---------
1 -3
2 -2
3 -1
182/185
lock table t IN EXCLUSIVE MODE;
Table(s) verrouillée(s). En attente
Mises à jour En attente
Mises à jour lock table t IN EXCLUSIVE MODE;

etc...
Commit ;
183/185
Le blocage de tuples et de tables se fait par la commande SQL :

LOCK TABLE LeNomDeLObjet IN LeMode MODE ;
LeNomDeLObjet : Le nom d’une table ou d’une vue.

Le mode partagé ou exclusif ... (SHARE, SHARE UPDATE,
EXCLUSIVE)
184/185
Bilan
185/185

Cours PLSQL +++

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours PLSQL +++

Transféré par

Droits d'auteur :

Formats disponibles

Bases de Données Avancées

Langage fournissant une interface procédurale au SGBD

Structure classique (1 à 3 sections)

Bloc PL/SQL nommé

Fonction : procédure retournant une valeur

SQL> CREATE OR REPLACE FUNCTION s o l d e ( no INTEGER)

VARCHAR2(n)/NVARCHAR2(n) : Chaı̂ne de n caractères

Définition : déclaration d’une variable associée à

Les records PL/SQL

Déclaration, en SQL*Plus, d’une variable attachée : utilisation de

Faire référence aux variables non-PL/SQL comme des variables

Exemple de requête SELECT générées des milliers de fois :

Les instructions peuvent être écrites sur plusieurs lignes.

Les nombres peuvent être des valeurs simples ou des

Précéder un commentaire écrit sur une seule ligne par ’--’.

Les fonctions sur les nombres

Convertir le nom en majuscule

Extraction d’une partie de la chaı̂ne

Replacement d’une chaı̂ne par une autre

Pour référencer une variable en PL/SQL, on doit préfixer son

Extraire une ligne de données à partir de la BD par la

Récupérer une donnée de la BD avec SELECT.

Retourne la somme des salaires de tous les employés d’un

Effectuer des mises à jour des tables de la BD utilisant les

Ajouter les informations d’un nouvel employé à la table emp

Augmenter le salaire de tous les employés dans la table emp

Suppression des lignes appartenant au département 10 de la

Mettre le ID de l’employé ’MARK’ à 101.

Si le nom de l’employé est ’CLEMENT’, lui attribuer le poste

Pour une valeur donnée en entrée, retourner une valeur

where rownum <= 100

Cette requête permet de retourner un contenu dans une colonne en

When : condition est une variable booléenne ou expression (TRUE,

Utiliser la boucle FOR pour raccourcir le test d’un nombre

WHILE condition LOOP

La condition est évaluée au début de chaque itération

ACCEPT p i t e m t o t PROMPT ’ Donner l e t o t a l max de l ’ ’ a c h a t

Imbriquer les boucles à niveaux multiples

Contiennent des champs qui sont soit des scalaires, des

Déclaration d’une variable associée à une collection de

Déclarer une variable pour stocker les mêmes informations

Déclarer une variable pour stocker les mêmes informations

Le type de données complexe TABLE offre au développeur un

Clé primaire Colonne

Définit une table dont la deuxième colonne est un

Un curseur est une zone de travail privée de SQL (zone

SQL%ROWCOUNT Nombre de lignes affecté par l’énoncé

Remarque : ne pas oublier Set ServerOutput on (sous

Chaque énoncé SQL exécuté par Oracle a son propre curseur :

CURSOR nom du curseur IS

Ne pas inclure la clause INTO dans la déclaration du curseur

OPEN nom du curseur ;

Ouvrir le curseur pour exécuter la requête et identifier

FETCH nom du curseur

FETCH c1 INTO v R e f A r t , v NomArt , v Q t e A r t ;

CLOSE nom du curseur ;

Fermer le curseur après la fin du traitement des lignes

Attribut Type Description

Traitement de plusieurs lignes d’un curseur en utilisant une

La recherche des lignes n’est possible que si le curseur est

Utiliser l’attribut %ROWCOUNT pour fournir le nombre exact des

FOR nom record IN nom curseur LOOP

Un raccourci pour le traitement des curseurs explicites