5

Les exceptions
 Généralités sur le traitement des erreurs
Lorsqu’un programme est en exécution, certaines circonstances
exceptionnelles peuvent compromettre la poursuite normale de son
exécution. Le programme peut s'arrêter d’une façon prématurée et
inattendue si on ne traite pas correctement ces circonstances qui peuvent
être liées à plusieurs types d’erreurs, comme par exemple:
• Erreur matérielle (imprimante débranchée, serveur en panne, câbles
défectueux ….)
• Contrainte physique (disque plein, dépassement de la capacité de la
mémoire, …)
• Erreurs de programmation (cas non prévu par le programme, division
par zéro, ouverture d’un fichier qui n’existe pas, …)
• Utilisateur récalcitrant (type de données rentrées par l’utilisateur
incorrect)
 Gérer les exceptions
La gestion des exceptions est un mécanisme qui permet d’avoir un moyen
souple et efficace pour la gestion des erreurs dans les programmes. Les
exceptions permettent d'écrire le flux principal du code et de traiter les cas
exceptionnels ailleurs. Cette approche possède plusieurs avantages :
• Dissocier la détection d'une erreur de son traitement.
• Séparer la gestion des erreurs du reste du code, donc contribuer à la
lisibilité des programmes.
• Séparation du code de gestion des erreurs du code de logique métier.
• Meilleure lisibilité des programmes.
 Intercepter les exceptions
Le traitement ou l’interception des exceptions se fait dans la partie
EXCEPTION du bloc Pl/Sql à l’aide des mots clés WHEN et THEN:

Syntaxe:

Pour pouvoir intercepter les autres types d’exceptions qui ne sont pas
prises en charge par la/les exceptions déclarées, on fait appel aux mots clés
EXCEPTION
WHEN
WHEN OTHERS et THENTHEN <liste_instructions> ;
<nom_exception>

Syntaxe:

EXCEPTION
WHEN OTHERS THEN <liste_instructions> ;
 Types d’exception
Il existe trois types d’exceptions :
• Exceptions prédéfinies (Exceptions systèmes nommées): Sont des
erreurs qui se produisent lors de l'exécution du programme. Oracle
attribue un nom à chaque exception (NO_DATA_FOUND).
• Exceptions définies par l’utilisateur (Exceptions utilisateurs
nommées): Sont déclenchées à la suite d’erreurs dans le code applicatif et
nommées lors de leur déclaration par le développeur .
• Exception internes (Exceptions système anonymes): Sont des erreurs
qui proviennent de l'environnement Oracle Database et déclenchée
automatiquement par le système d’exécution. Elles n’ont pas de nom mais
un code d’erreur (ORA-27102 :mémoire insuffisante)
 Exceptions prédéfinies
Nom d’exception Erreur Oracle Détails
NO_DATA_FOUND ORA-01403 déclenché si la
commande SELECT INTO
ne retourne aucune ligne
ou si on fait référence à
un enregistrement non
initialisé d’un tableau
PL/SQL
STORAGE_ERROR ORA-06500 problème de ressources
mémoire dû à PL/SQL
TOO_MANY_ROWS ORA-01422 la commande SELECT
INTO retourne plus d’une
ligne
ZERO_DIVIDE ORA-01476 tentative de division par
zéro
NOT_LOGGED_ON ORA-01012 tentative d’accès à la
base sans être connecté
INVALID_CURSOR ORA-01001 opération incorrecte sur
un curseur, comme par
exemple la fermeture
d’un curseur qui n’a pas
été ouvert
Pour plus de détails: https://docs.oracle.com/cd/B10500_01/appdev.920/a96624/07_errs.htm
 Exemple
Exception Simple:

Exception en utilisant when others:

 Exceptions définies par l’utilisateur
Pl/Sql permet aux développeurs de définir ses propres exceptions en
suivant les étapes suivantes:
1. Nommer l’exception dans la partie DECALRE du bloc Pl/Sql
2. Déclencher explicitement l’exception dans l’endroit convenable à
l’aide de la commande RAISE
3. Définir le traitement à effectuer dans la partie EXCEPTION du bloc
(Interception de l’exception)
DECLARE
Nom_Exception EXCEPTION;
BEGIN
instructions ;
IF (condition_anomalie) THEN RAISE Nom_Exception;
…
EXCEPTION WHEN Nom_Exception THEN
(Instructions de traitement);
END; /
Exemple
 Exception internes
