Base de Données Avancées 2CS-SIT 2-1

Le langage SQL (Structured Query Language) est le principal langage d'accès aux
données et de modification des données dans les bases relationnelles. Les
commandes SQL sont peu nombreuses, de sorte que vous pouvez les apprendre et
les utiliser facilement.
Prenons un exemple :
SELECT first_name, department_id, salary FROM employees;
L'instruction SQL précédente est simple et directe. Cependant, si vous souhaitez
modifier des données extraites de manière conditionnelle, vous vous heurtez
rapidement aux limitations du langage SQL.
Considérons un exemple légèrement différent : pour chaque employé extrait, vous
voulez vérifier l'ID de département et le salaire. Vous avez l'intention d'accorder des
primes différentes aux employés en fonction de leur salaire et des performances de
leur département.
Vous savez que vous devez pour cela exécuter l'instruction SQL ci-dessus, collecter les
données, puis appliquer une logique aux données.
Une solution consiste à écrire pour chaque département une instruction SQL
définissant la prime à accorder aux employés. Rappelez-vous que vous devez
également vérifier le salaire avant de fixer le montant de la prime. Le problème
devient alors un peu plus complexe.
Une solution mettant en oeuvre des instructions conditionnelles pourrait être plus
efficace.

Base de Données Avancées 2CS-SIT 2-2

Pour cela , un développeur doit utiliser un langage général pour les besoins suivants:
1. Certaines requêtes ne peuvent être exprimées avec SQL. En général ce sont des
traitements qui dépendent de plusieurs critères et conditions et qui seront
difficiles à exprimer avec du simple SQL (comme l’exemple précédent). Il sera
possible de les exprimer avec un langage comme C, Java ou autre. Pour écrire de
telles requêtes on peut intégrer du SQL dans un langage puissant.

2. SQL ne supporte pas les actions non déclaratives tel que l’impression d’état,
l’interaction avec l’utilisateur, l’envoi des résultats par mail,…. Les applications
sont composées de plusieurs parties, et l’interrogation et la modification des
données n’est qu’une de ces composants. Les autres composants sont codés avec
les structures classiques des langages de programmation. Pour créer une
application intégrée, il faut combiner le SQL avec les structures des langages de
programmation d’ordre général.

Base de Données Avancées 2CS-SIT 2-3

Il existe deux approches pour utiliser SQL à partir d’un langage de programmation
d’ordre général:

• SQL Dynamique: Le programme peut se connecter et communiquer avec le serveur

de base de données en utilisant un ensemble de fonctions ou méthodes.
Les commandes SQL sont construites sous forme de chaine de caractères. Ces
chaines seront soumises pour exécution et les résultats seront placés dans des
variables du programme, un enregistrement à la fois.
• SQL Intégré: Les instructions SQL intégrées dans le programme sont identifiées au
moment de la compilation en utilisant un préprocesseur. Ce dernier soumet les
instructions SQL au SGBD pour une précompilation et une optimisation. Il remplacera
les instructions SQL dans le programme avec le code et fonctions adéquats avant de
lancer le compilateur du langage.

Base de Données Avancées 2CS-SIT 2-4

Un défi majeur en créant un mélange du SQL avec un langage de programmation est
la différence dans la façon que chaque langage manipule les données. En SQL, les
données sont manipulées sous forme de relations. Les instructions SQL opèrent sur
les relations et retournent des relations comme résultat. Les langages de
programmation opèrent sur une variable à la fois, et ces variables correspondent en
général aux valeurs des attributs dans un tuple d’une relation. Intégrer ces deux types
de langages dans une même application nécessite un mécanisme pour retourner le
résultat d’une requête de manière à ce que le programme puisse la traiter.
Du coté des SGBD, et à travers leurs évolutions, chacun d’eux a créé et adopté son
propre langage procédural. Ceci sert à développer du code, le stocker et l’exécuter au
niveau du serveur de base de données.
On peut citer certains exemples: PL/SQL d’Oracle, TransactSQL de Microsoft SQL
Server, et PL/pgSQL pour PostgreSQL.

Base de Données Avancées 2CS-SIT 2-5

Le langage PL/SQL offre des extensions de programmation pour le langage SQL.

Base de Données Avancées 2CS-SIT 2-6

Le langage PL/SQL définit une structure de bloc pour l'écriture de code. Cette
structure facilite la maintenance et le débogage du code, car il est aisé de
comprendre le flux et l'exécution des programmes.
Le langage PL/SQL offre des fonctionnalités d'ingénierie logicielle modernes telles
que l'encapsulation de données, le traitement des exceptions et l'orientation objet. Il
fait bénéficier le serveur et les outils Oracle des évolutions en matière de
programmation. Il fournit toutes les structures procédurales disponibles dans les
différents langages de programmation de troisième génération (3GL).

Base de Données Avancées 2CS-SIT 2-7

Intégration de structures procédurales au langage SQL : Le principal avantage du
langage PL/SQL est l'intégration de structures procédurales au langage SQL. Ce
dernier est un langage non procédural. Une commande SQL indique au serveur de
base de données quoi faire. En revanche, elle ne peut pas indiquer comment le faire.
Le langage PL/SQL intègre au langage SQL des instructions de contrôle et des
instructions conditionnelles qui permettent de mieux contrôler les instructions SQL et
leur exécution.
Développement de programme modulaire : L'unité de base de tous les programmes
PL/SQL est le bloc. Les blocs peuvent être séquentiels ou imbriqués dans d'autres
blocs. Le développement modulaire de programme présente les avantages suivants :
Regrouper dans des blocs les instructions liées logiquement.
Imbriquer des blocs dans d'autres blocs afin de créer des programmes puissants.
Fractionner une application en modules plus petits.
Maintenance et débogage du code plus simplifiés.
Dans PL/SQL, la modularisation est mise en oeuvre à l'aide de procédures, de
fonctions et de packages.
Portabilité : Les programmes PL/SQL peuvent s'exécuter partout où un serveur Oracle
s'exécute, quels que soient le système d'exploitation et la plate-forme. Il n'est pas
nécessaire de les adapter à chaque nouvel environnement.
Traitement des exceptions : Le langage PL/SQL permet de traiter efficacement les
exceptions. Vous pouvez définir des blocs distincts pour la gestion des exceptions.

Base de Données Avancées 2CS-SIT 2-8

Un bloc PL/SQL est constitué de trois sections :

1. Section déclarative (facultative) : Cette section commence par le mot-clé

DECLARE et se termine là où commence la section exécutable.
Contient les déclarations de l'ensemble des variables, des constantes, des
curseurs et des exceptions définies par l'utilisateur qui sont référencés dans la
section exécutable et dans la section de traitement des exceptions.

2. Section exécutable (obligatoire) : Cette section commence par le mot-clé

BEGIN. Elle doit comporter au moins une instruction. Cependant, la section
exécutable d'un bloc PL/SQL peut contenir un nombre illimité de blocs PL/SQL.
Contient des instructions SQL permettant d'extraire des données de la base. Elle
inclut aussi des instructions PL/SQL permettant de manipuler les données du bloc.

3. Section de traitement des exceptions (facultative) : Cette section est imbriquée

dans la section exécutable. Elle commence par le mot-clé EXCEPTION.
Indique les actions à effectuer lorsque des erreurs et des conditions anormales
surviennent dans la section exécutable.

Tous les blocs PL/SQL doivent se terminer par une instruction END.

Base de Données Avancées 2CS-SIT 2-9

Un programme PL/SQL comporte un ou plusieurs blocs. Ces blocs peuvent être
complètement séparés ou imbriqués.
Les blocs composant les programmes PL/SQL sont de trois types :
Procédures
Fonctions
Blocs anonymes
Procédures : Les procédures sont des objets nommés qui contiennent des
instructions SQL et/ou PL/SQL.
Fonctions : Les fonctions sont des objets nommés qui contiennent des instructions
SQL et/ou PL/SQL. A la différence des procédures, elles renvoient des valeurs dont
elles définissent le type de donnée.
Blocs anonymes
Les blocs anonymes sont des blocs qui ne sont pas nommés. Ils sont déclarés en ligne
(inline) dans une application, à l'endroit où ils doivent être exécutés, et sont compilés
chaque fois que l'application est exécutée. Ces blocs ne sont pas stockés dans la base
de données. Ils sont transmis au moteur PL/SQL en vue de leur exécution.
Si vous souhaitez exécuter de nouveau le même bloc, vous devez réécrire le bloc.
Vous ne pouvez pas appeler le bloc que vous avez écrit précédemment, car les blocs
sont anonymes et n'existent plus après leur exécution.

Base de Données Avancées 2CS-SIT 2 - 10

Dans un bloc PL/SQL, on utilise des instructions SQL pour extraire et modifier les
données des tables de base de données. Le langage PL/SQL prend en charge les
instructions LMD (Langage de manipulation de données) ainsi que les commandes de
gestion des transactions.
Un bloc peut englober plusieurs transactions, une transaction peut s'étendre sur
plusieurs blocs.
Le langage PL/SQL ne prend pas directement en charge les instructions LDD (Langage de
définition de données), telles que CREATE TABLE, ALTER TABLE et DROP TABLE.
Les instructions LDD ne peuvent pas être exécutées directement. Ces instructions
doivent être écrite sous forme d’instructions SQL dynamiques. Les instructions SQL
dynamiques sont créées sous forme de chaînes de caractères lors de l'exécution et
peuvent contenir des marques de réservation pour les paramètres. On peut donc les
utiliser pour exécuter des instructions LDD dans le code PL/SQL.
PL/SQL ne prend pas directement en charge les instructions LCD (Langage de contrôle de
données) telles que GRANT et REVOKE. On peut aussi utiliser du code SQL dynamique
pour exécuter ces instructions.

