Vous êtes sur la page 1sur 185

Bases de Données Avancées

PL/SQL

Thierry Hamon

Bureau H202
Institut Galilée - Université 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 complète Oracle

3/185
Clauses SQL
SELECT Interrogation des données
INSERT
UPDATE Langage de Manipulation de Données (LMD)
DELETE
CREATE
ALTER
DROP Langage de Définition de Données (LDD)
RENAME
TRUNCATE
GRANT Langage de Contrôle de Données (LCD)
REVOKE
COMMIT
ROLLBACK Contrôle de transaction
SAVEPOINT

4/185
PL/SQL
Procedural Language for Structured Query Language

Langage fournissant une interface procédurale au SGBD


Oracle
Intègration du langage SQL en lui apportant une dimension
procédurale
Réalisation de traitements algorithmiques (ce que ne permet
pas SQL)
Mise à disposition de la plupart des mécanismes classiques de
programmation des langages hôtes tels que C, COBOL,
PASCAL, C++, JAVA ...

5/185
Environnement PL/SQL

6/185
Avantages de PL/SQL
PL/SQL complément de SQL (qui n’est pas procédural)
Mécanismes offerts par PL/SQL :
Structures itératives : WHILE *** LOOP, FOR *** LOOP,
LOOP ***
Structures conditionnelles :
IF *** THEN *** ELSE | ELSEIF *** ENDIF, CASE ***
Déclaration des curseurs et des tableaux
Déclaration de variables
Affectation de valeurs aux variables
Branchements : GOTO, EXIT
Exceptions : EXCEPTION

7/185
Avantages de PL/SQL
Intégration
Meilleure cohérence du code avec les données
Utilisation de librairies standards prédéfinies (bibliothèques
partagées)

8/185
Avantages de PL/SQL
Blocs SQL
Traitement par/de blocs SQL dans un énoncé PL/SQL
(optimisation des transactions réseaux)

9/185
Avantages de PL/SQL
Exécution de programmes modulaires
Traitements complexes (cas particuliers, erreurs)
Traitements des exceptions
...

10/185
Avantages de PL/SQL
Résumé

Langage portable
Utilisation de variable de stockage
Utilisation de type simple ou de type structuré
dynamiquement (%TYPE, %ROWTYPE, etc.)
Utilisation des structures de contrôle des langages procéduraux
Gestion et manipulation des erreurs
Création d’ordre SQL dynamique

11/185
Utilisation de PL/SQL

3 formes :
Bloc de code, executé comme une commande SQL (utilisation
d’un interpréteur standard SQL+ ou iSQL*PLus)
Fichier de commandes PL/SQL
Programme stocké : procédure, fonction, package ou trigger

12/185
Structure d’un bloc PL/SQL
−− S e c t i o n d é 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 é 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 é 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

Procédure

Fonction

14/185
Type de blocs
Bloc anonyme

Structure classique (1 à 3 sections)


Un bloc ne peut ê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
Procédure

Bloc PL/SQL nommé


puis compilé et stocké dans la base

PROCEDURE nom IS

BEGIN
Instructions

[ EXCEPTION]
END;
/

18/185
Type de blocs
Procé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
crée la procédure PL/SQL
compile et stocke dans la base le bloc PL/SQL compris entre le BEGIN et
le END, référencé par ’proc exemple’

19/185
Type de blocs
Procédure

Remarques :
Exécution (auto) de la procédure :
SQL> EXECUTE proc_exemple
Pas d’exécution de procédure (ou d’instructions) en fin de
transaction (COMMIT, ROLLBACK, Ordre DDL)
Décision d’enregistrement ou d’annulation de la transaction en
cours : à réaliser par le programme appelant la procédure

20/185
Type de blocs
Fonction

Fonction : procédure retournant une valeur


FUNCTION nom RETURN t y p e d o n n é 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 requête SQL
Exemple :
SQL> SELECT solde(1000) FROM dual ;
Solde(1000)
-----------
12024,50
Appel d’une fonction comme une procé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
Références
Variables de l’environnement extérieur à PL/SQL
Attachées (Bind)
Hôtes (Host)

24/185
Dé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 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 employés
v datenaissance := ’ 23−SEP−2004 ’ ;
Fixer le nom d’un employé à ’Clément’
v nom := ’ Clément ’ ;