Pour pouvoir intercepter les exceptions internes (erreur oracle non
prédéfinie) il faut:
1. Déclarer le nom de l’exception anonyme dans la partie DECLARE:
DECLARE Nom_exception EXCEPTION;
2. Associer l’exception déclarée au code standard de l’erreur oracle
dans la partie DECLARE à l’aide de la commande PRAGMA
EXCEPTION_INIT:
PRAGMA EXCEPTION_INIT (Nom_exception , Code_erreur_oracle)
3. Définir le traitement à effectuer dans la partie EXCEPTION du bloc
(Interception de l’exception)
DECLARE
Nom_Exception EXCEPTION;
PRAGMA EXCEPTION_INIT(Nom_Exception, code_erreur_oracle)
BEGIN
…
EXCEPTION WHEN Nom_Exception THEN
(Instructions de traitement);
END; /
 SQLERRM & SQLCODE
On peut récupérer la valeur numérique associée à l’erreur via la
fonction SQLCODE
On peut aussi récupérer le message d’erreur associé au code d’erreur
via la fonction SQLERRM
Exemple
 Quelques règles d’interception d’exceptions
• Le mot clé EXCEPTION débute la section de la gestion des
exceptions
• Plusieurs exceptions sont permises (définies et pré-définies)
• Une seule exception est exécutée avant de sortir d’un bloc
• WHEN OTHERS est la dernière clause:
• Intercepte toutes les exceptions non gérées dans la même
section d’exception
• Utilisez le gestionnaire d’erreurs OTHERS et placez le en
dernier lieu après tous les autres gestionnaire d’erreurs, sinon il
interceptera toutes les exceptions mêmes celle qui sont
prédéfinies.
La portée des exceptions
6

Les programmes stockés

 Qu’est-ce qu’une procédure stockée
Une procédure est un bloc PL/SQL nommé, stocké dans la base de
données sous format compilé. Elle effectue un traitement et peut recevoir
des arguments. Elles permet de :
• Réduire le trafic sur le réseau (les procédures sont locales sur le
serveur)
• Mettre en œuvre une architecture client/serveur de procédures et
rendre indépendant le code client de celui des procédures (à l’API près)
• Masquer la complexité du code (simple appel de procédure avec
passage d’arguments)
• Sécuriser l’accès aux données (accès à certaines tables seulement à
travers les procédures)
• Optimiser le code, elles sont compilées avant l’exécution du
programme et sont exécutées immédiatement si elles se trouvent dans la
SGA (zone mémoire gérée par ORACLE). De plus une procédure peut être
exécutée par plusieurs utilisateurs.
 Création d’une procédure stockée
Une procédure stockée est créée de la forme suivante:

[ CREATE [ OR REPLACE ] ] PROCEDURE <nom_procedure>

[ ( <nom_argument> [ { IN | OUT | IN OUT } ] TYPE [ , . . . ] ) ]
{ IS | AS }
BEGIN . . .
EXCEPTION WHEN <nom_exception> THEN <instructions>;
END [ <nom_procedure> ];
IN: indique que le paramètre transmis par le programme appelant n’est
pas modifiable par la procédure.
OUT: indique que le paramètre est modifiable par la procédure
IN OUT: indique que le paramètre est transmis par le programme appelant
et renseigné par la procédure.
Exemple
 Appel d’une procédure stockée
On peut appeler une procédure stockée de plusieurs façons:

1. <nom_procedure> [ (<argument1>, . . . ] ) ] ;
Cet appel peut se faire dans un bloc PLSQL (anonyme ou programme
stocké)
1. EXEC | EXECUTE <nom_procedure> [ (<argument1>, . . . ] ) ]
2. CALL <nom_procedure> [ (<argument1>, . . . ] ) ] ;
procédure stockée avec argument
Exemple d’Utilisation de IN
Exemple d’Utilisation de OUT
Exemple d’Utilisation de IN OUT
 Qu’est-ce qu’une fonction
Une fonction est une procédure qui retourne une valeur.

[ CREATE [ OR REPLACE ] ] FUNCTION <nom_fonction>

[ ( <nom_argument> TYPE [ , . . . ] ) ]
RETURN <type_valeur>
{ IS | AS }
BEGIN . . .