Base de Données Avancées 2CS-SIT 2 - 11

 select_list Liste comprenant au moins une colonne et pouvant inclure des
expressions SQL, des fonctions de ligne ou des fonctions de groupe

variable_name Variable scalaire contenant la valeur extraite

record_name Enregistrement PL/SQL contenant les valeurs extraites
table Nom de la table de base de données
condition Comprend des noms de colonne, des expressions, des constantes et des
opérateurs de comparaison, ainsi que des variables et des constantes
PL/SQL

Chaque valeur extraite doit être stockée dans une variable à l'aide de la clause INTO.
La clause WHERE est facultative.
Cependant, lorsqu’on utilise la clause INTO, on doit extraire une seule ligne. La
clause WHERE est pratiquement obligatoire (sauf pour les cas des fonctions
d’agrégation).

Il faut Définir dans la clause INTO un nombre de variables égal au nombre de

colonnes de base de données dans la clause SELECT. Il faut aussi s’assurer que les
positions correspondent et que les types de données sont compatibles.

Base de Données Avancées 2CS-SIT 2 - 12

Les interrogations doivent renvoyer une seule ligne
Les instructions SELECT d'un bloc PL/SQL sont conformes à la norme ANSI du code
SQL intégré, selon laquelle les interrogations doivent renvoyer une ligne et une seule.
Une interrogation qui renvoie plusieurs lignes ou n'en renvoie aucune génère une
erreur.
Le compilateur PL/SQL gère ces erreurs en générant des exceptions standards qui
peuvent être gérées dans la section de traitement des exceptions du bloc à l'aide des
exceptions NO_DATA_FOUND et TOO_MANY_ROWS. Incluez une condition WHERE
dans l'instruction SQL pour que cette dernière renvoie une seule ligne.

Comment extraire plusieurs lignes d'une table et opérer sur les données
Une instruction SELECT avec la clause INTO peut extraire une seule ligne à la fois.
Si vous souhaitez extraire plusieurs lignes et opérer sur les données, vous pouvez
utiliser des curseurs explicites.

Base de Données Avancées 2CS-SIT 2 - 13

Où le serveur Oracle traite-t-il les instructions SQL ?
Le serveur Oracle alloue une zone de mémoire privée appelée zone de contexte pour
le traitement des instructions SQL. L'instruction SQL est analysée (parse) et traitée
dans cette zone. C'est également dans cette zone que sont stockées les informations
requises pour le traitement et les données extraites à l'issue du traitement. Vous ne
pouvez pas contrôler cette zone car elle est gérée en interne par le serveur Oracle.
Un curseur est un pointeur vers la zone de contexte. Il s'agit d'un curseur implicite,
géré automatiquement par le serveur Oracle. Lorsque le bloc exécutable lance une
instruction SQL, le compilateur PL/SQL crée un curseur implicite.
Types de curseur
Il existe deux types de curseur :
• Un curseur implicite est créé et géré par le serveur Oracle. Vous n'y avez
pas accès. Le serveur Oracle crée un tel curseur lorsqu'il doit exécuter une
instruction SQL.
• En tant que programmeur, vous pouvez extraire plusieurs lignes d'une table
de base de données, utiliser un pointeur vers chaque ligne extraite, ou
encore opérer sur une ligne à la fois. Dans ce cas, vous pouvez déclarer un
curseur explicitement, en fonction de vos besoins métier. Un curseur
déclaré par les programmeurs est appelé curseur explicite. Vous déclarez ce
curseur dans la section déclarative d'un bloc PL/SQL.

Base de Données Avancées 2CS-SIT 2 - 14

Vous déclarez des curseurs explicites dans PL/SQL quand une instruction SELECT
renvoie plusieurs lignes. Vous pouvez ainsi traiter chaque ligne renvoyée par
l'instruction SELECT.
L'ensemble des lignes renvoyées par une interrogation multiligne est appelé
ensemble actif. Sa taille est égale au nombre de lignes satisfaisant aux critères de
recherche. Le diagramme de la diapositive ci-dessus montre comment un curseur
explicite "pointe" vers la ligne en cours dans l'ensemble actif. Cela permet au
programme de traiter les lignes une par une.
Fonctions des curseurs explicites :
• Ils peuvent effectuer un traitement ligne par ligne, au-delà de la première
ligne renvoyée par une interrogation.
• Ils effectuent le suivi de la ligne en cours de traitement.
• Le programmeur peut contrôler manuellement les curseurs explicites dans
le bloc PL/SQL.

Base de Données Avancées 2CS-SIT 2 - 15

1. Dans la section déclarative d'un bloc PL/SQL, déclarez le curseur en le nommant et
en définissant la structure de l'interrogation associée.
2. Ouvrez le curseur:
L'instruction OPEN exécute l'interrogation. Les lignes identifiées par l'interrogation
constituent l'ensemble actif et peuvent désormais faire l'objet d'une extraction
(fetch).
3. Procédez à l'extraction des données à partir du curseur.
Dans le diagramme de flux présenté dans la diapositive ci-dessus, l'existence de lignes
dans le curseur est testée après chaque extraction. S'il n'y a plus de ligne à traiter,
vous devez fermer le curseur.
4. Fermez le curseur.
L'instruction CLOSE libère l'ensemble de lignes actif. Il est alors possible de rouvrir le
curseur pour établir un nouvel ensemble actif.

Base de Données Avancées 2CS-SIT 2 - 16

Un programme PL/SQL ouvre un curseur, traite les lignes renvoyées par une
interrogation, puis ferme le curseur. Ce dernier marque la position en cours dans
l'ensemble actif.
1. L'instruction OPEN exécute l'interrogation associée au curseur, identifie
l'ensemble actif et positionne le curseur sur la première ligne.

2. L'instruction FETCH extrait la ligne en cours et place le curseur sur la ligne

suivante jusqu'à ce qu'il n'y ait plus de lignes ou qu'une condition indiquée
soit satisfaite.

3. L'instruction CLOSE libère le curseur.

Base de Données Avancées 2CS-SIT 2 - 17

Utilisez la syntaxe illustrée dans la diapositive ci-dessus pour déclarer un curseur.
Dans cette syntaxe :
cursor_name Identificateur PL/SQL
select_statement Instruction SELECT sans clause INTO

L'ensemble actif d'un curseur est déterminé par l'instruction SELECT incluse dans la
déclaration du curseur. La clause INTO est obligatoire dans une simple instruction
SELECT. Cependant, notez que l'instruction SELECT d'une déclaration de curseur
ne peut pas comporter de clause INTO (elle apparaît plus tard dans l'instruction
FETCH). En effet, vous définissez seulement le curseur dans la section déclarative,
vous n'extrayez aucune ligne dans le curseur.

Le curseur c_emp_cursor est déclaré pour extraire les colonnes employee_id

et last_name correspondant aux employés qui travaillent dans le département
dont l'ID department_id est 30.
Le curseur c_dept_cursor est déclaré pour extraire toutes les informations
relatives au département dont l'ID d'emplacement location_id est 1700.

Base de Données Avancées 2CS-SIT 2 - 18

L'instruction OPEN exécute l'interrogation associée au curseur, identifie l'ensemble
actif et positionne le pointeur de curseur sur la première ligne. L'instruction OPEN est
incluse dans la section exécutable du bloc PL/SQL.
OPEN est une instruction exécutable qui effectue les opérations suivantes :
1. Elle alloue de manière dynamique de la mémoire pour une zone de
contexte.
2. Elle analyse (parse) l'instruction SELECT.
3. Elle attache les variables d'entrée (en d'autres termes, elle fixe la
valeur des variables d'entrée en obtenant leurs adresses mémoire).
4. Elle identifie l'ensemble actif (c'est-à-dire l'ensemble des lignes qui
satisfont aux critères de recherche). Les lignes de l'ensemble actif ne sont pas
extraites dans des variables lorsque l'instruction OPEN est exécutée. C'est
l'instruction FETCH qui extrait les lignes du curseur dans les variables.
5. Elle positionne le pointeur sur la première ligne de l'ensemble actif.

Remarque : Si une interrogation ne renvoie aucune ligne lorsque le curseur est

ouvert, le code PL/SQL ne déclenche pas d'exception. Vous pouvez connaître le
nombre de lignes renvoyées par un curseur explicite en utilisant l'attribut
<cursor_name>%ROWCOUNT.

Base de Données Avancées 2CS-SIT 2 - 19

L'instruction FETCH extrait les lignes du curseur une par une. Après chaque
extraction, le curseur se positionne sur la ligne suivante de l'ensemble actif. Vous
pouvez utiliser l'attribut %NOTFOUND pour déterminer si l'ensemble actif a été
extrait en totalité.
Examinez l'exemple de la diapositive ci-dessus. Deux variables, à savoir empno et
lname, sont déclarées pour le stockage des valeurs extraites du curseur. Considérez
l'instruction FETCH.
Vous avez extrait avec succès les valeurs du curseur dans les variables. Cependant,
une seule ligne a été extraite, alors que le département 30 compte six employés.
Pour extraire toutes les lignes, vous devez utiliser des boucles. La diapositive qui suit
montre comment utiliser une boucle pour extraire toutes les lignes.
L'instruction FETCH effectue les opérations suivantes :
1. Elle lit les données de la ligne en cours et les stocke dans les variables
de sortie PL/SQL.
2. Elle fait passer le pointeur à la ligne suivante de l'ensemble actif.