26/185
Types de données scalaires
Types de base – chaı̂nes de caractères

VARCHAR2(n)/NVARCHAR2(n) : Chaı̂ne de n caractères


(n < 4000octets) – longueur variable
(préfixe N : prise en compte de la localisation – NLS/National
Language Support)
CHAR(n)/NCHAR(n) : Chaı̂ne de n caractères
(n < 2000octets) – longueur fixe, rempli par des espaces
LONG/RAW/LONG RAW : Chaı̂ne de caractère ou de données
binaires (raw ) de longueur variable ( < 2000octets)

27/185
Types de données scalaires
Types de base – nombres et date
NUMBER (n , m) : Réel avec n chiffres significatifs et m décimals
INTERGER/FLOAT : Nombre entier/réel signé
BINARY_INTEGER : Nombre entier signé sur 32 bits (utilisation de la
librairie mathématique)
DATE : date entre le 1 janvier -4712 et le 21 décembre 9999
BOOLEAN : booléen
NB : pas d’équivalent en SQL.
Il n’est donc pas possible
de stocker un booléen dans une table
de sélectionner un élément de table dans un variable booléenne
d’utiliser un booléen dans une requête SQL ou une fonction
PL/SQL appelée dans une requête SQL (paramètre en entrée ou
valeur de retour)

28/185
Dé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

Définition : déclaration d’une variable associée à


Une colonne d’une table dans la BD
Une variable précédemment dé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 données composites

Types :
Les tables PL/SQL

Les records PL/SQL


(voir plus loin)

31/185
Variables attachées/Bind variables
Variables de substitution dans les requêtes SQL
Variable référençant des variables non-PL/SQL
Economie d’analyse de la requête, donc gain de temps pour
Oracle
→ Mécanisme considéré par certains comme le point clé de
performance d’Oracle

32/185
Variables attachées/Bind variables
Déclaration

Déclaration, en SQL*Plus, d’une variable attaché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
Variables attachées/Bind variables
Réfé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 référence aux variables non-PL/SQL comme des variables


hôte
Précéder la référence par un ’ : ’

34/185
Variables attachées/Bind variables
Exemple d’utilisation – optimisation

Exemple de requête SELECT générées des milliers de fois :


SELECT fname , lname , pcode FROM c u s t WHERE i d = 6 7 4 ;
SELECT fname , lname , pcode FROM c u s t WHERE i d = 2 3 4 ;
SELECT fname , lname , pcode FROM c u s t WHERE i d = 3 3 2 ;
...
A chaque soumission d’un requête,
Vérification si la requête a déjà été été soumise
Si oui, récupération du plan d’exécution de la requête, et
exécution de la requête

35/185
Variables attachées/Bind variables
Exemple d’utilisation – optimisation
Si non,
analyse syntaxique de la requête
définition des différentes possibilités d’exécution
définition du plan d’exécution optimal
→ Processus coûteux en temps CPU, alors que seule la valeur
de id change !
Solution : réutiliser le plan d’exécution existant
→ Nécessite d’utiliser des variables attachées :
Substitution de la valeur par la variable attaché
Envoi de la même requê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 être écrites sur plusieurs lignes.


Les unités lexicales peuvent être séparées par des espaces :
Délimiteurs
Identificateurs
Littéraux (ou constantes)
Commentaires

37/185
Bloc PL/SQL
syntaxe et directives

Les littéraux
Les dates et les chaı̂nes de caractères délimité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 être des valeurs simples ou des


expressions
V s a l a i r e := 1500 + 300 ;

38/185
Commentaires dans le code

Précéder un commentaire écrit sur une seule ligne par ’--’.


Placer un commentaire é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 caractères
Les fonctions de conversion de type de données
Les fonctions de dates

40/185
Exemples de fonctions SQL en PL/SQL
Exemples :
Recomposer l’adresse d’un employé :
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 imbriqués et porté 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
Opérateurs dans PL/SQL

Identique à SQL
Logique
Arithmétique
Concaténation
Parenthèses pour contrôler l’ordre des opérations
Opérateur supplémentaire : Opérateur d’exponentiation **

43/185
Utilisation des variables liées

Pour référencer une variable en PL/SQL, on doit préfixer son