RETURN EXPRESSION;
EXCEPTION WHEN <nom_exception> THEN <instructions>;
END [ <nom_fonction> ];
N.B: SEUL le type d’argument IN est acceptable par les fonctions
Exemple
Fonction avec argument
 Appel d’une fonction
Les fonctions PL/SQL définies par l’utilisateur peuvent être appelées dans
un bloc PLSQL (anonyme ou programme stocké). La valeur retournée peut
être affectée à une variable.
Exemple:

Les fonctions PL/SQL définies par l’utilisateur peuvent être appelées

depuis toute expression SQL dans laquelle on peut utiliser une fonction
prédéfinie. L’utilisateur appelant cette fonction doit avoir le privilège EXECUTE
sur celle-ci pour pouvoir l’appeler depuis un ordre SQL.
Exemple:
 Passage de paramètres

Comme pour les curseurs, Il existe deux types d’affectation de valeur aux
paramètres:

1. Affectation par position: le paramètre effectif est substitué par la valeur formelle
2. Affectation par nom: le paramètre actuel est substitué par la valeur formelle à
l'aide du symbole de flèche (=>)

L’ordre spécifié dans la déclaration des paramètres de curseur doit être respecté lors de
l’ouverture du curseur.

On peut mélanger les deux types d’affectation; cependant, la notation de position doit
précéder la notation nommée.

Comme pour toute les variables, Il existe une autre manière d’affecter les valeurs à
des paramètres en ajoutant le mot clé DEFAULT. Ceci est applicable aux curseurs.

Exemple:
 Les sous programmes

Un sous programme peut être déclaré dans n’importe quel bloc

PL/SQL. C’est une alternative à la création de procédures/fonction à usage
unique (sans stockage) pour les appeler depuis d’autres programmes.

Le sous programme doit être déclaré dans la section déclarative du

bloc et doit être le dernier élément de cette section, après tous les autres
éléments du programme.

Si une variable est déclarée après la fin du sous programme cela créera
une erreur de compilation.
Exemple de sous programme
 Procédure VS Fonction
Les procédures sont créées pour stocker une série d’actions à exécuter
ultérieurement. Une procédure peut accepter ou non des paramètres, qui ne
sont pas limités en nombre et peuvent être transférés du et vers
l’environnement appelant.

Les fonctions sont créées pour calculer une valeur, elles doivent retourner
une valeur à l’environnement appelant. Une fonction peut accepter ou non
des paramètres qui sont transmis de l’environnement. Une fonction ne peut
retourner qu’une seule valeur et ne peut pas accepter de paramètre OUT ou
IN OUT.
7

Les déclencheurs (triggers)

 Qu’est-ce qu’un déclencheur
Un déclencheur ou trigger en anglais est un bloc PL/SQL qui s’exécute
implicitement chaque fois qu’un événement particulier a lieu.
Il peut être mis en place soit sur une base de données soit sur une
application. On se focalisera sur ceux qui sont appliqués aux BD.
Le trigger (déclencheur) de base de données est exécuté implicitement
lorsqu’un ordre INSERT, UPDATE ou bien DELETE est exécuté sur la table
associé à ce dernier. Ils sont appelés Déclencheurs LMD.
Ils sont également exécutés implicitement pour les actions de l’utilisateur
ou les actions systèmes de la base de données. Par exemple lorsqu’un
utilisateur se logue ou lorsque qu’un DBA arrête la base de données. Ils sont
appelés Déclencheurs SYSTEME.
 Composants de déclencheurs
Les composants d’un déclencheur sont:
1. Evénement: il s’agit des ordres déclenchant le trigger, par exemple pour
les triggers LMD, une insertion, une mise à jour ou bien une suppression
(Insert, UPDATE et DELETE) .
2. Synchronisation: définit le moment où le trigger sera déclenché, trois
valeurs sont possibles: BEFOR, AFTER et INSTEAD OF
3. Condition: il s’agit d’une condition logique (booléenne) optionnelle.
4. Action: block PL/SQL (programme stocké) exécuté lorsque la condition est
vérifiée.
 Création d’un trigger