Base de Données Avancées 2CS-SIT 2 - 20

Notez qu'une boucle LOOP simple est utilisée pour extraire (fetch) toutes les lignes.
En outre, l'attribut de curseur %NOTFOUND permet de tester la condition de sortie.
La sortie générée par l'exécution du bloc PL/SQL se présente comme suit :

Base de Données Avancées 2CS-SIT 2 - 21

L'instruction CLOSE désactive le curseur, libère la zone de contexte et annule la
définition de l'ensemble actif. Fermez le curseur après avoir terminé le traitement de
l'instruction FETCH. Vous pouvez rouvrir le curseur si nécessaire. Un curseur ne peut
être rouvert que s'il est fermé. Si vous essayez d'extraire des données d'un curseur
qui est fermé, une exception INVALID_CURSOR est générée.

Remarque : Bien qu'il soit possible de terminer le bloc PL/SQL sans fermer les
curseurs, prenez l'habitude de fermer les curseurs que vous déclarez explicitement,
afin de libérer les ressources.
Il existe une limite maximale quant au nombre de curseurs ouverts par session. Cette
limite est déterminée par le paramètre OPEN_CURSORS dans le fichier de
paramètres de la base de données. (OPEN_CURSORS = 50 par défaut.)

Base de Données Avancées 2CS-SIT 2 - 22

Dans le cadre de l’effort de standardisation des instructions du langage SQL, plusieurs
versions standards ont été publié et qui deviennent des références pour les éditeurs
de SGBD. L’objectif de ces standards étant de faire évoluer le langage et uniformiser
les concepts manipulés. Un des objectifs des dernières versions publiés était de
supporter les instructions qui donne toute la puissance d’un langage de
programmation. La partie du standard SQL qui traite de ces instructions est appelée
Persistent StorageModule (PSM).
SQL:1999 supporte les instructions while et repeat selon la syntaxe suivante:
while boolean expression do
sequence of statements;
end while

repeat
sequence of statements;
until boolean expression
end repeat

Base de Données Avancées 2CS-SIT 2 - 23

Il existe aussi une boucle for qui permet le parcours de tous les résultats d’une
requête comme dans l’exemple suivant:
declare n integer default 0;
for r as
select budget from department
where dept name = ‘Finance‘
do
set n = n− [Link]
end for

Le programme extrait les résultats de la requête une ligne à la fois à l’intérieur de la

variable de la boucle for (r, dans l’exemple).
L’instruction leave peut être utilisée pour quitter la boucle, alors que iterate
commence au prochain tuple, à partir du début de la boucle, en ignorant les
instructions restantes.

SQL supporte aussi les instructions conditionnelles comme le if-then-else selon la

syntaxe:

if boolean expression
then statement or compound statement
elseif boolean expression
then statement or compound statement
else statement or compound statement
end if

Base de Données Avancées 2CS-SIT 2 - 24

On peut modifier le flux logique des instructions dans un bloc PL/SQL grâce à un
certain nombre de structures de contrôle. On s’intéresse dans ce qui suit à deux
types de structure de contrôle PL/SQL : les structures conditionnelles avec
l'instruction IF et les structures de contrôle LOOP.

Base de Données Avancées 2CS-SIT 2 - 25

La structure de l'instruction PL/SQL IF est semblable à celle des instructions IF des
autres langages procéduraux. Elle permet au langage PL/SQL d'exécuter des actions
dépendant de conditions spécifiques.

Dans la syntaxe :

condition est une variable ou une expression booléenne qui renvoie TRUE,
FALSE ou NULL.
THEN introduit une clause qui associe l'expression booléenne à la
séquence d'instructions qui suit.
statements représente une ou plusieurs instructions PL/SQL ou SQL. Ces
dernières peuvent inclure d'autres instructions IF comprenant elles-
mêmes plusieurs instructions IF, ELSE et ELSIF imbriquées. Les
instructions de la clause THEN ne sont exécutées que si la condition
de la clause IF associée prend la valeur TRUE.

Base de Données Avancées 2CS-SIT 2 - 26

ELSIF est un mot-clé qui introduit une expression booléenne (si la première
condition donne FALSE ou NULL, le mot-clé ELSIF introduit des
conditions supplémentaires).

ELSE clause par défaut, qui est exécutée si et seulement si aucun des prédicats
précédents (introduits par IF et ELSIF) n'a la valeur TRUE. Les tests sont
exécutés dans l'ordre. Ainsi, un prédicat pouvant être vrai n'est pas pris en
compte si un prédicat antérieur est vrai.
END IF marque la fin d'une instruction IF.

Base de Données Avancées 2CS-SIT 2 - 27

Le langage PL/SQL offre plusieurs solutions pour programmer des boucles en vue de
répéter plusieurs fois une instruction ou une séquence d'instructions. Les boucles
sont essentiellement utilisées pour exécuter des instructions de manière répétée,
jusqu'à ce qu'une condition de sortie de boucle soit satisfaite. Il est obligatoire
d'inclure une condition de sortie dans une boucle pour qu'elle ne s'exécute pas sans
fin.
Les structures en boucle constituent le troisième type de structure de contrôle. Le
langage PL/SQL fournit les types de boucle suivants :
• Boucles de base, qui permettent de répéter des actions sans conditions
globales.
• Boucles FOR, qui permettent d'effectuer un contrôle d'itération des actions
à l'aide d'un compteur.
• Boucles WHILE, qui permettent d'effectuer un contrôle d'itération des
actions, à l'aide d'une condition.

Remarque : Une instruction EXIT peut être utilisée pour mettre fin aux boucles. Une
boucle de base doit comporter une instruction EXIT.

Base de Données Avancées 2CS-SIT 2 - 28

La forme de boucle la plus simple est la boucle LOOP de base, qui contient une
séquence d'instructions délimitée par les mots-clés LOOP et END LOOP. Chaque fois
que l'exécution du code atteint le mot-clé END LOOP, le programme reprend le
contrôle à partir de l'instruction LOOP correspondante. Une boucle de base exécute
au moins une fois les instructions qui lui sont associées, même si la condition EXIT
est remplie avant l'entrée dans la boucle. En l'absence d'instruction EXIT, la boucle
s'exécuterait sans fin.
Instruction EXIT
Vous pouvez mettre fin à une boucle en utilisant l'instruction EXIT. L'exécution
reprend alors à l'instruction qui suit END LOOP. Vous pouvez utiliser EXIT en tant
qu'action dans une instruction IF ou en tant qu'instruction autonome au sein de la
boucle. L'instruction EXIT doit être placée à l'intérieur de la boucle. Dans le second
mode d'utilisation, vous pouvez ajouter une clause WHEN pour définir une sortie de
boucle conditionnelle. Lorsque l'exécution rencontre l'instruction EXIT, elle évalue la
condition de la clause WHEN. Si la condition renvoie TRUE, la boucle se termine et
l'exécution du programme passe à la première instruction qui suit.
Une boucle de base peut contenir plusieurs instructions EXIT, mais il est
recommandé d'utiliser un seul point EXIT.

Base de Données Avancées 2CS-SIT 2 - 29

Vous pouvez utiliser une boucle WHILE pour répéter une séquence d'instructions
jusqu'à ce que la condition de contrôle ne soit plus évaluée comme TRUE. La
condition est évaluée au début de chaque itération. La boucle se termine lorsque la
condition renvoie FALSE ou NULL. Si la condition est évaluée comme FALSE ou
NULL dès le début de la boucle, aucune itération n'est effectuée. Il est donc possible
qu'aucune instruction de la boucle ne soit exécutée.

Dans la syntaxe :
condition est une variable ou une expression booléenne (TRUE,
FALSE ou NULL).
statement représente une ou plusieurs instructions PL/SQL ou SQL.

Si les variables impliquées dans les conditions ne changent pas au cours de la boucle,
la condition est toujours vérifiée (TRUE) et la boucle ne s'arrête jamais.

Base de Données Avancées 2CS-SIT 2 - 30

Les boucles FOR présentent la même structure globale que les boucles de base.
Elles possèdent en plus, avant le mot-clé LOOP, une instruction de contrôle qui
détermine le nombre d'itérations à effectuer par le compilateur PL/SQL.

counter est un entier déclaré implicitement, dont la valeur décroît ou augmente

automatiquement de 1 à chaque itération de la boucle jusqu'à ce que la
limite supérieure ou inférieure soit atteinte

REVERSE entraîne la décrémentation du compteur lors de chaque itération, jusqu'à

sa limite inférieure.
Remarque : La limite inférieure est toujours référencée en premier.
lower_bound indique la limite inférieure de la plage des valeurs du compteur.
upper_bound indique la limite supérieure de la plage des valeurs du compteur.

Ne déclarez pas le compteur. Il est déclaré implicitement en tant que nombre entier.

Base de Données Avancées 2CS-SIT 2 - 31

Base de Données Avancées 2CS-SIT 2 - 32
Il est possible d’utiliser une boucle FOR de curseur, laquelle traite les lignes dans un
curseur explicite. Il s'agit d'un raccourci car le curseur est ouvert et une ligne est
extraite une seule fois à chaque itération de la boucle. Celle-ci arrête son exécution
lorsque la dernière ligne est traitée et le curseur est fermé automatiquement. La
boucle s'arrête d'elle-même à la fin de l'itération qui extrait la dernière ligne.

record_name Nom de l'enregistrement déclaré implicitement.

Cursor_name Identificateur PL/SQL du curseur déclaré précédemment.

On peut aussi mettre la requête à la place du nom du curseur, et dans ce cas la boucle
FOR remplacera les quatre étapes de traitement des curseurs (déclaration, ouverture,
extraction et fermeture).