nom par un ’:’
Exemple :
: c o d e r e t o u r := 0 ;
I F v é r i f i e r c r é 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 données à partir de la BD par la


commande SELECT. Un seul ensemble de valeurs peut être
retourné
Effectuer des changements aux lignes dans la BD par les
commandes du LMD
Contrôler des transactions avec les commandes COMMIT,
ROLLBACK et SAVEPOINT
Déterminer les résultats du LMD avec des curseurs implicites
(voir plus loin)

45/185
Instruction SELECT dans PL/SQL

Récupérer une donnée de la BD avec SELECT.


Syntaxe
SELECT l i s t e s é l e c t i o n
INTO { nom var [ , nom var ] . . .
| nom record }
FROM table
WHERE condition ;

46/185
Instruction SELECT dans PL/SQL
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
Instruction SELECT dans PL/SQL

Retourne la somme des salaires de tous les employés d’un


département donné.
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 é g a t
INTO v som sal
FROM emp
WHERE deptno = v deptno ;
END;

48/185
Manipulation de données en PL/SQL

Effectuer des mises à jour des tables de la BD utilisant les


commandes du LMD :
INSERT
UPDATE
DELETE

49/185
Insertion de données

Ajouter les informations d’un nouvel employé à 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 lé m e n t ’ , ’ D i r e c t e u r ’ , 1 0 ) ;
END;

50/185
Mise à jour de données

Augmenter le salaire de tous les employé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 données

Suppression des lignes appartenant au dé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 contrô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
é n o n cé s ;
[ ELSIF c o n d i t i o n THEN
é n o n cé s ; ]
[ ELSE
é n o n cé s ; ]
END I F ;

54/185
Instruction IF
Exemple de IF simple

Mettre le ID de l’employé ’MARK’ à 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’employé est ’CLEMENT’, lui attribuer le poste


’Enseignant’, le département n◦ 102 et une commission de 25
% sur son salaire actuel
Exemple
...
I F v nom = ’ Clé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’employé est ’CLEMENT’, lui attribuer le poste
’Enseignant’, le département n◦ 102 et une commission de 25
% sur son salaire actuel, sinon afficher le message ’Employé
inexistant’
Exemple
...
I F v nom = ’ Clé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 ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
...

57/185
IF-THEN-ELSIF

Pour une valeur donnée en entrée, retourner une valeur


calculé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 requête permet de retourner un contenu dans une colonne en


fonction d’une condition

59/185
Boucle de base
Syntaxe

LOOP −− d é l i m i t e u r
é n o n cé 1 ; −− é n o n cé
....
EXIT [ WHEN c o n d i t i o n ] ; −− é n o n cé EXIT
END LOOP ;

When : condition est une variable booléenne ou expression (TRUE,


FALSE, ou NULL);

60/185
Boucle de base
Exemple
Insé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
é n o n cé 1 ;
é n o n cé 2 ;
.....
END LOOP ;

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


d’itérations
Ne pas déclarer l’indice, il est déclaré implicitement

62/185
Boucle FOR
exemple
Insérer Nb articles indexés de 1 à Nb avec la date du systè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
...
v D a t e := SYSDATE ;
FOR i IN 1 . . &Nb LOOP
INSERT INTO a r t i c l e ( Artno , ADate )
VALUES ( i , v D a t e ) ;
END LOOP ;
...

63/185
Boucle WHILE
Syntaxe

WHILE condition LOOP


é n o n cé 1 ;
é n o n cé 2 ;
.....
END LOOP ;

La condition est évaluée au début de chaque itération


Utiliser la boucle WHILE pour répéter des énoncé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
...
v D a t e := SYSDATE ;
WHILE v c o m p t e u r <= &p i t e m t o t 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 ;
END LOOP ;

65/185
Boucles imbriquées et Labels

Imbriquer les boucles à niveaux multiples


Utiliser les labels pour distinguer les blocs et les boucles
Quitter la boucle extérieure avec un EXIT référençant le label

66/185
Boucles imbriquées et Labels
....
BEGIN
<< b o u c e x t >>
LOOP
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 ;
<<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 données complexes

Types :
RECORDS
TABLES
Contiennent des composants internes
Sont réutilisables

68/185
Records PL/SQL

Contiennent des champs qui sont soit des scalaires, des