Un trigger est créée de la forme suivante:
[ CREATE [ OR REPLACE ] ] TRIGGER <nom_trigger>
timing
Event 1 [OR Event2 Or Event3]
On table_name/view_name
Trigger_body
Timing : Indique l’instant auquel sera déclenché le trigger en relation avec
l’événement déclenchant: BEFOR, AFTER ou bien INSTEAD OF
Event: Identifie l’opération de manipulation de données qui déclenche le
trigger : INSERT, UPDATE, DELETE ou bien d’autres.
Table/View_name: Indique la table ou la vue (pour l’option INSTEAD OF)
qui sera associée au trigger (LMD).
Trigger_body: Le corps du trigger définissant les actions qui seront
exécutées. Il peut être un bloc PL/SQL entre BEGIN et END comme il peut être
un appel à une procédure.
 Syntaxe de Création d’un Trigger LMD
[ CREATE [ OR REPLACE ] ] TRIGGER <nom_trigger>
{BEFOR|AFTER|INSTEAD OF} // événement
{INSERT|DELETE|UPDATE[OF liste de colonnes]} ON table
[FOR EAH ROW]
[WHEN (condition de déclenchement)] // condition
DECLARE
…
BEGIN
… //Action avec les données
EXCEPTION
…
END;
/
N.B: L’option INSTEAD OF uniquement pour vues multi-tables
Exemple
Exemple
 Les niveaux d’exécution
Il existe deux types de déclencheurs:

• Les triggers de tables: ou bien triggers statement, sont déclenchés une

seule fois même si aucune ligne n’est concernée. Il sont utiles si l’action du
trigger ne dépend pas des données des lignes concernées ou des données
fournies par l’évènement déclenchant lui-même.

• Les triggers de lignes: ou bien triggers Row est un trigger dont le corps
s’exécute une fois pour chaque ligne concernée par l’évènement
déclenchant. Si l’évènement déclenchant n’affecte aucune ligne, le corps
du trigger n’est pas exécuté.
Exemple
 Utilisation des qualificatifs OLD et NEW
Dans un déclencheur de niveau ligne (Trigger Row) il est possible de faire
référence aux valeurs d’une colonne avant et après le changement dû à un
ordre DML en préfixant le nom de celle-ci du qualificatif :OLD ou :NEW.
les valeurs des qualificatifs OLD et NEW varient selon l’ordre DML
effectué:

Ordre DML Valeur de OLD Valeur de New

INSERT Pas d’accès (Null) Valeur insérée
UPDATE Valeur avant la Valeur après la
mise à jour mise à jour
DELETE Valeur avant la Pas d’accès (Null)
suppression
Exemple
 La clause REFERENCING
La clause REFERENCING permet de créer un alias pour les qualificatifs OLD
et NEW.

Syntaxe:

REFERENCING [OLD AS <nom_ancien>] [NEW AS <nom_nouveau>].

Exemple:
 Déclenchement conditionnel
Grâce à la condition WHEN il est possible de restreindre le déclenchement
du trigger Row selon certaines conditions.

Exemple:
 Les attributs conditionnels
Il est possible de combiner plusieurs évènements déclenchant en une
seule déclaration et personnaliser les actions du trigger selon l’événement
déclenchant. Ceci est grâce aux attributs conditionnels INSERTING, UPDATING
et DELETING à l’intérieur du corps du trigger.
Ces attributs sont inclus dans des expressions conditionnelles de type IF-
THEN-ELSE. Exemple:
 Manipulation des triggers
Lorsque l’on a créé un trigger, il existe des commandes permettant de les
manipuler afin de les activer, les désactiver, les recompiler après modification
et les supprimer.

Activation/Désactivation d’un trigger:

ALTER TRIGGER trigger_name DISABLE | ENABLE
ALTER TABLE table_name DISABLE | ENABLE ALL TRIGGERS

Recompilation et supression d’un trigger:

ALTER TRIGGER trigger_name COMPILE;
DROP TRIGGER trigger_name ;
 Quelques règles sur les déclencheurs
• Eviter de remplacer une contrainte d’intégrité par un trigger.
• Il ne faut utiliser les déclencheurs que si nécessaire, son utilisation
exagérée peut aboutir à des interdépendances complexes, ce qui peut rendre
difficile la maintenance des grosses application.
• Eviter les triggers récursifs, qui contiennent une opération DML modifiant
la même table.
• Eviter les triggers en cascade dont l’action entraîne le déclenchement d’un
second trigger et ainsi de suite.

N.B: Le serveur Oracle autorise l’exécution en cascade de 32 triggers

maximum en même temps, mais on peut limiter le nombre de triggers en
cascade en changeant la valeur du paramètre d’initialisation de la base de
données OPEN_CURSORS.