Base de Données Avancées 2CS-SIT 2 - 33

Le code ne présente aucune erreur de syntaxe, ce qui veut dire qu’on doit pouvoir
exécuter avec succès le bloc anonyme. L'instruction SELECT du bloc extrait le nom
de famille de John.
Lorsqu’on exécute ce code, on obtient toutefois le rapport d'erreur suivant :

Le code ne fonctionne pas comme prévu. L'instruction SELECT extrait plusieurs

lignes. Les erreurs de ce type qui se produisent lors de l'exécution sont appelées des
exceptions. Lorsqu'une exception se produit, l'exécution du bloc PL/SQL prend fin.
On peut traiter les exceptions dans le bloc PL/SQL.

Base de Données Avancées 2CS-SIT 2 - 34

Pour traiter les exceptions, on ajoute une section (facultative), appelée section de
traitement des exceptions.
Elle commence par le mot-clé EXCEPTION.
Lorsqu'elle existe, cette section doit être la dernière du bloc PL/SQL.

Exemple
Dans la diapositive ci-dessus, l'exemple de code de la page précédente a été modifié
pour gérer l'exception qui s'était produite. La sortie du code est également illustrée.
La section EXCEPTION qui a été ajoutée empêche le programme PL/SQL de se
terminer brutalement. Lorsque l'exception est générée, le contrôle passe à la section
de traitement des exceptions et toutes les instructions de cette section sont
exécutées. L'exécution du bloc PL/SQL se termine normalement.

Base de Données Avancées 2CS-SIT 2 - 35

Une exception est une erreur PL/SQL qui est générée pendant l'exécution d'un bloc.
L'exécution d'un bloc s'arrête toujours quand une exception PL/SQL est déclenchée.
Cependant, on peut définir un gestionnaire d'exceptions afin de réaliser certaines
opérations avant la fin du bloc.
Méthodes de déclenchement d'une exception
Lorsqu'une erreur Oracle se produit, l'exception associée est déclenchée
automatiquement. Par exemple, si l'erreur ORA-01403 survient parce que
l'instruction SELECT n'a extrait aucune ligne de la base de données, PL/SQL
génère l'exception NO_DATA_FOUND. Ces erreurs sont converties en
exceptions prédéfinies.
En fonction des fonctionnalités métier implémentées par le programme, vous
pouvez être amené à générer explicitement une exception. Pour cela, vous
insérez une instruction RAISE dans le bloc. L'exception émise peut être
définie par l'utilisateur ou prédéfinie. Il existe également des erreurs Oracle
non prédéfinies. Il s'agit d'erreurs Oracle standard. Vous pouvez déclarer
explicitement des exceptions et les associer aux erreurs Oracle non
prédéfinies.

Base de Données Avancées 2CS-SIT 2 - 36

Intercepter une exception
Insérez une section EXCEPTION dans votre programme PL/SQL afin d'intercepter les
exceptions. Si l'exception est générée dans la section exécutable du bloc, le
traitement est dirigé vers le gestionnaire d'exceptions correspondant dans la section
de traitement des exceptions du bloc. Si le programme PL/SQL traite convenablement
l'exception, celle-ci n'est pas propagée au bloc englobant ou à l'environnement
appelant. L'exécution du bloc PL/SQL se termine correctement.

Propager une exception

Si l'exception est générée dans la section exécutable du bloc et qu'il n'existe aucun
gestionnaire d'exceptions correspondant, l'exécution du bloc PL/SQL s'interrompt
avec une erreur et l'exception est propagée au bloc englobant ou à l'environnement
appelant. L'environnement appelant peut être n'importe quelle application (telle que
SQL*Plus qui appelle le programme PL/SQL).

Base de Données Avancées 2CS-SIT 2 - 37

Exception Description Gestion
Erreur prédéfinie du L'une des vingt erreurs les Il n'est pas nécessaire de déclarer ces
serveur Oracle plus fréquentes en langage exceptions. Elles sont prédéfinies par le
PL/SQL serveur Oracle et sont générées
implicitement.
Erreur non prédéfinie Toute autre erreur standard Vous devez déclarer ces exceptions
du serveur Oracle du serveur Oracle dans la section déclarative. Le serveur
Oracle déclenche l'erreur implicitement
et vous pouvez intercepter l'erreur dans
le gestionnaire d'exceptions.
Erreur définie par Condition considérée Déclarez ces exceptions dans la section
l'utilisateur comme anormale par le déclarative et déclenchez-les
développeur explicitement.

Base de Données Avancées 2CS-SIT 2 - 38

Vous pouvez intercepter n'importe quelle erreur en insérant le gestionnaire
correspondant dans la section de traitement des exceptions du bloc PL/SQL. Chaque
gestionnaire d'exceptions contient une clause WHEN, qui indique le nom de
l'exception, suivie d'une séquence d'instructions à exécuter lorsque cette exception
est déclenchée.

Vous pouvez inclure un nombre quelconque de gestionnaires dans une section

EXCEPTION pour gérer des exceptions spécifiques. En revanche, il n'est pas possible
de définir plusieurs gestionnaires pour une même exception.
La syntaxe d'interception des exceptions comprend les éléments suivants :

exception Nom standard d'une exception prédéfinie ou d'une exception définie

par l'utilisateur dans la section déclarative.
statement Constitué d'une ou de plusieurs instructions PL/SQL ou SQL.
OTHERS Clause facultative de traitement des exceptions qui intercepte toute
exception n'ayant pas été traitée explicitement.

Base de Données Avancées 2CS-SIT 2 - 39

Gestionnaire d'exceptions WHEN OTHERS
Comme indiqué précédemment, la section de traitement des exceptions intercepte uniquement
les exceptions qui sont définies.
Pour intercepter des exceptions qui ne sont pas définies, vous utilisez le gestionnaire
d'exceptions OTHERS. Ce dernier permet d'intercepter les exceptions qui n'ont pas encore été
traitées. S'il est utilisé, OTHERS doit être le dernier gestionnaire d'exceptions défini.
Par exemple :
WHEN NO_DATA_FOUND THEN
statement1;
...
WHEN TOO_MANY_ROWS THEN
statement1;
...
WHEN OTHERS THEN
statement1;
Exemple
Examinons l'exemple précédent. Si l'exception NO_DATA_FOUND est générée par le
programme, les instructions du gestionnaire correspondant sont exécutées. Si l'exception
TOO_MANY_ROWS est générée, les instructions du gestionnaire correspondant sont exécutées.
Si d'autres exceptions sont générées, les instructions du gestionnaire d'exceptions OTHERS
sont exécutées.
Le gestionnaire OTHERS intercepte toutes les exceptions qui n'ont pas encore été traitées.

Base de Données Avancées 2CS-SIT 2 - 40

Les procédures et fonctions permettent à la logique métier d’être stockée dans la
base de données, et exécutée à partir de commandes SQL. Cette intégration à la base
présente plusieurs avantages comme le fait que ça donnera la possibilité à plusieurs
applications d’accéder à ces procédures tout en ayant un seul point de changement
dans le cas où des modifications à des règles métier deviennent nécessaires.

Base de Données Avancées 2CS-SIT 2 - 41

Les procédures et les fonctions offrent de nombreux avantages liés à la
modularisation du code :
La maintenance est simplifiée, car tous les sous-programmes résident dans un
même emplacement. Les modifications doivent être effectuées dans un seul
emplacement pour affecter différentes applications et limiter les tests.

La sécurité des données peut être renforcée, via le contrôle de l'accès indirect
aux objets de base de données par des utilisateurs n'ayant pas de privilèges,
et ce grâce à des privilèges de sécurité. Les sous-programmes exécutés
utilisent par défaut les droits du créateur. Le privilège d'exécution n'autorise
pas l'utilisateur appelant à accéder directement aux objets accessibles par le
sous-programme.

Afin de garantir l'intégrité des données, les actions liées sont exécutées
toutes ensembles ou ne sont pas exécutées du tout.

Base de Données Avancées 2CS-SIT 2 - 42

 Les performances peuvent être améliorées, grâce à la réutilisation du code
analysé (parse), disponible dans la zone SQL partagée du serveur. Lors des appels
suivants du sous-programme, cela évite d'avoir à analyser de nouveau le code.
Etant donné que le code est analysé lors de la compilation, la surcharge liée à
l'analyse des instructions SQL est évitée lors de l'exécution.

La clarté du code peut être améliorée, grâce à l'utilisation de noms et de

conventions appropriés pour la description de l'action des sous-programmes, ce
qui permet de limiter les commentaires et ainsi d'améliorer la lisibilité du code.

Base de Données Avancées 2CS-SIT 2 - 43

Les procédures et les fonctions, également appelées sous-programmes, sont des
blocs PL/SQL nommés. Les sous-programmes sont compilés et stockés dans la base
de données. La structure de bloc des sous-programmes est semblable à la structure
des blocs anonymes. Un sous-programme contient les sections suivantes :
Section déclarative : Les sous-programmes peuvent comporter une section
déclarative facultative. En revanche, cette section ne commence pas par le
mot-clé DECLARE, contrairement à celle des blocs anonymes. La section
déclarative facultative suit le mot clé IS ou AS dans la déclaration du sous-
programme.

Section exécutable : Il s'agit d'une section obligatoire du sous-programme, qui

contient l'implémentation de la logique métier. L'examen de son code permet
de déterminer facilement les fonctionnalités métier du sous-programme.
Cette section commence et se termine respectivement par les mots-clés
BEGIN et END.

Section de traitement des exceptions : Cette section facultative sert à traiter

les exceptions.