records ou des tables PL/SQL
Structure similaire à des enregistrements dans les langages de
programmation classiques
Très utiles pour rechercher des lignes de données dans une
table et les traiter

69/185
Cré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

Déclaration d’une variable associée à une collection de


colonnes dans une table ou une vue de la BD
le nom de la table doit précé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

Déclarer une variable pour stocker les mêmes informations


concernant une personne telles qu’elles sont stockées dans la
table PERS
personne P e r s%ROWTYPE;

Déclarer une variable pour stocker les mêmes informations


concernant un article telles qu’elles sont stockées dans la table
ART
article A r t%ROWTYPE;

72/185
Tables PL/SQL

Le type de données complexe TABLE offre au développeur un


mécanisme pour traiter les tableaux
Il se compose de deux colonnes :
Une clé primaire de type BINARY_INTEGER
Une colonne de type scalaire ou record

73/185
Cré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
INDEX BY BINARY INTEGER ;
etud nom type etud nom ;

74/185
Structure d’une table PL/SQL
en mémoire

Clé primaire Colonne


1 Ritchie
2 Marvin
3 Dennis
... ...
... ...
BINARY INTEGER Scalaire

75/185
Cré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 )
INDEX BY BINARY INTEGER ;
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 à l a l i g n e 1 :
ORA−01403: Aucune d o n né e t r o u v é e
ORA−06512: à l i g n e 10

76/185
TABLE de RECORDS en PL/SQL

Définit une table dont la deuxième colonne est un


enregistrement au lieu d’un scalaire
Pour définir la deuxième colonne :
Soit en utilisant l’attribut %ROWTYPE
Soit en utilisant un record déjà dé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
INDEX BY BINARY INTEGER ;
etud nom type etud nom ;
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
INDEX BY BINARY INTEGER ;
etud nom type etud nom ;
BEGIN
SELECT nom
INTO etud nom ( 1 ) . nom
FROM etud
...
END;

79/185
Les curseurs dans SQL

Un curseur est une zone de travail privée de SQL (zone


tampon)
Il y a deux types de curseurs:
Curseurs implicites
Curseurs explicites
Oracle utilise les curseurs implicites pour analyser et exécuter
les énoncés de SQL
Les curseurs explicites sont déclarés explicitement pas le
programmeur

80/185
Les attributs des curseurs SQL
Les attributs des curseurs SQL permettent de tester les résultats
des énoncés SQL

SQL%ROWCOUNT Nombre de lignes affecté par l’énoncé


SQL le plus récent (renvoie un entier).
SQL%FOUND attribut booléen qui prend la valeur TRUE
si l’énoncé SQL le plus récent affecte une
ou plusieurs lignes.
SQL%NOTFOUND attribut booléen qui prend la valeur TRUE
si l’énoncé SQL le plus récent n’affecte
aucune ligne.
SQL%ISOPEN Prend toujours la valeur FALSE parce que
PL/SQL ferment les curseurs implicites
immédiatement après leur exécution.

81/185
Les attributs des curseurs SQL
Supprimer de la table ITEM des lignes ayant un ordre spécifié.
Afficher le nombre de lignes supprimé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 s ’ ) ;
END;

Remarque : ne pas oublier Set ServerOutput on (sous


SQLPLUS)

82/185
Les curseurs

Chaque énoncé SQL exécuté par Oracle a son propre curseur :


Curseurs implicites : déclarés pour tout énoncé SELECT du
LMD ou PL/SQL
Curseurs explicites : déclarés et nommés par le programmeur

83/185
Contrôle des curseurs explicites

84/185
Contrôle des curseurs explicites

85/185
Déclaration des curseurs
Syntaxe

CURSOR nom du curseur IS


un é n o n cé SELECT ;

Ne pas inclure la clause INTO dans la déclaration du curseur


Si le traitement des lignes doit être fait dans un ordre
spécifique, on utilise la clause ORDER BY dans la requête

86/185
Dé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 exécuter la requête et identifier


l’ensemble actif
Si la requête ne renvoie aucune ligne, aucune exception n’aura
lieu
Utiliser les attributs des curseurs pour tester le résultat du
FETCH

88/185
Recherche des donné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 donné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 né e s r e c h e r c h é e s }
...
END LOOP ;
...

