LE LANGAGE PL/SQL
1 / INTRODUCTION :
SQL est un langage complet pour travailler sur une base de donnée relationnelle, mais il ne comporte pas des instructions procédurales. PL/SQL comprend quant à lui :
v La partie LID (Langage d’Interrogation des données) de SQL (Select),
v la partie LMD (Langage de Manipulation des Données) de SQL (Update, Insert,…) v la gestion des transaction (Commit, Rollback…)
v les fonctions standard de SQL
v plus une partie procédurale (IF, WHILE,…)
PL/SQL est doncun langage algorithmique complet
REMARQUE : PL/SQL ne comporte pas d’instructions de LDD (Create, Alter…)
2/ STRUCTURE D’UN BLOC PL/SQL
PL/SQL n'interprète pas une commande, mais un ensemble de commandes contenues dans un programme ou bloc PL/SQL.
La structure d’un bloc est la suivante:
DECLARE
Déclarations de variables, constantes, exception;
BEGIN
Section obligatoire contenant des instructions SQL et PL/SQL ou des blocs fils (Possibilités d’imbrication de blocs)
EXCEPTION
Traitement des exceptions (gestion des erreurs)
END;
REMARQUES :
Les sections Declare et Exception sont optionnelles
Exemple d’un bloc PL/SQL :
DECLARE
qte_stock number(5);
BEGIN
Select quantite into qte_stock from PRODUITS where codprod= ‘p1’;
-- contrôle du stock suffisant If qte_stock > 0
then update produits set quantite=quantite-1 where codprod= ‘p1’;
Insert into achat values (‘p1', SYSDATE) else
Insert into acheter values ('Plus de p1',SYSDATE); end If, commit, END;
3/. LES DECLARATIONS PL/SQL
La partie déclarative dans un bloc PL/SQL, peut comporter trois types de déclarations. Elle est délimitée par les mots-clé :
v DECLARE, qui spécifie le début de la déclaration des variables et
v BEGIN, qui signifie la fin de la déclaration et le début de la partie des commandes. v Les types de déclarations possibles dans cette partie sont les suivants :
ü déclaration des variables et des constantes, ü déclaration de curseurs,
ü déclaration des exceptions.
3.1 Types de données
Chaque variable ou constante utilisée dans un bloc PL/SQL, possède un type de données. PL/SQL offre deux variétés de types de données prédéfinies : scalaire et composé.
Les types scalaires :
Binary_integer : entiers entre –231
et 231-1
Number : un numérique Positive : entiers positifs Natural : entiers naturels
Decimal , float, integer, real sont des sous-types de number
Char : chaîne de caractère à taille fixe allant jusqu’à 32 767 caractère (au lieu de 255 dans la
définition des colonnes des tables)
Varchar2 : est une chaîne de caractère de longueur variable allant jusqu’à 32 767 (au lieu de
2000 dans la définition des colonnes des tables)
Boolean : type booléen ses valeurs possibles sont TRUE, FALSE, NULL Date : type date d’Oracle
Rowid : type interne à Oracle composé de 6 octets qui permet d’identifier une ligne unique
d’une table et d’offrir un accès rapide aux données.
Les types Composés :
Table : c’est le type tableau
3.2 Variables et constantes
La déclaration d'une variable consiste à allouer un espace pour stocker et modifier une valeur. elle est typée et peut recevoir une valeur par défaut et/ou un statut NOT NULL.
Une constante est définie comme une variable, mais l'utilisateur ne peut pas modifier son contenu.
3.2.1. La définition des variables en PL/SQL
Les variables se définissent dans la partie DECLARE, du bloc PL/SQL en utilisant la syntaxe suivante :
nomvariable [CONSTANT]
{type | variable%TYPE | colonne_de_table.%ROWTYPE} [NOT NULL]
[{ :=|DEFAULT} expression PL/SQL]
Remarques :
L'attributCONSTANT permet de figer l'affectation d'une variable.
L'attributNot NULL rend obligatoire d'initialiser la variable lors de sa définition. On peut faire référence à une colonne d'une table par la déclaration :
♦ nom_variable TABLE.COLONNE%TYPE,
On peut faire référence à une ligne d'une table par la déclaration
♦ Nom_variable TABLE%ROWTYPE,
On peut faire référence à une variable précédemment définie par l'instruction
♦ Nom_variable Pnom variable%TYPE
♦ L'initialisation d'une variable se fait par l'opérateur ‘ :=’ suivi ü d'une constante,
ü d'une expression PL/SQL, ü d'une fonction PL/SQL.
Les variables peuvent également être définies dans l'environnement extérieur au Bloc PL/SQL par exemple comme des champs de l'écran en Form Builder. Ces variables seront utilisées préfixées de':'.
Exemples de déclaration de variables :
Total NUMBER(9,3); Nom CHAR(4) := ‘ISET’;
Longeur NUMBER NOT NULL := LENGTH (Nom)*2; Date_Création DATE;
Numéro EMPLOYE.EMPNO%TYPE; Dpt DEPARTEMENT%ROWTYPE; Prénom Nom%TYPE;
3.2.2 L’affectation des variables PL/SOL
Deux possibilités d’affectation ou d’assignement sont disponibles: par l'opérateur d'affectation:':=',
par la clause Select ... Into…
La difficulté dans l'utilisation de la clause Select résulte du nombre de lignes ou d'occurrences retourné.
Si le Select retourne une et une seule valeur l'affectation s'effectue correctement. Par contre Si le SELECT ne retourne aucune ligne, l’erreur PL/SQLNO_DATA_FOUND sera générée. Si le SELECT retourne plusieurs lignes : l’erreur TOO_MANY_ROWS sera générée.
3.3. Les tableaux en PL/SQL
Nous avons vu précédemment que le langage PL/SQL fournit deux types d'objets composés: • les tableaux (TABLE),
• les enregistrements (RECORD).
Les tableaux sont conçus comme les tables de la base de données. Ils possèdent une clé primaire(index) pour accéder aux lignes du tableau.
Un tableau, comme une table, ne possède pas de limite de taille. De cette façon, le nombre d'éléments d'un tableau va croître dynamiquement.
3.3.1 La déclaration d'un tableau
Les tableaux PL/SQL doivent être déclarés en deux étapes. 1.Déclaration du type de la TABLE
2.Déclaration d’une table de ce type.
On peut déclarer un type TABLE dans la partie déclarative d'un bloc ou d'un sous-programme en utilisant la syntaxe suivante :
TYPE nom_type IS TABLE OF
{typecolonne | variable%TYPE | table.colonne%TYPE} [NOT NULL]
INDEX BY BINARY_INTEGER ;
Norn_type : utilisé ultérieurement dans la déclaration des tables PL/SQL. typecolonne : type de données comme CHAR, DATE, ou NUMBER.
Lorsque le type est déclaré, on peut déclarer des tableaux de ce type de la façon suivante :
Nom_tab nom_type ;
3.3.2 L'accès aux éléments d'un tableau
Pour accéder à un élément du tableau, on doit spécifier une valeur de clé primaire en respectant la syntaxe suivante :
Nom_tab(valeur_clé_primaire) ;
Valeur_clé_primaire : doit être du type BINARY_INTEGER
Pour affecter la valeur d'une expression PL/SQL à un élément du tableau, on doit utiliser la syntaxe suivante :
nom_tab(valeur_clé_primaire) := expression_Pl/sql ;
Exemple : DECLARE
TYPE nom_tab_type IS TABLE OF CHAR(25) INDEX BY BINARY-INTEGER; … tab_nom nom_tab_type ; BEGIN … tab_nom(l):='TUNISIE'; … END;
3.4. Les enregistrements prédéfinis (record PL/SOL)
La restriction posée par l'utilisation du type %ROWTYPE pour déclarer un enregistrement réside dans le manque de spécification des types de données au niveau de l'enregistrement.
L'implémentation du nouveau type composé nommé RECORD a permis de lever cette restriction.
3.4.1 La déclaration d'un enregistrement
1. Déclaration du type de l'enregistrement 2. Déclaration de la variable du type défini.
On peut déclarer un TypeRECORD dans la partie déclarative d'un bloc ou d'un sous-programme en utilisant la syntaxe suivante:
TYPE nom_type IS RECORD
(champ {type_champ | table.colonne%TYPE [NOT NULL], champ (type_champ | table.colonne%TYPE [NOT NULL],...)
nomtype : utilisé ensuite dans la déclaration des enregistrements PL/SQL. Type-champ : type de données comme CHAR, DATE ou NUMBER.
Lorsque le type est déclaré,On peut déclarer des enregistrements de ce type de la façon suivante :
Nom_erg nom_type ;
3.4.2 L'accès aux champs d'un enregistrement
Pour accéder à un élément d'une variable de type record, il suffit d'utiliser la syntaxe suivante
Nom_erg.nom_champ
Pour affecter la valeur d'une expression PL/SQL à un élément de l'enregistrement, on doit utiliser la syntaxe suivante :
Nom_erg.nom_champ := expression_pl/sql; Exemple :
DECLARE
TYPE ADRESSE IS RECORD (Numero positive,
Rue varchar2(35), CodePost char(5), Ville varchar2(25), Pays varchar2(30) ); TYPE CLIENT IS RECORD (NumCIi positive, NomCli varchar2(40), Adrcli ADRESSE, CA number(12,3)); monclient CLIENT ; BEGIN monclient.NumCIi := 1234;
monclient.NomCIi := ‘Ben HUSSEIN’; monclient.AdrCli.Numero := 10;
4 STRUCTRES DE CONTROLE
4.1. Les traitements Conditionnels
IF condition_plsql THEN commandes [ELSE commandes] [ELSIF condition_plsql THEN commandes [ELSE commandes]] END IF;
La condition peut utiliser les variables définies ainsi que tous les opérateurs présents dans SQL =,<,>,<=,>=,<>, IS NULL, IS NOT NULL.
Exemple : DECLARE
vjob CHAR(10);
vnom employés.ename%type := ‘BEN SALAH’ ; msg CHAR(30) ;
BEGIN
Select job into vjob from employés where ename = vnom;
--contrôle de la valeur de vjob if vjob is NULL
then msg := vnom || ‘pas de travail'; elsif vjob = ‘Vendeur’ then
UPDATE employés set comm = 100 where ename=vnom ; Msg := vnom || ‘a 100 dinars de commission’ ;
Else
UPDATE employés set comm = 0 where ename=vnom ; Msg := vnom || ‘n’a pas de commission’ ;
End if ; DBMS_OUTPUT.PUT_LINE(msg) ; commit; END ;
4.2 Les Traitements.Répétitifs
4.2.1. l’instruction LOOP
LOOP permet de répéter une séquence de commandes. Cette séquence est comprise entre le mot-clé LOOP, indiquant le début d’une boucle et END LOOP, spécifiant sa fin.
Syntaxe :
LOOP
instructions END LOOP ;
Les commandesEXIT,EXIT WHEN condition permettent de quitter la boucle. Exemple : DECLARE somme number(10) := 0 ; nombre number(5); BEGIN nombre:=0;
LOOP
Nombre:=nombre+1 ;somme := somme + nombre ; if nombre>=10
thenEXIT; end if ;
END LOOP;
DBMS_OUTPUT.PUT_LINE(‘la somme des 10 premiers entiers est ‘ || to_char(somme));
END;
4.2.2. L'instruction FOR …LOOP
FOR compteur IN [REVERSE] var_debut.. var_fin LOOP
instructions
END LOOP ;
compteur. est une variable de type entier, locale à la boucle. Sa valeur de départ est égale par défaut à la valeur de l'expression entière de gauche (var_debut). Elle s'incrémente de 1, après chaque traitement du contenu de la boucle, jusqu'à ce qu'elle atteigne la valeur de droite (var_fin).
5. LES CURSEURS EN PL/SQL
Pour traiter une commande SQL, PL/SQL ouvre une zone de contexte pour exécuter les commandes et stocker les informations.
5.1. Définition
Le curseur permet de nommer cette zone de contexte, d'accéder aux informations et éventuellement de contrôler le traitement. Cette zone de contexte est une mémoire de taille fixe, utilisée par le noyau pour analyser et interpréter tout ordre SQL.
5.2. Les types de curseurs
v Le curseur explicite
Il est créé et géré par l'utilisateur pour traiter un ordre Select qui ramène plusieurs lignes. Le traitement du select se fera ligne par ligne.
v Le curseur implicite
5.3. Les étapes d'utilisation d'un curseur explicite
Pour traiter une requête qui retourne plusieurs lignes, l'utilisateur doit définir un curseur qui lui permet d’extraire la totalité des lignes sélectionnées.
L’utilisation d'un curseur pour traiter un ordre Select ramenant plusieurs lignes, nécessite 4 étapes:
1. Déclaration du curseur 2. Ouverture du curseur 3. Traitement des lignes 4. Fermeture du curseur.
5.3.1. La déclaration d'un curseur
La déclaration du curseur permet de stocker l'ordre Select dans le curseur. La Symtaxe de définition..
Le curseur se définit dans la partie DECALRE d'un bloc PL/SQL.
Cursor nomcurseur [(nomparam type [,nomparam type, ...)] IS Commande_SELECT
Exemple :
Declare
Cursor DEPT_10 is
select ename, sal from emp where depno = 10;
5.3.2. L'ouverture et la fermeture d’un curseur
L'étape d'ouverture permet d'effectuer: 1. l'allocation mémoire du curseur,
2. l'analyse sémantique et syntaxique de l'ordre
3. le positionnement de verrous éventuels (si select for update...)
L'étape de fermeture permet de libérer la place mémoire réservée.
La syntaxe :
OPEN nomcurseur [(nomparam1[,nomparam2 , ...)] /* traitement des lignes */
CLOSE nomcurseur
Exemple :
Begin …
OPEN DEPT_10
/* traitement des lignes*/ CLOSE DEPT_10
5.3.3. Le traitement des lignes
Il faut traiter les lignes une par une et renseigner les variables réceptrices définies dans la partie Declare du bloc.
La syntaxe :
Dans la partie traitement du bloc.PL/Sql, il faut commencer par ouvrir le curseur puis
FETCH nomcurseur INTO {nomvariable [,nomvariable] | nomrecord}
L’ordre fetch ne ramène qu’une seule ligne à la fois. De ce fait il faut recommencer l’ordre pour traiter la ligne suivante.
Exemple :
Declare
Cursor DEPT_10 is
select ename, sal from emp where depno = 10; Vnom emp.name%TYPE ;
Vsalaire emp.sal%TYPE ; Begin
OPEN DEPT_10; LOOP
FETCH DEPT10 into vnom,vsalaire ; --Traitement ligne
END LOOP ; CLOSE DEPT_10; End;
5.4 Les attributs d’un curseur
Les attributs d’un curseur nous fournissent des informations sur l’exécution d’un ordre. Ils sont conservés par PL/SQL après l’exécution du curseur (implicite ou explicite)
Ces attributs permettent de tester directement le résultat de l’exécution. Ils sont résumés dans le tableau suivant :
Curseurs implicites Curseurs explicites
Sql%Found Nomcurseur%Found
Sql%Notfound Nomcurseur %Notfound
Sql%Isopen Nomcurseur %Isopen
Sql%Rowcount Nomcurseur %Rowcount
Sql%Rowtype Nomcurseur %Rowtype
5.4.1 l’attribut %Found
cet attribut est de type booléen (vrai ou faux)
Pour les curseurs implicites, cet attribut est vrai si les instructions insert, update, delete traitent au moins une ligne. Pour les curseurs explicites, il est vrai si le fetch ramène au moins une ligne.
Exemple :
Declare
CURSOR num_cur1 IS SELECT num from tab1 ; CURSOR num_cur2 IS SELECT num from tab2 ; Num1 number ; Num2 number ; somme number := 0; Begin OPEN num_cur1 ; OPEN num_cur2 ; LOOP
FFTCH num_cur1 INTO num1 ; FFTCH num_cur2 INTO num2;
IF (num_cur1%Found) AND (num_cur2%Found) THEN somme:= num1 + num2 ;
INSERT INTO sum_tab VALUES (somme); ELSE Exit ; END IF; END LOOP; CLOSE numl_cur1 ; CLOSE mun_cur2 ; COMMIT; END;
5.4.2. L'attribut %NotFound
cet attribut est de type booléen (vrai ou faux)
Pour les curseurs implicites, cet attribut est vrai si les instructions insert, update, delete ne traitent aucune ligne. Pour les curseurs explicites, il est vrai si le fetch ne ramène plus de ligne.
Exemple :
Declare
CURSOR num_cur1 IS SELECT num from tab1 ; CURSOR num_cur2 IS SELECT num from tab2 ; Num1 number ; Num2 number ; somme number := 0; Begin OPEN num_cur1 ; OPEN num_cur2 ; LOOP
FFTCH num_cur1 INTO num1 ; FFTCH num_cur2 INTO num2;
EXIT WHEN (num_cur1%NotFound) OR (num_cur2%NotFound) ; somme:= num1 + num2 ;
INSERT INTO sum_tab VALUES (somme); END LOOP;
CLOSE numl_cur1 ; CLOSE mun_cur2 ; END;
5.4.3. L'attribut %IsOpen
Cet attribut est de type booléen soit vrai, soit faux.
Le curseur implicite est toujours faux car Oracle referme toujours les curseurs qu'il ouvre après chaque utilisation.
Le curseur explicite est vrai si le curseur est ouvert.
Exemple :
Declare
Cursor Dept10 is
Select ename, sal from emp where deptno=10; Begin
If not (Dept10%lsopen) then open Dept10 ;
End if,
Fetch Dept10 into … --traitement
End ;
5.4.4.'L'attribut %RowCount
Cet attribut est de type numérique. Le curseur implicite indique le nombre de lignes traités par les ordres insert, update, delete.
Le curseur explicite est incrémenté à chaque ordre fetch, donc cet attribut traduit la nième ligne traitée.
Exemple
Declare cursor C1 is
select ename, empno, sal from emp order by sal desc ; nom char(10); numero number(4); salaire number(7,2); Begin Open Cl; Loop .
Fetch cl into nom, numéro, salaire ;
exit when (c1%rowcount > 25) or (cl%notfound); insert into temp values (salaire, numéro, nom);
End Loop; Close C1 ; commit ; End;
5.4.5. L'attribut %Rowtype
Cet attribut permet la déclaration implicite d'une structure dont les éléments sont d'un type identique aux colonnes ramenées par le curseur.
Syntaxe :
Dans la partie déclarative du bloc.
CURSOR nomcurseur IS ordre select; nomrecord nomcurseur%Rowtype;
Les éléments de la structure sont identifiés par:nomrecord.nomcolonne La structure est renseignée par le Fetch :Fetch nomcurseur into nomrecord;
Exemple
Declare
/* la fonction nvl permet de tester la valeur Null d'une colonne si comm=NULL alors nvl retourne 0 sinon nvl retourne la valeur de comm */
cursor c1 is select sal + nvl(comm) saltot, ename from emp; /* l'enregistrement comporte deux colonnes: saltot, ename c1_record c1%Rowtype;
Begin open c1; Loop
Fetch c1 into c1_record; Exit when c1 %notfound ;
if c1_record.saltot > 2000 then
insert into temp values (c1_record.saltot, c1_record.ename); end if,
End Loop; close c1; End;
5.5. Les boucles et les curseurs
L'objectif est de fournir au programmeur une structure simple et efficace pour utiliser les structures de boucle et les curseurs.
Declare
Cursor nomcurseur is ordre_select ; Begin
For nomrecord in nomcurseur Loop
/* traitement End Loop;
End;
Le bloc PL/SQL ci-dessus permet d'obtenir une génération implicite de la structure suivante :
Declare
Cursor nomcurseur is ordre_select; nomrecord nomcurseur%rowtype; Begin
Open nomcurseur ; Loop
Fetch nomcurseur into nomrecord ; Exit when nomcurseur%notfound ; /* traitement
End Loop;
Close nomcurseur; End;
5.6. Le curseur paramètre
Il permet d'utiliser des variables dans le curseur. Principalement dans la clause where.
Il faut pour cela spécifier les noms et les types des paramètres dans la déclaration du curseur.
Cursor nomcurseur (paraml type, param2 type,...) is select ordre_select ,
L'ordre_select utilise les paramètres.
Les types possibles sont : char, number, date, boolean sans spécifier la longueur.
Begin
Exemple :
Declare
cursor c1 (depart number)
is select sal, nvl(comm,0) commi from emp where deptno=depart ;
total number(11,2) := 0 ; sal_sup number(4):=0 ; comm_sup number(4):=0;
Begin
for c1_rec in c1(20) Loop
total:= total+ c1_rec.sal + c1_rec.commi ; if c1_rec.sal > 4000
then sal_sup := sal_sup + 1 ; end if ;
if c1_rec.commi > 3000
then commi_sup:=commi_sup+1 ; end if;
End Loop; insert into temp
values (sal_Sup, comm_sup, 'total salaire’||to_Char(total)); commit ;
End;
5.7. La clause "current of…"
Cette clause permet d'accéder directement à la ligne ramenée par l'ordre Fetch afin de la traiter (update, delete).
v Il faut se réserver la ligne lors de la déclaration du curseur par le positionnement d'un verrou d'intention : (For update of nom_colonne)
v Il faut spécifier que l'on veut traiter la ligne courante au Fetch par la clause :(Where current of nom_curseur)
Exemple :
Declare
Cursor cl is select ename, sal from emp for update of sal ;
Begin
For c1_record in c1 Loop
If c1_ record.sal > 1500 then
insert into resultat values (c1_record.sal, c1_record.sal*1.3, c1_record.ename); update emp set sal = sal * 1.3 where current of c1 ;
end if, End loop ; Commit; End ;
6 Utilisation de sous-programmes
PL/SQL accepte aussi l’utilisation de sous-programmes, nommés procédures et fonctions. Une procédure PL/SQL exécute certaines actions et peut accepter des paramètres optionnels. Une fonction PL/SQL retourne une valeur d’un certain type et peut aussi accepter des
paramètres optionnels.
6.1 Déclaration d’une procédure
La syntaxe de déclaration d’une procédure est :
PROCEDUREnom_procédure [(paramètre1 … [, pramètreN ] IS [déclaration des variables locales]
BEGIN
Instructions PL/SQL [section_exception ] END [nom_procédure]
• Paramètre1 à paramètreN représentent la déclaration des paramètres de la procédure sous la forme : nom_paramètre [IN|OUT|IN OUT] type_données [ { :=|default } valeur].
• déclaration des variables locales représentent les déclarations optionnelles de variables, de constantes, de fonctions et de procédures locales à la procédure.
• section_exception est la section optionnelle de gestion des exceptions de la procédure.
Exemple :
Declare
Vpatient_ID Patient.Patient_ID%type ; Fièvre_elevée constant real := 42 ;
Procedure enregistrer_Temp_Deg_C_Patient (patient_ID varchar2, Temp_Corps_Deg_C real) is
Temp_Deg_F real ; Begin
Temp_Deg_F := (9/5)* Temp_Corps_Deg_C + 32 ; Insert into Patient (Patient_ID, Temp_Corps_Deg_F) Values (patient_ID, Tem_Deg_F) ; Commit ; End ; Begin Vpatient_ID := ‘ES8888’ ;
enregistrer_Temp_Deg_C_Patient (Vpatient_ID, Fièvre_elevée) ; End ;
6.2 Déclaration d’une fonction
La syntaxe de déclaration d’une fonction est :
FUNCTIONnom_fonction[(paramètre1 … [, pramètreN ] RETURNtype_données_fonction IS
[déclaration des variables locales] BEGIN Instructions PL/SQL RETURNval_à_retournée [section_exception ] END [nom_fonction] Exemple :
Soit l’extrait suivant d’une base de données relationnelle d’une application de gestion de scolarité d’une université :
Etudiant(codetu, nometu,adretu)
Matière(codmat, description_mat, coefmat) Moyenne(codetu,codmat, moyenne_mat)
La fonction meilleur_étu_mat retourne le code du meilleur étudiant d’une matière donnée.
Declare
Codmatière Matière.codmat%type; Vcode_etu etudiant.codetu%type;
FUNCTION meilleur_étu_mat (pcodmat varchar2) RETURN varchar2 IS Vcodetu etudiant.codeetu%type ;
BEGIN
Select codetu into Vcodetu From Moyenne M
Where M.moyenne_mat in (Select max(moyenne_mat from Moyenne M Where M.codmat=pcodmat); Return Vcodetu; End ; Begin Codmatière := ‘M001’; Vcode_etu := meilleur_étu_mat(Codmatière);
DBMS_OUTPUT.PUT_LINE(‘Le meilleur étudiant de la matière’ || Codmatière || ‘est : ‘ || Vcode_etu);
6.3 Paramètres de procédure et fonction
Un ou plusieurs paramètres peuvent être passés à une procédure ou à une fonction, de trois façons : IN, OUT ou IN OUT
Exemple :
Declare
Param1 number ; Param2 number ; Param3 number ;
Procedure Différents_Param(P1 IN number, P2 OUT number, P3 IN OUT number) Is Begin P2 := P1 ; P3 := P3 + 1 ; END ; Begin Param1 := 3.14 ; Param3 := 15 ;
Différents_Param(Param1, Param2, Param3) ;
DBMS_OUTPUT.PUT_LINE('param1 = ' || to_char(param1) || 'param2 = ' || to_char(param2) ||
'param3 = ' || to_char(param3) );
End ;
7. GESTION DES ERREURS
Le mécanisme de gestion d'erreurs dans PL/SQL est appelé gestionnaire des exceptions. Il permet au programmeur de planifier sa gestion et d'abandonner ou de continuer le traitement en présence d'une erreur.
Il faut affecter un traitement approprié aux erreurs apparues dans un bloc PL/SQL. C'est pourquoi on distingue2 types d'erreurs ou d'exceptions :
1. Erreur interne Oracle (Sqlcode <= 0) : dans ce cas la main est rendue directement au système environnant.
2. Anomaliedéterminée par 1'utilisateur. La solution :
1. Donner un nom à l'erreur (si elle n'est pas déjà prédéfinie), 2. Définir les anomalies utilisateurs, leur associer un nom, 3. Définir le traitement à effectuer.
7.1. Les exceptions internes
Une erreur interne est produite quand un bloc PL/SQL viole une règle d'Oracle ou dépasse une limite dépendant du système d'exploitation. Les erreurs Oracle générées par le noyau sont numérotées, or le gestionnaire des exceptions de PL/SQL, ne sait que gérer des erreurs nommées.
Pour cela PL/SQL a redéfini quelques erreurs Oracle comme des exceptions. Ainsi, pour gérer d'autres erreurs Oracle, 1'utilisateur doit utiliser le gestionnaire OTHERS ou EXCEPTION_INIT pour nommer ces erreurs.
Les exceptions fournies par Oracle sont regroupées dans ce tableau :
Nom d'exception Valeur SqlCode Erreur Oracle
CURSOR_ALREADY_OPEN -6511 ORA-06511 DUP_VAL_ON_INDEX -1 ORA-00001 INVALID_CURSOR -1001 ORA-01001 INVALID_NUMBER -1722 ORA-01722 LOGIN_DENIED -1017 ORA-01717 NO_DATA_FOUND -1403 ORA-01413 NOT_LOGGED_ON -1012 ORA-01012 PROGRAM_ERROR -6501 ORA-06501 STORAGE_ERROR -6500 ORA-06500 TIMEOUT_ON_RESOURCE -51 ORA-00051 TOO_MANY_ROWS -1422 ORA-01422 TR.ANSACTION_BACKED_OUT -61 ORA-00061 VALUE_ERROR -6502 ORA-06502 ZERO_DIVIDE -1476 ORA-01476
OTHERS : toutes les autres erreurs non explicitement nommées.
Pour gérer les exceptions le programmeurdoit écrire un gestionnaire des exceptions qui prend le contrôle du déroulement du bloc PL/SQL en présence d'une exception.
Le gestionnaire d'exception fait partie du bloc PL/SQL et se trouve après les commandes Il commence par le mot cléEXCEPTION et se termine avec le même END du bloc.
Chaque gestion d'exception consiste à spécifier son nom d'erreur après la clause WHEN et la séquence de la commande à exécuter après le mot clé THEN, comme le montre l'exemple suivant:
DECLARE
Wsal emp.sal%type; BEGIN
select sal into wsal from emp;
EXCEPTION
WHEN TOO_MANY_ROWS then… --gérer erreur trop de lignes WHEN NO_DATA_FOUND then…
--gérer erreur pas de ligne WHEN OTHERS then…
--gérer toutes les autres erreurs END ;
Remarques :
ü L'exception optionnelle OTHERS est toujours située à la fin des exceptions.
ü Pour rattacher une séquence de commandes à plus d'une exception, l'utilisateur peut utiliser l'opérateur booléen OR comme suit :
7.2. Les exceptions utilisateur (externes)
PL/SQL permet à l'utilisateur de définir ses propres exceptions.
La gestion des anomalies utilisateur peut se faire dans un bloc PL/SQL en effectuant les opérations suivantes:
1. Nommer l'anomalie (type exception) dans la partie Déclare du bloc.
DECLARE
Nom_ano Exception;
2. Déterminer l’erreur et passer la main au traitement approprié par la commandeRaise. BEGIN
…
If (condition_anomalie) then raise Nom_ano
3. Effectuer Ie traitement défini dans la partie EXCEPTION du Bloc.
EXCEPTION
WHEN (Nom_ano) then (traitement);
Exemple :
DECLARE
wsal emp.sal%type ; sal_zero Exception ; BEGIN
Select sal into wsal from emp where empno=5; If wsal=0 then
Raise sal_zero;
EXCEPTION
WHEN sal_zero then… -- gérer erreur salaire
WHEN TOO_MANY_ROWS then... --gérer erreur trop de lignes WHEN_NO_DATA_FOUND then ...
-- gérer erreur pas de ligne WHEN OTRERS then ...
--gérer toutes les autres erreurs END;
Le programmeur Peut utiliser les fonctions Sqlcode et Sqlerrm pour coder les erreurs Oracle en Exception.
sqlcode est une fonction propre à PL/SQL qui retourne le numéro (généralement négatif) de l'erreur courante.
Sqlerrm reçoit en entrée le numéro de l'erreur et renvoie en sortie le message de l'erreur codé sur196 octets.