Base de Données Avancées 2CS-SIT 2 - 44

Les blocs anonymes ne sont pas des objets de base de données persistants. Ils sont
compilés chaque fois qu'ils doivent être exécutés. Ils ne sont pas stockés dans la base
de données en vue de leur réutilisation. Si vous souhaitez les réutiliser, vous devez
réexécuter le script qui crée le bloc anonyme, ce qui entraîne la recompilation et
l'exécution.
Les procédures et les fonctions sont compilées et sont stockées dans la base de
données sous forme compilée. Elles ne sont recompilées que suite à une
modification. Etant donné que ces sous-programmes sont stockés dans la base, toute
application peut les utiliser dès lors qu'elle dispose des droits appropriés.
L'application appelante peut transmettre des paramètres à une procédure si celle-ci
est conçue pour accepter des paramètres. De la même façon, une application
appelante peut extraire une valeur si elle appelle une fonction ou une procédure.

Base de Données Avancées 2CS-SIT 2 - 45

Une procédure est un bloc PL/SQL nommé qui peut accepter des paramètres (parfois
appelés arguments). En général, on utilise une procédure pour exécuter une action.
Une procédure est appelée en utilisant son nom dans la section d'exécution d'un
autre bloc PL/SQL.

Base de Données Avancées 2CS-SIT 2 - 46

Les procédures sont créées via l'instruction CREATE PROCEDURE. Cette dernière
permet de déclarer une liste de paramètres et doit définir les actions à exécuter par
le bloc PL/SQL standard.
L'option REPLACE indique que, si la procédure existe, elle sera supprimée et
remplacée par la nouvelle version créée par l'instruction.
Autres éléments syntaxiques
parameter1 représente le nom d'un paramètre. Les paramètres peuvent être
considérés comme des variables locales.
L'option mode définit la façon dont un paramètre est utilisé : IN (par défaut),
OUT ou IN OUT.
datatype1 définit le type de données du paramètre, sans aucune taille.

Base de Données Avancées 2CS-SIT 2 - 47

Dans l'exemple de code ci-dessus, la procédure add_dept insère un nouveau
département dont le numéro est 280 et le nom ST-Curriculum.

Cet exemple illustre également les points suivants :

• La section déclarative d'une procédure débute immédiatement après la
déclaration de celle-ci et ne commence pas par le mot-clé DECLARE.
• La procédure déclare deux variables : dept_id et dept_name.
• La procédure utilise l'attribut de curseur implicite ou l'attribut SQL
SQL%ROWCOUNT pour vérifier que la ligne a bien été insérée.

Base de Données Avancées 2CS-SIT 2 - 48

Lorsque vous créez un objet, les informations que vous entrez sont ajoutées à la table
user_objects. Lorsque le code de la diapositive précédente s'exécute avec succès,
vous pouvez vérifier que les nouveaux objets ont été insérés en interrogeant la table
user_objects à l'aide de la commande suivante :

SELECT object_name,object_type FROM user_objects;

Le code source de la procédure est stocké dans la table user_source. Vous pouvez
examiner le code source en exécutant la commande suivante :

SELECT * FROM user_source WHERE name='ADD_DEPT';

Base de Données Avancées 2CS-SIT 2 - 49

La diapositive ci-dessus montre comment appeler une procédure à partir d'un bloc
anonyme. Vous devez inclure l'appel de la procédure dans la section exécutable du
bloc anonyme. Vous pouvez également appeler une procédure à partir d'une
application. L'instruction SELECT du code vérifie si la ligne a bien été insérée.

Il est aussi possible d'appeler une procédure à l'aide de l'instruction SQL CALL
<procedure_name>.

Base de Données Avancées 2CS-SIT 2 - 50

Lorsque vous développez des procédures appelées à partir d'autres procédures, vous
devez être conscient de l'effet des exceptions traitées et non traitées sur la
transaction et la procédure appelante.
Lorsqu'une exception est déclenchée dans une procédure appelée, la section de
traitement des exceptions du bloc prend immédiatement le contrôle. Une exception
est considérée comme traitée si la section de traitement des exceptions fournit un
gestionnaire pour l'exception générée.
Lorsqu'une exception se produit et est traitée, le flux d'exécution du code est le
suivant :
1. L'exception est générée.
2. Le contrôle est transféré au gestionnaire d'exceptions.
3. L'exécution du bloc se termine.
4. Le programme/bloc appelant continue de s'exécuter comme si rien ne
s'était passé.

Base de Données Avancées 2CS-SIT 2 - 51

Les deux procédures de l'exemple sont les suivantes :
• La procédure add_department crée un nouvel enregistrement de
département en allouant un nouveau numéro de département à partir
d'une séquence, puis elle définit les valeurs des colonnes
department_name, manager_id et location_id, respectivement
à l'aide des paramètres name, mgr et loc.
• La procédure create_departments crée plusieurs départements à
l'aide d'appels de la procédure add_department.

La procédure add_department détecte toutes les exceptions générées dans son

propre gestionnaire. Lorsque la procédure create_departments est exécutée, la
sortie suivante est générée :
Added Dept: Media
Err: Adding Dept: Editing
Added Dept: Advertising

Base de Données Avancées 2CS-SIT 2 - 52

Lorsqu'une exception est déclenchée dans une procédure appelée, la section de
traitement des exceptions du bloc prend immédiatement le contrôle. Si la section de
traitement des exceptions ne fournit pas de gestionnaire pour l'exception générée,
celle-ci n'est pas traitée. Le flux d'exécution du code est le suivant :
1. L'exception est générée.
2. L'exécution du bloc prend fin, car il n'existe aucun gestionnaire
d'exceptions ; toute opération LMD effectuée dans la procédure est annulée.
3. L'exception est propagée vers la section de traitement des exceptions
de la procédure appelante. Autrement dit, le contrôle est renvoyé à la section
de traitement des exceptions du bloc appelant, si celle-ci existe.

Si une exception n'est pas traitée, toutes les instructions LMD de la procédure
appelante et de la procédure appelée sont annulées, ainsi que toutes les
modifications apportées aux variables hôte. Les instructions LMD qui ne sont pas
affectées sont les instructions qui ont été exécutées avant l'appel du code PL/SQL
dont les exceptions ne sont pas traitées.

Base de Données Avancées 2CS-SIT 2 - 53

L'exemple de code de la diapositive ci-dessus illustre la procédure
add_department_noex, qui ne comporte pas de section de traitement des
exceptions. Dans ce cas, l'exception se produit lors de l'ajout du département
Editing. Etant donné l'absence de traitement des exceptions dans les différents
sous-programmes, aucun nouvel enregistrement de département n'est ajouté à la
table DEPARTMENTS. L'exécution de la procédure create_departments_noex
donne un résultat semblable au suivant :
Added Dept: Media
BEGIN create_departments_noex; END;

*
ERROR at line 1:
ORA-02291: integrity constraint (ORA1.DEPT_MGR_FK)
violated - parent key not
found
ORA-06512: at "ORA1.ADD_DEPARTMENT_NOEX", line 4
ORA-06512: at "ORA1.CREATE_DEPARTMENTS_NOEX", line 4
ORA-06512: at line 1

Base de Données Avancées 2CS-SIT 2 - 54

Une fonction est un bloc PL/SQL nommé qui peut accepter des paramètres, être
appelée et renvoyer une valeur. En règle générale, on utilise une fonction pour
calculer une valeur.
Les fonctions et les procédures présentent la même structure. Une fonction doit
renvoyer une valeur à l'environnement appelant, tandis qu'une procédure peut
renvoyer ou non des valeurs à son environnement appelant.
Une fonction doit comporter une clause RETURN dans l'en-tête, et au moins une
instruction RETURN dans la section exécutable.

Base de Données Avancées 2CS-SIT 2 - 55

Les instructions SQL peuvent référencer des fonctions PL/SQL définies par l'utilisateur
partout où une expression SQL est autorisée. Par exemple, une fonction définie par
l'utilisateur peut être utilisée partout où une fonction SQL intégrée, telle que
UPPER(), peut être utilisée.
Avantages
• Elles autorisent des calculs qui seraient trop complexes, malaisés, voire
impossibles en langage SQL.
• Elles renforcent l'indépendance des données en traitant les analyses de
données complexes sur le serveur Oracle, plutôt que d'extraire les données
vers une application.
• Elles améliorent l'efficacité des interrogations, puisque les fonctions sont
traitées dans ces dernières, plutôt que dans l'application.

Base de Données Avancées 2CS-SIT 2 - 56

Vous pouvez créer des fonctions via l'instruction CREATE FUNCTION. Cette
dernière permet de déclarer une liste de paramètres ; en outre, elle doit renvoyer
une valeur et définir les actions qui seront exécutées par le bloc PL/SQL standard.

Base de Données Avancées 2CS-SIT 2 - 57

La fonction check_sal permet de déterminer si le salaire d'un employé est
supérieur ou inférieur au salaire moyen de tous les employés travaillant dans le
même département.
La fonction renvoie TRUE si le salaire de l'employé est supérieur au salaire moyen du
département ; dans le cas contraire, elle renvoie FALSE. Elle renvoie NULL si une
exception NO_DATA_FOUND est générée.

Notez que la fonction effectue la vérification pour l'employé dont l'ID est 205. La
vérification est codée en dur pour cet ID uniquement. Si vous souhaitez l'appliquer
aux autres employés, vous devez modifier la fonction. Pour résoudre ce problème,
déclarez la fonction de telle sorte qu'elle accepte un argument. Vous pourrez ainsi lui
transmettre l'ID d'employé en tant que paramètre.