90/185
Fermeture du curseur
Syntaxe

CLOSE nom du curseur ;

Fermer le curseur après la fin du traitement des lignes


Rouvrir le curseur si nécessaire
On ne peut pas rechercher des informations dans un curseur si
ce dernier est fermé

91/185
Les attributs du curseur explicite
Obtenir les informations d’é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 récent
ne retourne aucune ligne
CUR EXP%FOUND BOOLEAN Prend la valeur TRUE
si le FETCH le plus récent
retourne une ligne
CUR EXP%ROWCOUNT NUMBER Retourne le nombre de lignes
traitées jusqu’ici

92/185
Contrôle des recherches multiples

Traitement de plusieurs lignes d’un curseur en utilisant une


boucle
Rechercher une seule ligne à chaque itération
Utiliser les attributs du curseur explicite pour tester le succè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 traitées
Utiliser les attributs %FOUND et %NOT FOUND pour formuler le
test d’arrê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’é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 à 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 façon implicite
Ne pas déclarer le record, il est déclaré 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 : mécanisme pour


manipuler les erreurs rencontrées lors de l’exécution
Possibilité de continuer l’exécution si l’erreur n’est pas
suffisamment importante pour produire la terminaison de la
procédure
Décision de continuer une procédure après erreur : décision
que le développeur doit faire en fonction des erreurs possibles

101/185
Types des exceptions

Déclenchées implicitement
Exceptions Oracle prédéfinies
Exceptions Oracle Non-prédéfinies
Déclenchées explicitement
Exceptions dé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
é n o n cé 1 ;
é n o n cé 2 ;
...
[WHEN e x c e p t i o n 2 [OR e x c e p t i o n 4 . . . ] THEN
é n o n cé 3 ;
é n o n cé 4 ;
...]

[WHEN OTHERS THEN


é n o n cé 5 ;
é n o n cé 6 ;
...]

103/185
Capture des exceptions prédéfinies

Faire référence au nom dans la partie traitement des


exceptions
Quelques exceptions prédéfinies :
NO DATA FOUND
TOO MANY ROWS
INVALID CURSOR
ZERO DIVIDE
DUP VAL ON INDEX

104/185
Exceptions prédéfinies
Exemple
BEGIN
...
EXCEPTION
WHEN NO DATA FOUND THEN
é n o n cé 1 ; é n o n cé 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
é n o n cé 3 ; é n o n cé 4 ;
DBMS OUTPUT . PUT LINE ( ’ Données i n v a l i d e s ’ ) ;

WHEN OTHERS THEN


é n o n cé 5 ; é n o n cé 6 ;
DBMS OUTPUT . PUT LINE ( ’ A u t r e s e r r e u r s ’ ) ;

105/185
Capture des exceptions définies par l’utilisateur

106/185
Capture des exceptions non-prédéfinies
Exemple
Capture de l’erreur n◦ 2291 (violation de la contrainte intégrité).
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 é g r i t é ’ ) ;
...
END ;

107/185
Capture des exceptions définies par l’utilisateur

108/185
Exceptions dé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 numérique du code de l’erreur


SQLERRM : Retourne le message associé au numé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 séquence d’instruction PL/SQL


qui possède un nom
On distingue deux types de sous programmes :
Les procédures
Les fonctions

112/185
Les sous-programmes

Une procédure : sous programme qui ne retourne des résultats


seulement dans ses paramètres
Une fonction : sous programme qui retourne des résultats
dans :
Le nom de la fonction
Les paramètres de la fonction