Base de Données Avancées 2CS-SIT 2 - 58

Placez l'appel de la fonction dans la section exécutable du bloc anonyme.
La fonction est appelée dans le cadre d'une instruction. La fonction check_sal
renvoie un type Boolean ou NULL. L'appel de la fonction est donc inclus comme
expression conditionnelle pour le bloc IF.

Base de Données Avancées 2CS-SIT 2 - 59

La fonction considérée dans les diapositives précédentes était codée en dur. Elle
permettait seulement de vérifier le salaire de l'employé possédant l'ID 205. Dans la
diapositive ci-dessus, le code de la fonction a été réécrit de manière à supprimer
cette contrainte. La fonction admet maintenant le numéro de l'employé comme
paramètre. On peut lui transmettre différents matricules afin de vérifier le salaire des
employés correspondants.
Le résultat du code illustré par la diapositive ci-dessus présente l'aspect suivant :

Base de Données Avancées 2CS-SIT 2 - 60

Le code de la diapositive ci-dessus appelle la fonction deux fois en transmettant des
paramètres. La sortie présente l'aspect suivant :

Base de Données Avancées 2CS-SIT 2 - 61

Remarque : Il est préférable de remplacer une procédure contenant un paramètre
OUT unique par une fonction qui renvoie la valeur.

Base de Données Avancées 2CS-SIT 2 - 62

Modèle des droits du créateur
Avant la version Oracle8i, tous les programmes s'exécutaient avec les privilèges de
l'utilisateur ayant créé le sous-programme. On parle du modèle des droits du
créateur, lequel :
• accorde à l'appelant du programme le privilège d'exécuter la procédure,
mais aucun privilège sur les objets sous-jacents auxquels la procédure
accède ;
• nécessite que le propriétaire possède tous les privilèges objet nécessaires
pour les objets auxquels la procédure fait référence.

Modèle des droits de l'appelant

Dans le modèle des droits de l'appelant, introduit dans Oracle8i, les programmes sont
exécutés avec les privilèges de l'utilisateur appelant. Un utilisateur d'une procédure
qui s'exécute avec les droits de l'appelant nécessite des privilèges sur les objets sous-
jacents auxquels la procédure fait référence.

Base de Données Avancées 2CS-SIT 2 - 63

La syntaxe suivante permet de définir les droits de l'appelant pour différentes
structures de sous-programme PL/SQL :
CREATE FUNCTION name RETURN type AUTHID CURRENT_USER IS...
CREATE PROCEDURE name AUTHID CURRENT_USER IS…

Dans ces instructions, affectez à AUTHID la valeur DEFINER, ou ne l'utilisez pas

pour le comportement par défaut.

Base de Données Avancées 2CS-SIT 2 - 64

Un déclencheur (trigger) est un objet codé que le système exécute automatiquement
comme un effet de bord, suite à une modification de la base de données. Pour
concevoir un mécanisme déclencheur, on doit spécifier:
1. Quand le trigger doit être exécuté. Ceci est exprimé par l’évènement qui cause le
déclenchement du code ainsi que la condition qui doit être satisfaite pour que
l’exécution du trigger ait lieu.
2. Les actions qui doivent être effectuée à l’exécution du trigger.

Une fois le trigger créé dans la base de données, le SGBD prend la responsabilité de
l’exécuter à chaque occurrence de l’évènement associé et à la satisfaction de la
condition indiquée.

Base de Données Avancées 2CS-SIT 2 - 65

Les déclencheurs de base de données s'exécutent implicitement lorsque l'un des
événements suivants se produit :
• opérations LMD sur une table,
• opérations LMD sur une vue, avec un déclencheur INSTEAD OF,
• instructions LDD, telles que CREATE et ALTER.

Les déclencheurs s'exécutent quel que soit l'utilisateur connecté ou quelle que soit
l'application utilisée. Ils s'exécutent également de manière implicite lorsque certaines
actions utilisateur ou système se produisent (par exemple la connexion d'un
utilisateur ou la fermeture de la base de données par l'administrateur).

Base de Données Avancées 2CS-SIT 2 - 66

Utilisez des déclencheurs pour garantir l'exécution d'actions liées pour une opération
spécifique.
Utilisez les déclencheurs de base de données pour les opérations globales et
centralisées qui doivent être exécutées pour l'instruction de déclenchement, quel que
soit l'utilisateur ou l'application à l'origine de l'instruction.

Ne définissez pas de déclencheurs pour dupliquer ou remplacer une fonctionnalité

déjà intégrée à la base de données. Par exemple, implémentez les règles d'intégrité à
l'aide de contraintes déclaratives et non de déclencheurs.

Base de Données Avancées 2CS-SIT 2 - 67

trigger_name identifie le déclencheur de manière unique.
timing indique à quel moment le déclencheur s'exécute par rapport à l'événement
déclencheur. Les valeurs sont BEFORE, AFTER ou INSTEAD OF.
event identifie l'opération LMD qui provoque l'exécution du déclencheur.
Les valeurs sont INSERT, UPDATE [OF column] et DELETE.
object_name indique la table ou la vue associée au déclencheur.

Pour les déclencheurs sur ligne, vous pouvez indiquer :

• une clause REFERENCING afin de choisir des noms de corrélation pour
référencer les anciennes et nouvelles valeurs de la ligne en cours
(les valeurs par défaut sont OLD et NEW),
• FOR EACH ROW pour indiquer que le déclencheur est un déclencheur sur
ligne,
• une clause WHEN pour appliquer un prédicat conditionnel (entre
parenthèses) qui est évalué pour chaque ligne afin de déterminer si le
corps du déclencheur doit ou non être exécuté.
Le corps trigger_body est l'action exécutée par le déclencheur, qui peut être
implémentée de deux façons différentes :
• un bloc anonyme avec un mot-clé DECLARE ou BEGIN et un mot-clé END,
• une clause CALL afin d'appeler une procédure, telle que :
CALL my_procedure;

Base de Données Avancées 2CS-SIT 2 - 68

Déclencheur sur instruction
Un déclencheur sur instruction s'exécute une fois pour le compte de l'événement
déclencheur, même si aucune ligne n'est affectée. Ce type de déclencheur s'avère
particulièrement utile si l'action ne dépend pas des données des lignes concernées
ou des données fournies par l'événement déclencheur. C'est le cas par exemple d'un
déclencheur qui exécute un contrôle de sécurité complexe sur l'utilisateur en cours.

Déclencheur sur ligne

Un déclencheur sur ligne s'exécute chaque fois qu’une ligne est affectée par
l'événement déclencheur. Si l'événement déclencheur n'affecte aucune ligne, le
déclencheur n'est pas exécuté. Ce type de déclencheur s'avère particulièrement utile
si l'action dépend des données des lignes concernées ou des données fournies par
l'événement déclencheur.

Base de Données Avancées 2CS-SIT 2 - 69

Le déclencheur BEFORE est fréquemment utilisé dans les cas suivants :
• Pour déterminer si l'instruction de déclenchement doit être autorisée (cela
permet d'éliminer tout traitement inutile et permet l'annulation (rollback)
si une exception est générée dans l'action de déclenchement)
• Pour obtenir des valeurs de colonne avant d'exécuter une instruction
INSERT ou UPDATE
• Pour valider des règles complexes

Les déclencheurs AFTER sont fréquemment utilisés dans les cas suivants :
• Pour effectuer différentes actions à partir de la même instruction de
déclenchement
• Pour garder trace des opérations effectuées sur la base de données (audit)

Les déclencheurs INSTEAD OF offrent un moyen transparent de modifier les vues

qui ne peuvent pas être modifiées directement par l'intermédiaire d'instructions LMD
SQL parce qu'une vue n'est pas toujours modifiable. Vous pouvez écrire les
instructions LMD appropriées dans le corps d'un déclencheur INSTEAD OF afin
d'exécuter des actions directement sur les tables sous-jacentes des vues.

Base de Données Avancées 2CS-SIT 2 - 70

Si l'instruction LMD à l'origine du déclenchement concerne une seule ligne, les
déclencheurs sur instruction et sur ligne sont tous deux exécutés.

Exemple
L'instruction SQL de la diapositive ci-dessus ne différencie pas les déclencheurs sur
instruction des déclencheurs sur ligne, car exactement une ligne est insérée dans la
table à l'aide de la syntaxe de l'instruction INSERT illustrée.

Base de Données Avancées 2CS-SIT 2 - 71

Si l'instruction LMD à l'origine du déclenchement concerne plusieurs lignes, le
déclencheur sur instruction s'exécute à une seule reprise, tandis que le déclencheur
sur ligne s'exécute une fois pour chaque ligne affectée.

Exemple
Dans l'instruction SQL de la diapositive ci-dessus, le nombre d'exécutions du
déclencheur au niveau ligne correspond au nombre de lignes satisfaisant à la clause
WHERE (à savoir le nombre d'employés membres du département 30).

Base de Données Avancées 2CS-SIT 2 - 72

L'événement déclencheur ou l'instruction de déclenchement peut être une
instruction INSERT, UPDATE ou DELETE exécutée sur une table.

Lorsque l'événement déclencheur est une instruction UPDATE, vous pouvez indiquer
une liste de colonnes afin d'identifier les colonnes dont la modification provoquera
l'exécution du déclencheur.
. . . UPDATE OF salary . . .

L'événement déclencheur peut contenir une ou deux des opérations LMD ci-après, ou
les trois.
. . . INSERT or UPDATE or DELETE
. . . INSERT or UPDATE OF job_id . . .

Remarque : La taille d'un déclencheur est limitée à 32 Ko.

Base de Données Avancées 2CS-SIT 2 - 73

Dans l'exemple de la diapositive ci-dessus, le déclencheur de base de données
SECURE_EMP est un déclencheur sur instruction de type BEFORE qui empêche
l'opération INSERT si la condition n'est pas satisfaite. Dans ce cas, le déclencheur
limite les insertions à la table EMPLOYEES au cours de certaines heures de travail.

Si un utilisateur tente d'insérer une ligne dans la table EMPLOYEES hors des heures
de travail, un message d'erreur s'affiche, le déclencheur échoue et l'instruction de
déclenchement est annulée.
RAISE_APPLICATION_ERROR est une procédure intégrée côté serveur qui
renvoie une erreur à l'utilisateur et provoque l'échec du bloc PL/SQL.

En cas d'échec d'un déclencheur de base de données, le serveur Oracle annule

automatiquement l'instruction de déclenchement.

Base de Données Avancées 2CS-SIT 2 - 74

Tentez d'insérer une ligne dans la table EMPLOYEES en dehors des heures ouvrables.
Lorsque la date et l'heure ne correspondent pas aux horaires d'ouverture indiqués
dans le déclencheur, un message d'erreur semblable à celui présenté dans la
diapositive ci-dessus s'affiche.

Base de Données Avancées 2CS-SIT 2 - 75

Vous pouvez combiner plusieurs événements déclencheurs au sein d'un même
événement en utilisant les prédicats conditionnels spéciaux INSERTING,
UPDATING et DELETING dans le corps du déclencheur.

Base de Données Avancées 2CS-SIT 2 - 76

Vous pouvez créer un déclencheur sur ligne BEFORE afin d'empêcher
l'aboutissement d'une opération de déclenchement en cas de violation d'une
condition déterminée.

Dans l'exemple de la diapositive ci-dessus, un déclencheur est créé afin d'autoriser

certains employés à percevoir un salaire supérieur à 15 000. Supposons qu'un
utilisateur tente d'exécuter l'instruction UPDATE suivante :
UPDATE employees
SET salary = 15500
WHERE last_name = 'Russell';

Le déclencheur génère l'exception suivante :

UPDATE EMPLOYEES
*
ERROR at line 1:
ORA-20202: Employee cannot earn more than $15,000.
ORA-06512: at "PLSQL.RESTRICT_SALARY", line 5
ORA-04088: error during execution of trigger
"PLSQL.RESTRICT_SALARY"

Base de Données Avancées 2CS-SIT 2 - 77

Dans un déclencheur sur ligne, faites référence à la valeur d'une colonne avant et après la
modification des données, en la faisant précéder du qualificatif OLD ou NEW.
Opération sur les données Ancienne valeur Nouvelle valeur
INSERT NULL Valeur insérée
UPDATE Valeur avant mise à jour Valeur après mise à jour
DELETE Valeur avant suppression NULL
Remarques relatives à l'utilisation :
• Les qualificatifs OLD et NEW sont disponibles uniquement dans les déclencheurs
sur ligne.
• Ils doivent être précédés du signe deux-points (:) dans toutes les instructions SQL
et PL/SQL.
• N'utilisez pas le préfixe (:) quand les qualificatifs sont référencés dans la
condition de restriction WHEN.
Remarque : Les déclencheurs sur ligne peuvent entraîner une dégradation des
performances si vous effectuez de nombreuses mises à jour sur des tables volumineuses.

Base de Données Avancées 2CS-SIT 2 - 78

Créez un déclencheur sur la table EMPLOYEES pour ajouter des lignes à la table
utilisateur AUDIT_EMP_TABLE et consigner ainsi les activités d'un utilisateur par
rapport à la table EMPLOYEES. Le déclencheur enregistre les valeurs de plusieurs
colonnes avant et après les modifications de données en utilisant les qualificatifs OLD
et NEW avec le nom de colonne approprié.

Base de Données Avancées 2CS-SIT 2 - 79

La clause WHEN permet de limiter l'action du déclencheur aux lignes qui satisfont à
une condition déterminée.
Vous pouvez créer un déclencheur sur la table EMPLOYEES pour calculer la
commission d'un employé lors de l'ajout d'une ligne à cette table ou lors de la
modification du salaire d'un employé.
Le qualificatif NEW ne peut pas être précédé d'un signe deux-points dans la clause
WHEN, car celle-ci se trouve en dehors des blocs PL/SQL.

Base de Données Avancées 2CS-SIT 2 - 80

Les déclencheurs INSTEAD OF vous permettent de modifier les données, lorsqu'une
instruction LMD est exécutée pour une vue qui, par nature, ne peut pas être mise à
jour.
On parle de déclencheurs INSTEAD OF, car contrairement aux autres déclencheurs,
le serveur Oracle les exécute à la place de l'instruction de déclenchement.
Ce type de déclencheur permet d'effectuer directement les opérations INSERT,
UPDATE ou DELETE sur les tables sous-jacentes. Vous pouvez écrire des
instructions INSERT, UPDATE ou DELETE par rapport à une vue et laisser le
déclencheur INSTEAD OF s'exécuter en arrière-plan pour réaliser les actions
appropriées.
Vous ne pouvez pas modifier une vue en utilisant les instructions LMD standard, si
l'interrogation de la vue contient des opérateurs ensemblistes, des fonctions de
groupe, des clauses telles que GROUP BY, l'opérateur DISTINCT ou des jointures.

Par exemple, si une vue comporte plusieurs tables, une opération d'insertion la
concernant peut entraîner une insertion dans une table et une mise à jour dans une
autre. Vous pouvez donc créer un déclencheur INSTEAD OF qui s'exécute lorsque
vous effectuez une insertion dans la vue. Dans ce cas, le corps du déclencheur
s'exécute à la place de l'insertion d'origine, ce qui se traduit par l'insertion de
données dans une table et la mise à jour de l'autre.

Base de Données Avancées 2CS-SIT 2 - 81

L'exemple de la diapositive ci-dessus illustre l'insertion d'un employé dans la vue
EMP_DETAILS, dont l'interrogation est basée sur les tables EMPLOYEES et
DEPARTMENTS. Le déclencheur NEW_EMP_DEPT (INSTEAD OF) s'exécute à la
place de l'opération INSERT qui entraîne l'exécution du déclencheur.
Le déclencheur INSTEAD OF exécute ensuite les instructions INSERT et UPDATE
sur les tables de base utilisées par la vue EMP_DETAILS. Par conséquent, plutôt
que l'insertion du nouvel enregistrement d'employé dans la table EMPLOYEES, les
actions suivantes ont lieu :
1. Le déclencheur NEW_EMP_DEPT INSTEAD OF s'exécute.
2. Une ligne est insérée dans la table NEW_EMPS.
3. La colonne DEPT_SAL de la table NEW_DEPTS est mise à jour. Le
salaire indiqué pour le nouvel employé est ajouté au montant total des
salaires du service auquel l'employé a été affecté.
Remarque : Le code de ce scénario est illustré dans les pages qui suivent.

Base de Données Avancées 2CS-SIT 2 - 82

L'exemple de la diapositive ci-dessus crée deux tables, NEW_EMPS et NEW_DEPTS,
basées respectivement sur les tables EMPLOYEES et DEPARTMENTS. Une vue
EMP_DETAILS est également créée à partir des tables EMPLOYEES et
DEPARTMENTS.
Si une vue présente une structure d'interrogation complexe, il n'est pas possible
d'effectuer une opération LMD directement sur la vue pour affecter les tables sous-
jacentes. Cet exemple nécessite la création d'un déclencheur INSTEAD OF, nommé
NEW_EMP_DEPT, illustré à la page suivante. Le déclencheur NEW_DEPT_EMP gère
les opérations LMD de la façon suivante :
• Lorsqu'une ligne est insérée dans la vue EMP_DETAILS, l'insertion de la
ligne ne s'effectue pas directement ; elle s'effectue dans les tables
NEW_EMPS et NEW_DEPTS en fonction des données fournies avec
l'instruction INSERT.
• Lorsqu'une ligne est modifiée ou supprimée dans la vue EMP_DETAILS,
ce sont les lignes correspondantes des tables NEW_EMPS et NEW_DEPTS
qui sont affectées.
Remarque : Les déclencheurs INSTEAD OF peuvent être écrits uniquement pour les
vues, et les options de déclenchement BEFORE et AFTER ne sont pas valides.

Base de Données Avancées 2CS-SIT 2 - 83

 CREATE OR REPLACE TRIGGER new_emp_dept
INSTEAD OF INSERT OR UPDATE OR DELETE ON emp_details
FOR EACH ROW
BEGIN
IF INSERTING THEN
INSERT INTO new_emps
VALUES (:NEW.employee_id, :NEW.last_name,
:[Link], :NEW.department_id);
UPDATE new_depts
SET dept_sal = dept_sal + :[Link]
WHERE department_id = :NEW.department_id;
ELSIF DELETING THEN
DELETE FROM new_emps
WHERE employee_id = :OLD.employee_id;
UPDATE new_depts
SET dept_sal = dept_sal - :[Link]
WHERE department_id = :OLD.department_id;
ELSIF UPDATING ('salary') THEN
UPDATE new_emps
SET salary = :[Link]
WHERE employee_id = :OLD.employee_id;
UPDATE new_depts
SET dept_sal = dept_sal +
(:[Link] - :[Link])
WHERE department_id = :OLD.department_id;
ELSIF UPDATING ('department_id') THEN
UPDATE new_emps
SET department_id = :NEW.department_id
WHERE employee_id = :OLD.employee_id;
UPDATE new_depts
SET dept_sal = dept_sal - :[Link]
WHERE department_id = :OLD.department_id;
UPDATE new_depts
SET dept_sal = dept_sal + :[Link]
WHERE department_id = :NEW.department_id;
END IF;
END;
/

Base de Données Avancées 2CS-SIT 2 - 84

Base de Données Avancées 2CS-SIT 2 - 85
Un déclencheur présente deux modes ou états : ENABLED et DISABLED. Un
déclencheur est activé par défaut lors de sa création.

Désactiver un déclencheur Avec la syntaxe ALTER TRIGGER DISABLE pour

désactiver un déclencheur spécifique ou ALTER TABLE DISABLE ALL TRIGGERS
pour désactiver tous les déclencheurs d'une table.

Recompiler explicitement un déclencheur non valide en utilisant la commande

ALTER TRIGGER COMPILE.

Base de Données Avancées 2CS-SIT 2 - 86

Avant de coder le corps d'un déclencheur, vous devez définir ses composantes.
Dans le cas d'événements système, les déclencheurs peuvent être définis au niveau
de la base de données ou du schéma. Par exemple, un déclencheur de fermeture de
base de données est défini au niveau de la base de données.
Des déclencheurs sur des instructions LDD (Langage de définition de données), ou
bien sur la connexion ou la déconnexion d'un utilisateur, peuvent être définis au
niveau de la base de données ou du schéma.
Les déclencheurs sur instructions LMD sont, quant à eux, définis sur une table ou une
vue spécifique.
Un déclencheur défini au niveau de la base de données s'exécute pour tous les
utilisateurs. Lorsqu'il est défini au niveau du schéma ou de la table, le déclencheur
s'exécute uniquement si l'événement déclencheur concerne le schéma ou la table.

Voici la liste des événements pouvant provoquer l'exécution d'un déclencheur :

• instruction LDD sur un objet de la base de données ou du schéma,
• connexion ou déconnexion d'un utilisateur spécifique (ou de n'importe
quel utilisateur),
• démarrage ou fermeture d'une base de données.

Base de Données Avancées 2CS-SIT 2 - 87

 Vous pouvez créer des déclencheurs pour les événements ci-dessus au niveau
DATABASE ou SCHEMA. Vous pouvez également définir BEFORE ou AFTER pour
désigner le moment de déclenchement.

DDL_Event Valeurs admises

CREATE Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'une instruction
CREATE ajoute un nouvel objet de base de données au dictionnaire.
ALTER Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'une instruction
ALTER modifie un objet de base de données dans le dictionnaire de données.
DROP Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'une instruction
DROP supprime un objet de base de données dans le dictionnaire de données.

Base de Données Avancées 2CS-SIT 2 - 88

A l'exception des événements SHUTDOWN et STARTUP, pour lesquels les
déclencheurs ne s'appliquent qu'au niveau DATABASE, vous pouvez créer des
déclencheurs au niveau DATABASE ou SCHEMA pour les événements ci-dessus.

Database_event Valeurs admises

AFTER Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'un
SERVERERROR message d'erreur du serveur est enregistré.
AFTER LOGON Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'un
utilisateur se connecte à la base de données.
BEFORE LOGOFF Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois qu'un
utilisateur se déconnecte de la base de données.
AFTER STARTUP Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois que la
base de données est ouverte.
BEFORE Entraîne l'exécution du déclencheur par le serveur Oracle, chaque fois que la
SHUTDOWN base de données est fermée.

Base de Données Avancées 2CS-SIT 2 - 89

Vous pouvez créer ces déclencheurs pour contrôler le nombre de connexions et de
déconnexions, ou pour générer un état sur la durée des connexions. Lorsque vous
indiquez ON SCHEMA, le déclencheur s'exécute pour un utilisateur spécifique.
Lorsque vous indiquez ON DATABASE, le déclencheur s'exécute pour tous les
utilisateurs.

Base de Données Avancées 2CS-SIT 2 - 90

Une instruction CALL permet d'appeler une procédure stockée, au lieu de coder le
corps PL/SQL du déclencheur. La procédure peut être implémentée en langage
PL/SQL, C ou Java.
L'appel peut référencer les attributs de déclencheur :NEW et :OLD en tant que
paramètres, comme le montre l'exemple suivant :

CREATE TRIGGER salary_check

BEFORE UPDATE OF salary, job_id ON employees
FOR EACH ROW
WHEN (NEW.job_id <> 'AD_PRES')
CALL check_salary(:NEW.job_id, :[Link])
/

Remarque : Il n'y a pas de point-virgule à la fin de l'instruction CALL.

Dans l'exemple ci-dessus, le déclencheur appelle une procédure check_salary.
Celle-ci compare le nouveau salaire à la plage de salaires, pour le nouvel ID de poste
dans la table JOBS.

Base de Données Avancées 2CS-SIT 2 - 91

Une table en mutation est une table sur laquelle une instruction UPDATE, DELETE
ou INSERT est en cours d'exécution, ou une table susceptible d'être mise à jour à la
suite d'une action d'intégrité référentielle déclarative DELETE CASCADE. Pour les
déclencheurs STATEMENT, une table n'est pas considérée comme une table en
mutation.

La table sur laquelle porte le déclencheur est elle-même une table en mutation,
comme n'importe quelle table la référençant avec la contrainte FOREIGN KEY. Cette
restriction empêche un déclencheur sur ligne d'avoir accès à un ensemble incohérent
de données.

Base de Données Avancées 2CS-SIT 2 - 92

Le déclencheur CHECK_SALARY utilisé dans l'exemple ci-dessus essaie de garantir
l'adéquation du salaire d'un employé avec l'échelle de rémunération établie pour le
poste, chaque fois qu'un nouvel employé est ajouté à la table EMPLOYEES, ou
encore que le salaire ou l'ID de poste d'un employé existant est modifié.

Lorsque l'enregistrement d'un employé est mis à jour, le déclencheur

CHECK_SALARY s'exécute sur chaque ligne mise à jour. Le code du déclencheur
interroge la table qui est mise à jour. Par conséquent, on dit que la table
EMPLOYEES est une table en mutation.

Base de Données Avancées 2CS-SIT 2 - 93

Dans l'exemple de la diapositive ci-dessus, le code du déclencheur tente de lire ou de
sélectionner des données dans une table en mutation.
Toute tentative de limitation d'un salaire entre une valeur minimale et une valeur
maximale génère une erreur lors de l'exécution. La table EMPLOYEES est en
mutation ; par conséquent, le déclencheur ne peut pas la lire.

Une solution possible au problème des tables en mutation serait de stockez les
données récapitulatives (salaires minimum et maximum) dans une autre table
récapitulative, qui est tenue à jour avec d'autres déclencheurs LMD.

Base de Données Avancées 2CS-SIT 2 - 94

Base de Données Avancées 2CS-SIT 2 - 95
Fonctionnalité Amélioration
Sécurité Le serveur Oracle permet aux utilisateurs ou aux rôles d'accéder aux tables. Les
déclencheurs autorisent l'accès aux tables en fonction des valeurs des données.
Audit Le serveur Oracle opère un suivi des opérations effectuées sur les tables. Les
déclencheurs opèrent un suivi des valeurs pour les opérations effectuées sur les
tables.
Intégrité des Le serveur Oracle applique les contraintes d'intégrité. Les déclencheurs
données implémentent les règles d'intégrité complexes.
Intégrité Le serveur Oracle applique les règles d'intégrité référentielle standard. Les
référentielle déclencheurs implémentent les fonctionnalités non standard.
Réplication Le serveur Oracle copie les tables de manière asynchrone dans des clichés
de tables (snapshots). Les déclencheurs copient les tables de manière synchrone dans des
copies.
Données Le serveur Oracle calcule les valeurs des données dérivées en fonction des ordres
dérivées passés par l'utilisateur. Les déclencheurs calculent automatiquement les valeurs
des données dérivées.
Consignation Le serveur Oracle consigne les événements de manière explicite. Les déclencheurs
des événements consignent les événements de manière transparente.

Base de Données Avancées 2CS-SIT 2 - 96

La diapositive ci-dessus présente les vues du dictionnaire de données auxquelles vous
pouvez accéder pour obtenir des informations sur les déclencheurs.
La vue USER_OBJECTS contient le nom et le statut du déclencheur, ainsi que la
date et l'heure de sa création.
La vue USER_ERRORS contient des détails sur les erreurs se produisant lors de la
compilation d'un déclencheur. Le contenu de ces vues est similaire à celui des sous-
programmes.
La vue USER_TRIGGERS contient des informations telles que le nom, le type,
l'événement de déclenchement, la table sur laquelle le déclencheur a été créé et le
corps du déclencheur.

Base de Données Avancées 2CS-SIT 2 - 97

Si le fichier source n'est pas disponible, vous pouvez utiliser USER_TRIGGERS
pour le régénérer. Vous pouvez également examiner les vues ALL_TRIGGERS et
DBA_TRIGGERS, dont chacune contient la colonne supplémentaire OWNER,
désignant le propriétaire de l'objet.

Base de Données Avancées 2CS-SIT 2 - 98

Base de Données Avancées 2CS-SIT 2 - 99
Bibliographie
• A. Silberschatz, H. F. Korth, S. Sudarshan. « DATABASE SYSTEM CONCEPTS »,
Sixth Edition.
• Oracle University, « Oracle Database: Les fondamentaux du langage SQL»
• Oracle University, « Oracle Database: Les fondamentaux du langage PL/SQL»
• Oracle University, « Oracle Database: Objets procéduraux basés d'Oracle»

Base de Données Avancées 2CS-SIT 2 - 100