113/185
Les procédures
Syntaxe
DECLARE
...
PROCEDURE <Nom Proc >[( P1 , . . . , Pn ) ] I S
[ D é 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 é d u r e ∗/
...
EXCEPTION
...
END ;
/
114/185
Les procédures
Syntaxe des paramètres

P1,...,Pn suivent la syntaxe :


<Nom Arg> [ IN | OUT | IN OUT] <Type>
Où :
IN : Paramètre d’entrée
OUT : Paramètre de sortie
IN OUT : Paramètre d’entrée/Sortie
Par défaut le paramètre est IN

115/185
Les procé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 ( ’ Employé 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 procé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 procédures
Exemple

BEGIN
NouvSal ( 7 5 5 0 , 5 0 0 , VErr ) ;
I F VErr = 0 THEN
DBMS OUTPUT . PUT LINE ( ’ O p é r a t i o n E f f e c t u é e ’ ) ;
ELSE DBMS OUTPUT . PUT LINE ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
EXCEPTION
WHEN OTHERS THEN DBMS OUTPUT . PUT LINE ( ’ E r r e u r ’ ) ;
END ;
/

118/185
Les fonctions
Syntaxe
DECLARE
[ D é 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 é 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 ( ’ Employé i n e x i s t a n t ’ ) ;
END I F ;
EXCEPTION
WHEN OTHERS THEN DBMS OUTPUT . PUT LINE ( ’ E r r e u r ’ ) ;
END ;

121/185
Le paramètre IN OUT

Paramètre jouant le rôle des deux paramètres IN et OUT


Obligatoire de le spé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 é d u r e c r é é e .

122/185
Appel de affnom de SQL*Plus

Définition d’une variable lié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 cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s
SQL> p r i n t name
NAME
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mark

123/185
Appel de affnom de SQL*Plus

Exécution de la procédure avec un paramètre IN OUT


Affichage la nouvelle valeur de la variable

SQL> execute a ff no m ( : name ) ;


P r o cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s .
SQL> p r i n t name
NAME
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
MARK

124/185
Passage de paramètres

Il y a plusieurs façons de passage de paramètres :


Appel de la procédure en spécifiant les paramètres
Appel de la procédure sans paramètre si ce dernier est un
paramètre d’entrée initialisé
Appel de la procédure en changeant la position des
paramètres (il faut spécifier le nom du paramètre)

125/185
Passage de paramètres
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
Passage de paramètres
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 /

P r o cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s .
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 procédures et les fonctions stockées

Sont des blocs PL/SQL qui possèdent un nom


Consistent à ranger le block PL/SQL compilé dans la base de
données (CREATE)
Peuvent être réutilisées sans être recompilées (EXECUTE)
Peuvent être appelées de n’importe bloc PL/SQL
Peuvent être regroupées dans un package

128/185
Les procédures stockées
Syntaxe
CREATE [ OR REPLACE ] PROCEDURE <Nom Proc >[( P1 , . . . , Pn ) ]
[ D é 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 procédure est correcte


Ou
Procedure Created with compilation errors : Corriger
les erreurs → SHOW ERRORS;

129/185
Les procédures stocké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 procédures stockées
Syntaxe
La procédure stockée est appelée par les applications soit :
En utilisant son nom dans un bloc PL/SQL (autre procé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 procédures stocké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 pé 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 stockées
Syntaxe
CREATE [ OR REPLACE ] FUNCTION <Nom Fonc >[( P1 , . . . , Pn ) ]
RETURN Type I S
[ D é 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 stocké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 stockées
Syntaxe
La fonction stockée est appelé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
Appel des fonctions stockées
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 yé 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
Appel des fonctions stockées
Exemple

SQL> VARIABLE VNb


SQL> EXECUTE : VNb:=NbEmp(&VDep , VErr ) ;
P r o cé d u r e PL/SQL t e r m i n é e a v e c s u c c è s .
SQL> PRINT VNb

VNB
−−−−−−−−−−
300

137/185
Suppression des procédures et des fonctions stockées
Syntaxe

Comme tout objet manipulé par Oracle, les procédures et les


fonctions peuvent être supprimées si nécessaire
Cette suppression est assurée par la commande suivante :
DROP PROCEDURE nomprocedure ;
DROP FUNCTION nomfonction ;

138/185
Suppression des procédures et des fonctions stockées
Exemple

SQL> DROP PROCEDURE AjoutProd ;


Procedure dropped .

SQL> DROP FUNCTION NbEmp ;


Function dropped .

139/185
Les procédures et les fonctions stocké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 :


procédures, fonctions, curseurs, variables, ...
Consiste en deux parties :
Spécification (déclaration)
Corps (implémentation)
Ne peut pas être appelé, ni paramétré ni imbriqué
Permet à Oracle de lire plusieurs objets à la fois en mémoire

141/185
Développement des packages

Sauvegarder l’énoncé de CREATE PACKAGE dans deux


fichiers différents (ancienne/dernière version) pour faciliter de
éventuelles modifications
Le corps du package ne peut pas être compilé s’il n’est pas
déclaré (spécifié)
Restreindre les privilèges pour les procédures à une personne
donnée au lieu de lui donner tous les droits sur toutes les
procédures

142/185
La spécification du package
Syntaxe

Contient la déclaration des curseurs, variables, types, procédures,


fonctions et exceptions
CREATE [OR REPLACE ] PACKAGE <Nom Package>
I S [ D é 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 é c l a r a t i o n d e s c u r s e u r s ]
[ D é c l a r a t i o n d e s p r o c é d u r e s e t f o n c t i o n s ]
[ D é 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 spé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 ,
. . . , PErr Out Number ) ;
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 ,
. . . , PErr Out Number ) ;
Procedure AffProd ;
EndPackProd ;
/

144/185
Le corps du package
Syntaxe

On implémente les procédures et fonctions déclarées dans la


spécification
Create [ Or R e p l a c e ] Package Body <Nom Package> Is
[ I m p l é m e n t a t i o n p r o c é 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 procédures / fonctions du package
Syntaxe

Les procédures et les fonctions définies dans un package sont


appelées de la façon suivante :

<NomPackage>.<NomProcedure >[( P a r a mè t r e s ) ] ;

Var := <NomPackage>.<NomFonction >[( P a r a mè t r e s ) ] ;

148/185
Appels des procé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 é ’ ) ;
Else
DBMS Output . P u t L i n e ( ’ E r r e u r ’ ) ;
End I f ;
End ;
/

149/185
Packages : Exemples

Cré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 é é 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 ê t r e d é c l a r é
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 é c i f i c a t i o n

SQL>

151/185
Les triggers (Déclencheurs)

Un trigger est un programme PL/SQL qui s’exécute


automatiquement avant ou après une opération LMD
(Insert, Update, Delete)
Contrairement aux procédures, un trigger est déclenché
automatiquement suite à un ordre LMD

152/185
Evénement-Condition-Action

Un trigger est activé par un événement


Insertion, suppression ou modification sur une table
Si le trigger est activé, une condition est évaluée
Prédicat qui doit retourner vrai
Si la condition est vraie, l’action est exécutée
Insertion, suppression ou modification de la base de données

153/185
Composants du trigger

À quel moment se déclenche le trigger ?


BEFORE : le code dans le corps du trigger s’exécute avant les
évènements de déclenchement LMD
AFTER : le code dans le corps du trigger s’exécute avant les
évènements de déclenchement LMD

154/185
Composants du trigger

Les évènements du déclenchement :


Quelles sont les opérations LMD qui causent l’exécution du
trigger ?
INSERT
UPDATE
DELETE
La combinaison des ces opérations

155/185
Composants du trigger

Le corps du trigger est défini par un bloc PL/SQL anonyme


[DECLARE]
BEGIN
[ EXEPTION ]
END;

156/185
Composants du trigger
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 pé 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
Composants du trigger
Exemple
Cré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 dé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 >;

Dé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 gérer l’ancienne et la nouvelle


valeurs manipulé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 à jour la table classe suite à une insertion d’un
nouvel é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 prédicats inserting, updating et deleting

Inserting:
True: Le trigger est déclenché suite à une insertion
False: Sinon
Updating:
True: le trigger est déclenché suite à une mise à jour
False: sinon
Deleting:
True: le trigger est déclenché suite à une suppression
False: sinon

162/185
Les pré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
Séquences
Syntaxe
Auto-incrémentation d’une colonne (évite les doublons)
Dé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 séquence
Pseudo-colonne NEXTVAL : Incrémentation de la séquence et
retourne la nouvelle valeur

164/185
Sé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 requête SQL avant de


l’exécuter
Possibilité de création d’un code générique et réutilisable
(sinon simple paramètrage de valeur de remplacement de la
clause where)
Execute immediate chaine_de_caractères ;
chaine_de_caractères est une commande sql donné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 unité logique de travail, un ensemble


d’instructions de mise à jour des données que SQL traité comme
une seule entité :
soit toutes les instructions sont exécutées ensemble,
soit aucune ne l’est.
Exemple :
si une somme d’argent doit transiter d’un compte à un autre, les
deux opérations (crédit et débit) de mise à jour doivent
absolument s’effectuer toutes les deux (ou ne pas s’effectuer du
tout) pour que la cohérence des données soit respectée.

168/185
Gestion des transactions

Le mécanisme des transactions est nécessaire parce que divers


événements peuvent interrompre l’exécution d’une séquence
d’instructions :
défaillance du système,
panne de courant, micro-coupure,
le désir de revenir en arrière et abandonner les modifications
faites jusqu’alors.

169/185
Gestion des transactions

Dans Oracle, le début d’une transaction est implicitement


défini par le début de la session, ou par la dernière instruction
COMMIT ou ROLLBACK.
Les instructions du DDL et du DCL exé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 exécute la commande COMMIT.

170/185
Gestion des transactions

Tant que les changements à la base n’ont pas eu lieu de façon


permanente :
l’utilisateur peut voir ces changements par des ordres SELECT,
les autres utilisateurs ne voient pas les modifications,
l’utilisateur peut défaire les modifications par l’instruction
ROLLBACK.
Un ROLLBACK automatique a lieu en cas de panne du système

171/185
Contrôle de transactions
Commandes COMMIT et ROLLBACK

Lancer une transaction avec la première commande du LMD à


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
Contrô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 ;
INSERT INTO temp ( num col1 , num col2 , c h a r c o l )
VALUES ( 2 , 2 , ’ROW 2 ’ ) ;
SAVEPOINT b ;
INSERT INTO temp ( num col1 , num col2 , c h a r c o l )
VALUES ( 3 , 3 , ’ROW 3 ’ ) ;
SAVEPOINT c ;
ROLLBACK TO SAVEPOINT b ;
COMMIT;
END;

Quel est l’état de la table à la fin de l’exécution du bloc ?

174/185
Exemple de transactions en parallèle
CREATE TABLE T ( A NUMBER,
B NUMBER, PRIMARY KEY (A));

INSERT INTO T VALUES ( 1, 1);


INSERT INTO T VALUES ( 2, 2);
SELECT * FROM T ;

Le résultat obtenu est :


A B
-------- ---------
1 1
2 2

COMMIT ;

Validation effectuée.

175/185
Exemple de transactions en parallèle
INSERT INTO T VALUES ( 3, 3);
INSERT INTO T VALUES ( 4, 4);
SELECT * FROM T ;
Le résultat obtenu est :
A B
--------- ---------
1 1
2 2
3 3
4 4
ROLLBACK ;
Annulation (ROLLBACK) effectuée.

SELECT * FROM T ;
Le résultat obtenu est :
A B
--------- ---------
1 1
2 2

176/185
Exemple de transactions en parallèle
INSERT INTO T VALUES ( 3, 3);
SAVEPOINT A ;
1 ligne créée.
Point de sauvegarde (SAVEPOINT) créé.

INSERT INTO T VALUES ( 4, 4);


1 ligne créée.

SELECT * FROM T ;
Le résultat obtenu est :
A B
--------- ---------
1 1
2 2
3 3
4 4

177/185
Exemple de transactions en parallèle

ROLLBACK TO SAVEPOINT A;
Annulation (ROLLBACK) effectuée.

SELECT * FROM T ;
Le résultat obtenu est :
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 résultat obtenu est : Le résultat obtenu est :
A B A B
--------- --------- --------- ---------
1 1 1 1
2 2 2 2
3 3 3 3

179/185
Blocage des tuples et des tables

Transaction T1 Transaction T2

update t set b = b - 2 ;
1 ligne mise à 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
Blocage des tuples et des tables
Transaction T1
COMMIT;
Validation effectuée.

Transaction T2
1 ligne mise à jour.

select * from t;

A B
--------- ---------
1 -3
2 -2
3 -1
COMMIT;
Validation effectuée.

181/185
Blocage des tuples et des tables
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
Blocage des tuples et des tables

Transaction T1 Transaction T2
lock table t IN EXCLUSIVE MODE;

Table(s) verrouillée(s). En attente

Mises à jour En attente

Mises à jour lock table t IN EXCLUSIVE MODE;


etc...
Commit ;

183/185
Blocage des tuples et des tables

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 partagé ou exclusif ... (SHARE, SHARE UPDATE,
EXCLUSIVE)

184/185
Bilan

185/185