SQL FUNDEMENTALS SQL ORACLE PREMIER NIVEAU

Objectifs
 Configurer l’environnement de travail
 Vérifier les pré-requis
 Installer le SGBDR Oracle Database 11g Express Edition
 Installer Oracle SQL Developer
 Se connecter au moteur de base de données Oracle
 Créer le shéma fac (fac.sql)

Prés-requis
 Matériel
• Mémoire
Minimum :
- Éditions Express : 512 MO
• Processeur
Minimum :
- Processeur x86 : 1,0 GHz, Processeur x64 : 1,4 GHz
- Recommandé : 2,0 GHz ou plus
• Disque
Minimum :
- 5,0 GO disponible

Prés-requis
 Logiciel
• OS
Windows 7 && Windows 8 :
• SGBDR et Outil
- Oracle Database 11g Entreprise Edition
• http://www.oracle.com/technetwork/database/database-technologies/
expressedition/ downloads/index.html
• Oracle SQL Developper
• http://www.oracle.com/technetwork/developer-tools/sql-developer/downloads/
index.html

MODULE 1:
Présentation de PL/SQL
Introduction à PL/SQL
Le langage PL/SQL
MODULE 2 :
Les types de variables.
Écritures des instructions exécutables
Interagir avec le Serveur Oracle
MODULE 3:
Interaction avec la base de données
Les instructions de contrôle : conditions, itérations.
Utiliser des types de données composites
Curseurs implicites et explicites

MODULE 4 :
Gestion des erreurs par le mécanisme d'exceptions
Procédures et fonctions.
- Définition et utilisation des procédures stockées.
- Spécification des packages.
MODULE 5 :
Triggers LMD dans Oracle
Présentation des triggers d’Oracle
- Structure d'un trigger (Evénement/Action).
- Types de triggers LMD (statement et row triggers).
- Actions d'un trigger (mise à jour automatique des données, annulation d'une action illicite, audit).
MODULE 6 :
Utilisation des triggers
- Création et utilisation des triggers d'instruction.
- Utilisation des triggers de ligne : NEW et : OLD dans ces triggers. Gestion des triggers.

Présentation du language PL/SQL
Utiliser Oracle SQL Developer pour développer en PL/SQL
Exécuter un programme PL/SQL à partir de sqlplus
1) Outils de développement
 Oracle SQL Developer
Caractéristiques
• Auto-formatage des instructions PL/SQL et SQL
• Inclut un débogueur PL/SQL
• Permet de naviguer dans les objets de bases de données
• Contient des modèles de code
• Permet l’exécution de scripts

Introduction à PL/SQL
Il faut Connaître la syntaxe du langage PL/SQL et écrire et exécuter un bloc PL/SQL
Le langage PL/SQL est une extension procédurale du langage SQL. : il est caractérise par
• Possibilité d ’inclure des requêtes .
• des ordres de manipulation données à l ’intérieur d ’une structure algorithmique
 Intérêts du PL/SQL
Améliorations des performances

Structure d’un programme PL/SQL
Un programme PLSQL se décompose en trois parties :

Structure d’un bloc PL/SQL
 DECLARE (facultatif)
• Variables, curseurs, exceptions définies
• par l’utilisateur
 BEGIN (obligatoire)
• - Instructions SQL
• - Instructions PL/SQL
 Exception (facultatif)
• Actions à effectuer
• lorsque des erreurs se produisent
 END; (obligatoire)

Affichage à l’écran
• DBMS_OUTPUT : package fourni par Oracle
• Procédure PUT_LINE : affichage de la valeur d’une variable.
• Utilisable sous SQL*PLUS avec l’option SET SERVEROUTPUT ON

Les variables
 identifier les identificateurs valides et non valides
 Répertorier les utilisations des variables
 Déclarer et initialiser des variables
 Répertorier et décrire les différents types de données
 Identifier les avantages liés à l’utilisation de l’attribut %TYPE
 Déclarer, utiliser et afficher des variables attachées

Utilisations de variables
• Connaître les types de données des variables
• Déclarer et manipuler des variables en PL/SQL
• Déclaration dans la section DECLARE.
• Affectation de valeurs dans la section exécution (ou à la déclaration).
• Passage de valeurs pour les procédures et fonctions.
• Les variables peuvent être utilisées pour
• le stockage temporaire de données
• La manipulation de valeurs stockées
• La réutilisation

Identificateurs
 Les identificateurs sont utilisés pour
• nommer les variables
• définir une convention pour les noms de variables et les noms
• doivent commencer par une lettre
• Peuvent inclure des lettres ou des chiffres
• Peuvent inclure des caractères spéciaux tels que les signe $, _ ou #
• Doivent présenter une longueur maximale de 30 caractères
• Ne doivent pas être des mots réservés

Types de variables
 Variables PL/SQL
 Scalaires
 Composites
 Références
 Lob(grand objets , large objet)
• Variables non PL/SQL : variables attachées

Conversion de types de données
 Les types de conversion
• EXPLICITE
• Utilisent des fonctions comme TO_DATE, TO_CHAR, etc.
 IMPLICITE
 Réalisés automatiquement par le bloc PL/SQL
- Evaluation d’expressions
- Affectation des variables

 Evaluations d’expressions

Affectation de variables

Déclarations et initialisations des variables
Syntaxe :
Exemple:

Règles de déclaration et d'initialisation
des variables PL/SQL
 Respecter les conventions de notations
• Utiliser des noms évocateurs pour les variables
• Initialiser les variables désignées comme NOT NULL et CONSTANT
• Initialiser les variables avec l’opérateur d’affectation (:=) ou le mot clé DEFAULT
• Déclarer un identificateur par ligne pour améliorer la lisibilité et faciliter la
maintenance du code

Règles de déclaration et d'initialisation
des variables PL/SQL
 Eviter d’utiliser des noms de colonnes comme identificateurs
 Utiliser la contrainte NOT NULL lorsque la variable doit contenir une valeur

Affectation de valeur
Syntaxe :
Exemples :
Affecter une valeur date d’ embauche
Affecter un nom employé :

Types de données scalaires
• Ils contiennent une valeur unique
• Ils n’ont pas de composants internes
• CHAR [(maximum_length)]
• VARCHAR2 (maximum_length)
• LONG
• LONG RAW
• NUMBER [(precision, scale)]
• BOOLEAN
• BINARY_FLOAT
• BINARY_DOUBLE
• BINARY_INTEGER
• PLS_INTEGER
• DATE
• TIMESTAMP
• TIMESTAMP WITH TIME ZONE
• TIMESTAMP WITH LOCAL TIME ZONE
• INTERVAL YEAR TO MONTH
• INTERVAL DAY TO SECOND

Déclarations des variables scalaires

Déclaration de type par référence
 L’attribut %TYPE
• est utilisé pour déclarer une variable en fonction d’une définition de colonne de
base de données d’une autre variable déclarée est préfixé avec la table et la
colonne de la base de données le nom de la variable déclarée
Syntaxe de déclaration
<nom_variable> {<nom_table.colonne | <nom_variable>}%TYPE;
 Attribut %ROWTYPE
Permet à la variable d’hériter des caractéristiques d’une ligne de table
Syntaxe de déclaration
• <nom_variable> {<nom_table> | <nom_variable>}%ROWTYPE;

Déclarer des variables avec l’attribut %TYPE
Syntaxe :
Exemples :

Déclarer des variables booléennes
 Seules les valeurs TRUE, FALSE et NULL peuvent être affectées à une variable booléenne
 Les expressions conditionnelles utilisent les opérateurs logiques AND et OR, ainsi que
l’opérateur NOT, pour vérifier les valeurs des variables
 Les variables renvoient toujours TRUE, FALSE ou NULL
 Des expressions arithmétiques, caractères, ou dates peuvent être utilisées pour renvoyer une
valeur booléenne
Exemple :
DECLARE
FLAG BOOLEAN := FALSE;
BEGIN
FLAG :=TRUE;
END;
/

Variables attachées
Les variables attachées sont créées dans l’environnement sont :
 Également appelées variables hôte
 Créées avec le mot clé VARIABLE
 Utilisées dans les instructions SQL et les blocs PL/SQL
 Accessibles même après l’exécution du bloc PL/SQL
 Référencées avec un signe deux-points précédant la variable

Afficher des variables attachées
Exemples:

Ecrire des instructions exécutables
1. Identifier les unités lexicales d’un bloc PL/SQL
2. Utiliser des fonctions SQL intégrées dans du code PL/SQL
3. Décrire dans quels cas des conversions implicites ont lieu et dans
quels cas effectuer des conversions explicites
4. Écrire des blocs imbriqués et qualifier des variables avec des
étiquettes
5. Écrire du code lisible grâce à des indentations appropriées

Unités lexicales d’un bloc PL/SQL
Les unités lexicales
 sont les blocs constitutifs de n’importe quel bloc PL/SQL
 Sont des séquences de caractères incluant des chiffres, des
tabulations, des espaces, des retours chariot et des symboles
 peuvent être classées en différents groupe
 Identificateurs
 Délimiteurs
 Littéraux
 commentaires

Syntaxe et règles relatives au bloc
PL/SQL
 Littéraux
 Les littéraux de type caractères et date doivent être placés entre apostrophes
 Les nombres peuvent être des valeurs simples ou utiliser une notation scientifique
 Les instructions peuvent s’étendre sur plusieurs lignes

Commenter le code
 Commentaires monolignes avec deux traits d’union (--)
 Commentaires multi-lignes entre les symboles "/*" et "*/"
Exemple:

Fonction SQL dans le code PL/SQL
• Disponibles dans les instructions procédurales
• Fonctions monolignes numériques
• Fonctions monolignes de type caractère
• Conversion de type de données
• Fonctions de date
• Horodatage
 Fonctions GREATEST et LEAST
• Fonctions diverses
• Non disponibles dans les instructions procédurales
• DECODE
• Fonctions de groupe

Fonction SQL dans le code PL/SQL
 Exemples :
• Déterminer la longueur d’une chaine
• Convertir le nom d’un employé en minuscule

Conversion de type de données
 Conversion de données en type de données comparables
 Elles sont de deux types
• Conversion implicite
• Conversion explicite
 Exemples de fonctions de conversion
• TO_CHAR
• TO_NUMBER
• TO_DATE
• TO_TIMESTAMP

Blocs imbriqués
 Les blocs PL/SQL peuvent être imbriqués
 Une section exécutable (BEGIN…END) peut contenir des blocs imbriqués
 Une section de traitement des exceptions peut contenir des blocs imbriqués

Portée et visibilité des variables

Opérateurs en PL/SQL
Exemple :
 Incrémenter le compteur pour une boucle
 Définir la valeur d’un indicateur booléen
 Vérifier qu’un numéro d’employé contient une valeur

Interagir avec le Serveur Oracle
Objectif :
 déterminer les instructions SQL pouvant être incluses directement dans un
bloc exécutable PL/SQL
 Manipuler les données à l’aide d’instructions LMD dans du code PL/SQL
 Utiliser des instructions de gestion des transactions dans le code PL/SQL
 Utiliser la clause INTO pour le stockage des valeurs renvoyées par une
instructions SQL
 Distinguer les curseurs implicites des curseurs explicites Utiliser des
attributs de curseur SQL

Instructions SQL en langage PL/SQL
• Extraire une ligne de la BD à l’aide de la commande SELECT
• Modifier des lignes de la BD en utilisant des commandes LMD
• Contrôler une transaction avec les commandes COMMIT,
• ROLLBACK ou SAVEPOINT

Instructions SELECT en PL/SQL
Extraire des données de la BD avec une commande SELECT

Instructions SELECT en PL/SQL
 La clause INTO est obligatoire
 Les interrogations doivent renvoyer une seule ligne

Exemple d’extraction de données
Exemple : Extraire les valeurs hire_date et salary de l’employé
désigné

Exemple
• Exemple : Renvoyer la somme des salaires de tous les employés du
département désigné

Conventions d’appellation
• Utiliser une convention de notation pour éviter toute ambigüité avec
• la clause WHERE
• Eviter d’utiliser des noms de colonnes de base de données comme
• identificateurs
• Des erreurs de syntaxe peuvent survenir, car le compilateur PL/SQL
• recherche en premier lieu une colonne de la base de données
• Les noms des variables locales et les paramètres formels ont une
• priorité sur les noms de tables de la BD
• Les noms des colonnes des tables de la BD ont une priorité sur les
• noms des variables locales

Manipulation des données
Modifier des tables de la BD en utilisant des instructions LMD

Insérer des données
Exemple : ajout un nouvel employé

Mise à jour
Exemple : Augmenter le salaire de tous les employés chargés du contrôle des
stocks

Supprimer des données
Exemple : Supprimer les tuples appartenant au département 10 à
partir de la table employees

Ordres COMMIT et ROLLBACK
• Début de transaction : premier ordre LMD
• Fin de transaction explicite : COMMIT ou ROLLBACK.

Curseur SQL
• Un curseur est un pointeur vers la zone mémoire allouée par le serveur Oracle
• Il existe deux types de curseur
• Curseurs implicites : créés et gérés en interne par le serveur Oracle afin de
traiter les instructions SQL
Curseurs explicites : déclarés explicitement par le programmeur

Attributs de curseur SQL pour les curseurs
implicites
• Grâce aux attributs de curseur SQL, on peut tester le résultat de l’exécution des
instructions SQL

Exemple d’utilisation de curseurs
Exemple : Supprimer l’identifiant 51 de la table test
DECLARE
v_rows_deleted VARCHAR2(20);
v_test test.id%TYPE := 51;
BEGIN
delete from test where id=v_test;
v_rows_deleted := (SQL%ROWCOUNT || ' ligne supprimée');
DBMS_OUTPUT.PUT_LINE (v_rows_deleted);
END;
/

Exemple d’utilisation de curseur implicite
Exemple : ajouter une ligne dans la table test
DECLARE
v_rows_ajout VARCHAR2(20);
BEGIN
insert into test values(1,'SAMBA');
v_rows_ajout := (SQL%ROWCOUNT || ' ligne ajoutée');
DBMS_OUTPUT.PUT_LINE (v_rows_ajout);
END;
/

Exemple de mise à jour avec les curseurs implicites
Exemple : augmenter le salaire de l’employé à 100 qui a l’identifiant 3
DECLARE
v_rows_deleted VARCHAR2(20);
salaire test.Sal%TYPE := 100;
BEGIN
Update test set Sal=Sal + salaire where id=3;
v_rows_deleted := (SQL%ROWCOUNT || ' ligne modifiée');
DBMS_OUTPUT.PUT_LINE (v_rows_deleted);
END;
/

Instructions de contrôle
Objectif du chapitre
 Identifier les types de structures de contrôle et leurs utilisations
 Écrire une instruction IF
 Utiliser des instructions et des expressions CASE
 Écrire et identifier différents types d’instruction de boucle
 Appliquer les règles d’utilisation des structures de contrôle conditionnel.

Contrôle le flux d’exécution

Types de Structures de contrôle
 Deux types de structures :
 Alternatives
 Répétitives
 Structures alternatives
Instruction IF
Trois formes :
• IF-THEN-END IF
• IF-THEN-ELSE-END IF
• IF-THEN-ELSIF-END IF

Instruction IF
Syntaxe :
Exemple : simple instruction IF

Exemple instruction IF THEN ELSE
Exemple :

Exemple de la clause IF-THEN-ELSIF

Valeur NULL dans les instructions de IF

Expressions CASE
 Une expression CASE sélectionne un résultat et le renvoie
 Pour sélectionner le résultat, l’expression CASE utilise des expressions.
 La valeur renvoyée par ces expressions est utilisée pour sélectionner une ou plusieurs
alternatives

Exemple d’expression Case
DECLARE
v_grade char(1) := upper('&grade');
Mention varchar2(20) ;
BEGIN
Mention := CASE v_grade
WHEN 'A‘ THEN ‘Excellent'
WHEN 'B' THEN ‘Very Good'
WHEN 'C' THEN ‘Good'
ELSE 'pas de grade'
END;
DBMS_OUTPUT.PUT_LINE('Grade: '||v_grade || ' Mention ' || Mention );
END;
/

Traiter les valeurs NULL
• Lorsqu’on utilise des valeurs NULL, on peut éviter certaines erreurs
• fréquentes en gardant à l’esprit les règles suivantes :
• Les comparaisons simples impliquant des valeurs NULL renvoient toujours une
valeur NULL
• L’application de l’opérateur NOT à une valeur NULL renvoie toujours une valeur
NULL
• Dans les instructions de contrôle conditionnelles, si la condition renvoie
• une valeur NULL, la séquence d’instructions associée n’est pas exécutée.

Structure répétitive
Une boucle répète une instruction ou une séquence d’instructions plusieurs fois.
 Trois possibilités :
• – instruction LOOP
• – Instruction FOR
• – instruction WHILE

Contrôle d’itération : instructions LOOP
Les boucles permettent d’exécuter plusieurs fois une instruction ou une suite
d’instructions
• Il existe trois types de boucle :
• Boucle de base
• Boucle FOR
• Boucle WHILE

Exemple d’instruction Loop
Exemple :
DECLARE
v_val test.id%TYPE :=1 ;
v_compter NUMBER(2) := 1;
BEGIN
LOOP
INSERT INTO test (id , nom , sal , num_test) VALUES (v_val ,'sall',1000, v_compter);
v_compter := v_compter + 1;
EXIT WHEN v_compter > 4;
END LOOP;
END;
/

Exemple avec l’instruction Loop
Exemple : afficher les 10 premiers nombres entiers
DECLARE
v_val number(2):=0;
v_compter NUMBER(2) := 1;
BEGIN
LOOP
v_val := v_val+1;
v_compter := v_compter + 1;
DBMS_OUTPUT.PUT_LINE( v_val);
EXIT WHEN v_compter > 10;
END LOOP;
END;
/

Boucle WHILE
Une boucle WHILE est utilisée pour répéter des instructions tant qu’une condition est
vérifiée (ie. renvoie TRUE)
Syntaxe :

Exemple de Boucle while
Exercice1:
Ecrivez un programme qui place la valeur 10 dans une variable a, puis affichant la factorielle de a.
DECLARE
a NUMBER;
Res NUMBER;
compt NUMBER;
BEGIN
a := 10 ;
res := 1 ;
compt := a ;
WHILE compt > 0 LOOP
res := res * compt ;
compt := compt - 1 ;
END LOOP ;
DBMS_OUTPUT.PUT_LINE ( a || ' != ' || res ) ;
END;
/

Instruction FOR
Règles :
• L’indice n’est utilisable qu’à l’intérieur de la boucle.
• Il est interdit d’affecter une valeur à l’indice
Syntaxe :
• Le nombre de répétitions est contrôlé par l’indice.
• Ne pas déclarer l’indice, sa déclaration est implicite.

Exemple de la boucle FOR
Exemple : création de 10 lignes pour le numéro de test 10
DECLARE
v_test test.id%TYPE :=10 ;
BEGIN
FOR i IN 1..10 LOOP
INSERT INTO test(id , num_test)VALUES(v_test , i);
END LOOP;
END;
/
Exemple : écrire un programme qui affiche les 10 premiers nombres

Exemple instruction FOR
Exemple : écrire un programme qui affiche les 10 premiers nombres
DECLARE
v_val number :=10 ;
res number;
BEGIN
FOR i IN 1..10 LOOP
res:=res * v_val ;
res:=i;
DBMS_OUTPUT.PUT_LINE(res);
END LOOP;
END;
/

Remarques relatives à l’utilisation des
boucles
 Utiliser la boucle de base lorsque ses instructions de base s’exécute
au moins une fois
 Utiliser la boucle WHILE si la condition doit être évaluée au début
de chaque itération
 Utiliser une boucle FOR si le nombre d’itérations est connu.

Utiliser des types de données composites
Deux types:
– Enregistrement (RECORD)
– Tableau (TABLE PL/SQL)
• Contiennent des composants internes sont réutilisables
Ils peuvent contenir plusieurs valeurs, contrairement aux types scalaires
Ils sont de deux types: Enregistrements PL/SQL Ensembles PL/SQL
Tables INDEX BY ou tableaux associatifs
• Tables imbriquées
• VARRAY
• Utiliser des enregistrement PL/SQL pour stocker des valeurs de types différents
• Utiliser des ensembles PL/SQL pour stocker des valeurs de même type de données

Enregistrements PL/SQL
 Ils doivent être composés d’un ou plusieurs champs de type scalaire,
RECORD, ou table INDEX BY
 Ils sont semblables aux structures de la plupart des langages de
troisième génération, tels que C et C++
 Ils sont définis par l’utilisateur et peuvent être un sous-ensemble d’une ligne
d’une table
 Ils traitent un ensemble de champ comme une unité logique
 Ils permettent d’extraire une ligne de données à partir d’une table pour la traiter

Déclaration d’un type d’enregistrement
Syntaxe :
Avec déclaration de champs

Déclaration d’un type d’enregistrement
Exemple
Déclaration d ’une variable pour stocker nom, emploi, et salaire d’un employé.

Exemple d’enregistrement (1)
Exemple : écrire un programme qui donne l’abscisse et l’ordonné d’un enregistrement
DECLARE
TYPE point IS RECORD
(
abscisse NUMBER,
ordonnee NUMBER
) ;
p point ;
BEGIN
p . abscisse := 1 ;
p . ordonnee := 3 ;
DBMS_OUTPUT . PUT_LINE ( ' p.abscisse = ' || p.abscisse ||
' and p.ordonnee =' || p.ordonnee ) ;
END;
/

Créer une table test_table1 (record_ number, current_date)
DECLARE
type enrg is record
( Nbr test_table1.record_number%type ,
dateca test_table1.current_date%type ,
mot varchar(40));
test_rec enrg;
BEGIN
test_rec.Nbr :=10 ;
test_rec.mot :=‘cours de PL/SQL';
test_rec.dateca := '01/01/2000';
dbms_output.put_line(‘Numero :' || test_rec.Nbr);
dbms_output.put_line('Date est :' || to_char(test_rec.dateca,'dd-mm-yyyy'));
dbms_output.put_line('Remarque :' || test_rec.mot);
insert into test_table1
(record_number , current_date)
values (test_rec.Nbr,test_rec.dateca);
end;
/

Attribut %ROWTYPE
Déclarer une variable correspondant à l’ensemble des colonnes d’une table ou d’une vue
d’une base de données
Faire précéder %ROWTYPE du nom de la table ou de la vue de la BD
Les noms et types de données des champs de l’enregistrement sont issus des colonnes de la
table ou de la vue.
Syntaxe :

Utilisation de %ROWTYPE
• Permet de déclarer une variable de même structure qu’une ligne de table ou de vue.
• Nom_table%ROWTYPE.
• Les champs de l’enregistrement ont même nom et même type que ceux des colonnes de la
table ou de la vue.
Exemples :
Déclarer une variable pour stocker la même information que celle définie dans
la table DEPT
Déclare une variable pour stocker la même information que celle définie dans
la table EMP.

Avantage de %ROWTYPE
• Il n ’est pas nécessaire de connaître les caractéristiques des colonnes de la ligne de
référence .
• Mise à jour automatique en cas de modification de la structure de la ligne
de référence.
• Utilisable avec SELECT pour recueillir les données d’une ligne.
 Il n’est pas nécessaire de connaître le nombre et le type des
colonnes sous-jacentes.
 Le nombre et les types de colonnes sous-jacentes peuvent être modifiés durant l’exécution
 L’attribut permet d’extraire une ligne avec l’instruction SELECT *.

Curseurs Explicites
Objectifs
• Faire la différence entre un curseur implicite et un curseur explicite
• Déterminer quand et pourquoi utiliser un curseur explicite
• Déclarer et contrôler des curseurs explicites
• Utiliser une boucle simple et une boucle FOR de curseur pour extraire des
données
• Déclarer et utiliser des curseurs avec parmètres
• Verrouiller des ligne à l’aide ce la clause FOR UPDATE
• Référencer la ligne actuelle avec la clause WHERE CURRENT

A propos des curseurs
Tout ordre SQL utilise un curseur pour s’exécuter :
• curseur implicite
– tout ordre LMD (DML)
– SELECT … INTO ... sous PL/SQL
• curseur explicite
– déclaré dans un module
A chaque instruction SQL exécutée par le serveur Oracle est associé
un curseur individuel :
Curseurs implicites : déclarés et gérés par le compilateur PL/SQL pour
toutes les instructions LMD et les instructions SELECT PL/SQL
Curseurs explicites : déclarés et gérés par le programmeur.

Contrôler les curseurs explicites

Mise en oeuvre des curseurs explicites

Déclaration d’un curseur
Syntaxe :
• Requête sans clause INTO.

Ouverture du curseur
Syntaxe :
• Exécution de la requête et génération des lignes résultats au niveau du serveur.
• Pas d’erreur si la requête ne sélectionne pas de ligne.
• Possibilité de tester le statut du curseur après exécution de l’ordre FETCH.
Exemple:

Distribution des lignes
Syntaxe :
• Distribue les valeurs des colonnes de la ligne courante dans les variables de réception.
• Effectue une correspondance par position.
• Renvoie un code statut.
Inclure l ’ordre FETCH dans une structure répétitive.
• Une ligne est distribuée à chaque itération.
• Utiliser %NOTFOUND ou %FOUND pour contrôler la sortie de la boucle.

Fermeture du curseur
Syntaxe :
 Ferme le curseur et libère les ressources.
• Possibilité de ré-ouvrir le même curseur.

Exemples
Exemples :
DECLARE
CURSOR test_cur IS
SELECT * FROM test ;
ligne test_cur%rowtype ;
BEGIN
OPEN test_cur ;
FETCH test_cur INTO ligne ;
DBMS_OUTPUT . PUT_LINE (ligne.nom) ;
CLOSE test_cur ;
END;
/

Exemples avec une boucle FOR
DECLARE
CURSOR emp_cur IS
ligne emp_cur%rowtype ;
BEGIN
FOR ligne IN emp_cur LOOP
DBMS_OUTPUT . PUT_LINE (ligne.nom) ;
END LOOP;
END;
/

Extraire les données du curseur
Exemples :
DECLARE
CURSOR test_cur IS
SELECT nom , sal FROM test ;
v_val test.nom%TYPE;
v_salaire test.sal%TYPE;
BEGIN
OPEN test_cur;
FETCH test_cur INTO v_val , v_salaire ;
DBMS_OUTPUT.PUT_LINE (v_val || '' || v_salaire ) ;
END;
/

Curseurs et enregistrements
Exemple :
DECLARE
CURSOR test_cur IS
SELECT nom , sal FROM test where id =1 ;
v_test_record test_cur%ROWTYPE;
BEGIN
OPEN test_cur;
FETCH test_cur INTO v_test_record;
DBMS_OUTPUT.PUT_LINE (v_test_record.nom || '' || v_test_record.sal ) ;
END;
/

Curseur paramétré
Syntaxe :
• Transmettre des paramètre au curseur au moment de son ouverture et de l’exécution de
l’interrogation
• Ouvrir un curseur explicite à plusieurs reprises en renvoyant un ensemble actif différent à
chaque fois

Curseur avec paramètre
Exemple:
DECLARE
CURSOR test_cur (deptno number , name varchar2) IS
SELECT nom , sal FROM test where id =deptno;
v_nom test.nom%TYPE;
BEGIN
OPEN test_cur (5 , 'sall');
FETCH test_cur INTO v_nom , v_salaire ;
DBMS_OUTPUT.PUT_LINE ( v_nom || ‘ ' || v_salaire ) ;
END;
/

Mise à jour avec un curseur
Clause For Update
Utiliser un verrouillage explicite pour interdire l’accès aux autres sessions pendant la durée d’une
transaction
• Verrouiller les lignes avant la mise à jour ou la suppression
• Verrouille les lignes sélectionnées pour la durée de la transaction.
• Verrouille les lignes avant l’exécution d ’un ordre update ou delete.
Exemple : sélectionner les employés du département 30;

Clause WHERE CURRENT OF
Syntaxe :
• Utiliser des curseurs pour mettre à jour ou supprimer les lignes en cours
• Inclure la clause FOR UPDATE dans l’interrogation du curseur pour
• verrouiller au préalable les lignes
• Utiliser la clause WHERE CURRENT OF pour référencer la ligne en cours à partir d’un
curseur explicite
• Curseur en vue de modifier ou supprimer les lignes sélectionnées.
• Utiliser la clause FOR UPDATE dans l’expression du curseur.
• Utiliser la clause WHERE CURRENT OF pour faire référence à la dernière ligne distribuée
par le curseur.

Exemples
Exemples : modifier le sal de l’employé qui a l’identifiant 1 ;
DECLARE
CURSOR sal_cursor IS
SELECT sal
FROM test
WHERE id = 1
FOR UPDATE of sal NOWAIT;
BEGIN
FOR emp_record IN sal_cursor LOOP
UPDATE test
SET sal = emp_record.sal * 0.10
WHERE CURRENT OF sal_cursor;
END LOOP;
COMMIT;
END;
/

Codes statut d’un curseur
La distribution de ligne ne s’effectue que pour un curseur ouvert.
• Permet de savoir si un curseur est ouvert avant d’exécuter un ordre fetch.

Attribut %ISOPEN
Exemple :
DECLARE
CURSOR test_cur IS
SELECT nom , sal FROM test where id =1 ;
v_val test.nom%TYPE;
BEGIN
IF NOT test_cur%ISOPEN THEN
OPEN test_cur;
END IF;
FETCH test_cur INTO v_val , v_salaire ;
DBMS_OUTPUT.PUT_LINE (v_val || '' || v_salaire ) ;
END;
/

Attribut NOTFOUND
FOUND ROWCOUNT
%ROWCOUNT :
donne, après chaque exécution de l’ordre fetch, le nombre de lignes distribuées.
• %NOTFOUND :
indique la fin de distribution des lignes d’un curseur.
• %FOUND :
testé après exécution du premier ordre fetch indique si la requête a sélectionné au moins une
ligne.

Exemples
DECLARE
CURSOR test_cur IS
ligne test_cur%rowtype ;
BEGIN
OPEN test_cur ;
loop
FETCH test_cur INTO ligne ;
exit when test_cur%ROWCOUNT > 6 OR test_cur%NOTFOUND;
DBMS_OUTPUT.PUT_LINE (ligne.nom) ;
end loop;
CLOSE test_cur ;
END;
/

Gestion des exceptions
Objectifs
• Définir des exceptions PL/SQL
• Reconnaitre des exceptions non gérées
• Répertorier et utiliser différents types de gestionnaires d’exceptions
• PL/SQL
• Intercepter les erreurs non prédéfinies
• Décrire l’effet de la propagation des exceptions dans des blocs
• imbriqués
• Personnaliser les messages d’exception PLS/SQL

Gestion des exceptions en PL/SQL
• Débutée par le mot clé EXCEPTION, elle contient le code mis en oeuvre pour la
gestion des erreurs générées par la section d'exécution
• Une erreur survenue lors de l'exécution du code déclenche ce que l'on nomme une
exception. Le code erreur associé est transmis à la section EXCEPTION, pour vous
laisser la possibilité de la gérer et donc de ne pas mettre fin prématurément à
l'application. Prenons l'exemple suivant :
• Nous souhaitons retrouver la liste des employés dont la date d'entrée est inférieure au
premier janvier 1970

Exemple
Exo 1 : créer la table emp (empno , ename , hiredate , sal)
Declare
Nom EMP.ename%Type ;
Begin
Select empno Into Nom From EMP
Where hiredate < to_date('01/01/1970', 'DD/MM/YYYY') ;
End ;
/
Rq :
Declare
*
ERREUR à la ligne 1 :
ORA-01403: Aucune donnée trouvée
ORA-06512: à ligne 4

Comme la requête ne ramène aucune ligne, l'exception prédéfinie NO_DATA_FOUND est
générée et transmise à la section EXCEPTION qui peut traiter le cas et poursuivre
l'exécution de l'application. L'exception NO_DATA_FOUND (ORA_01403) correspond au
code erreur numérique +100. Il existe des milliers de code erreur Oracle et il serait vain de
tous leur donner un libellé.

Traitement des exceptions en PL/SQL
Une exception est une erreur PL/SQL détectée pendant l’exécution du programme
Une exception peut être générée Implicitement par le serveur Oracle ou explicitement par le
programme .Une exception peut être traitée Par interception à l’aide d’un gestionnaire par
propagation vers l’environnement appelant.

Types d’exceptions
• Erreur émise par le serveur
– Prédéfinies
– Non prédéfinies
• Exception générée par l’utilisateur

Intercepter les exceptions
Syntaxe :
• WHEN OTHERS est la dernière clause.
• Le mot clé EXCEPTION introduit la section de gestion des exceptions.
• Plusieurs gestionnaires d’exception peuvent être définis dans un même bloc
• Un seul gestionnaire d’exception est exécutée suite à la détection d ’une exception, avant de sortir du
bloc.

Exemples
Declare
Chaine varchar2(10) ;
trop_long exception ;
Begin
Chaine := 'informatique' ;
Exception
when others then
dbms_output.put_line( 'Chaîne de caractères trop longue') ;
End ;
/

Utilisation des exceptions
Syntaxe :

Exemples
Exemple :
Exception ZERO_DIVIDE
DECLARE
x NUMBER := 5;
y NUMBER := 0;
z NUMBER;
BEGIN
z := x/y;
EXCEPTION
WHEN ZERO_DIVIDE THEN
raise_application_error(-20101, 'division par zéro impossible ');
END;
/

Intercepter les erreurs non prédéfinies
du serveur Oracle

Intercepter les erreurs non prédéfinies
du serveur Oracle
Vous pouvez associer un code erreur Oracle à vos propres variables exception à l'aide du mot
clé PRAGMA EXCEPTION_INIT, dans le cadre de la section déclarative de la façon
suivante :
Nom_exception EXCEPTION ;
PRAGMA EXCEPTION_INIT ( nom_exception, -code_error_oracle);
Exemple :
Lorsque l'on tente d'insérer plus de caractères dans une variable que sa déclaration ne le permet
pas Oracle déclenche
• une erreur -6502. Nous allons "nommer" cette erreur en trop_long et l'intercepter dans la
section exception

Exemple
Declare
trop_long exception ;
pragma exception_init( trop_long, -6502 ) ;
Begin
Chaine := 'environnement' ;
Exception
when trop_long then
dbms_output.put_line( 'Chaîne de caractères trop longue') ;
End ;
/

Fonctions d’interception des exceptions
• SQLCODE : renvoie la valeur numérique du code d’erreur
• SQLERRM : renvoie le message d’erreur associé au code d’erreur
Exemple :
Declare
Begin
Chaine := ‘ departement finance ’ ;
Exception
when others then
dbms_output.put_line( 'Code erreur : ' || to_char( SQLCODE )) ;
dbms_output.put_line( 'libellé erreur : ' || to_char( SQLERRM )) ;
End ;
/

Fonctions d’interception des exceptions
Exemple : insérer une valeur nulle dans la table test .
Declare
insert_excep exception;
pragma exception_init (insert_excep ,-01400);
BEGIN
INSERT into test1 (id,sal) values (1 ,null);
exception
when insert_excep then
DBMS_OUTPUT.PUT_LINE(‘ message : || insertion refusée');
DBMS_OUTPUT.PUT_LINE( ‘code message : ‘ || SQLERRM);
DBMS_OUTPUT.PUT_LINE(‘code erreur : ’ || SQLCODE);
END;
/
Rq : on constate que l’insertion est refusée car on a posé une exception

Exception définie par l’utilisateur
• L’exception définie par l’utilisateur est aussi appelée personnaliser les exceptions.

Exception définie par l’utilisateur
Syntaxe :

Exemples
Définir une execption personalisée en plus des exceptions prédéfinies, Il est possible de
définir sa propre exception :
DECLARE
x NUMBER := 20;
MonException EXCEPTION;
BEGIN
IF x = 20 THEN
RAISE MonException;
END IF;
EXCEPTION
WHEN MonException THEN
raise_application_error(-20101, ‘pas de sens.');
WHEN OTHERS THEN
raise_application_error(-20101, ‘Erreur generique');
END;
/

Procédure RAISE_APPLICATION_ERROR
Syntaxe :
On peut utiliser cette procédure pour générer des messages d’erreur définis par l’utilisateur à
partir de sous-programmes stockés
Elle permet de signaler les erreurs à l’applications et d’éviter le renvoie d’exceptions non
traitées
• Permet de définir une erreur (numéro [entre -20000 et -20999] et texte du message) dans un
bloc PL/SQL.
• Utilisable dans les sections de code d’un bloc PL/SQL.
– dans la section Exécution
– dans la section Exception
• La génération de l’erreur est conforment au standard du serveur et est traitable comme telle.

Exemples
DECLARE
v_lname varchar2(15);
MonException EXCEPTION;
BEGIN
RAISE MonException;
select nom into v_lname from test where libelle='cadre';
IF SQL%NOTFOUND THEN raise MonException;
END IF;
EXCEPTION
WHEN MonException THEN
raise_application_error( -20999, 'aucune valeur trouvée ');
END;
/

Procédures et Fonctions
 Blocs PL/SQL nommés
 Appelés sous-programmes PL/SQL
 Présentent des structures de blocs semblables à celles des blocs anonymes
 Section déclarative facultative (sans le mot-clé DECLARE)
 Section exécutable obligatoire
 Section facultative de traitement des exceptions

Procédures & Fonctions stockées
Une procédure est un ensemble de code PL/SQL nommé, défini par l'utilisateur et
généralement stocké dans la BDD Une fonction est identique à une procédure à la différence
qu'elle retourne une valeur Un paquetage est le regroupement de plusieurs procédures et
fonctions dans un objet distinct Ces ensembles nommés sont stockés dans la base de données,
offrant les avantages suivants : Le code relatif aux règles de gestion est centralisé. Cela
permet de dissocier les fonctions au sein d'une équipe La partie traitement des règles de
gestion est confiée à une partie de l'équipe et la conception des interfaces est confiée à l'autre
partie Ces traitements stockés sont donc déportés des interfaces clientes, permettant le partage
du code entre plusieurs applications ainsi qu'une amélioration des performances, car le code
stocké est pré-compilé Ces traitements sont accessibles par toute application tierce supportant
l'appel des procédures stockées (Sql*Plus, Forms, Reports, Pro*C, Pro*Cobol, etc.)
Cela permet également de tirer parti de la réutilisation des requêtes dans la base qui se
trouvent dans le pool partagé de la zone SGA(System Global Area)

Procédures stockées (1)
• De plus, les procédures sont stockées dans le cache mémoire de la base de données sous
forme compilée lors de leur première exécution, ce qui accroît les performances pour
les exécutions suivantes.
• Une procédure stockée peut être définie comme une suite d’instructions PL/SQL,
stockée dans la base de données et identifié par son nom.
• Pour permettre à cette suite d’instructions de s’adapter au plus grand nombre de cas,
certaines valeurs du code sont paramétrables lors de l’appel de la procédure.

Avantages des procédures stockées
Les procédures stockées offrent de nombreux avantages :
1) Performance
• Chaque fois qu’une requête PL/SQL est exécutée, le serveur détermine si la syntaxe est
correcte puis il construit un plan d’exécution avant d’exécuter la requête.
• Les procédures stockées sont plus performantes parce que le serveur vérifie la syntaxe à la
création. La première fois que la procédure stockée est exécutée, le serveur créé le plan
d’exécution et compile la procédure. Les exécutions ultérieures de cette procédure stockée
seront plus rapides parce que le serveur ne fera pas de nouvelles vérifications sur la
syntaxe et la construction du plan d’exécution ;
2) Réutilisabilité
• Une fois que la procédure stockée est créée, vous pouvez l’appeler à n’importe quel
moment. Ceci permet une modularité et encourage la réutilisation de votre code ;

Avantages des procédures stockées
3) Simplification
• Elles peuvent partager une logique d'application avec d'autres applications, contribuant ainsi
à garantir la cohérence des accès aux données et de leurs modifications.
• Elles peuvent encapsuler une fonctionnalité d'entreprise. Les règles et politiques de
fonctionnement encapsulées dans les procédures stockées peuvent être modifiées au même
endroit.
• Tous les clients peuvent utiliser les mêmes procédures stockées afin de garantir la cohérence
des accès aux données et de leurs modifications ;
4) Accès Réseau
• Elles contribuent à la réduction du trafic sur le réseau. Au lieu d'envoyer des centaines
d'instructions PL/SQL sur le réseau, les utilisateurs peuvent effectuer une opération
complexe à l'aide d'une seule instruction, réduisant ainsi le nombre de demandes échangées
entre le client et le serveur

Création d’une procédure
La création d’une procédure stockée se fait par l’instruction CREATE PROCEDURE.
La syntaxe de l’instruction CREATE PROCEDURE est la suivante :
CREATE [OR REPLACE] PROCEDURE nom_procédure
[ (paramètre [,paramètre]) ]
IS
[<Section déclaration des variables>]
BEGIN
<CODE PL/SQL>
[EXCEPTION
<Section gestion des exceptions>]
END [nom_procédure];

Appel & suppression de procédures
Appel d’une procédure ;
Les procédures stockées peuvent être exécutées par simple appel de leur nom ou par
l’instruction EXECUTE.
EXECUTE Nom_procédure;
Ex: appel de la procédure maj
Execute maj;
Suppréssion d’une procédure on met le mot clé :
DROP PROCEDURE nom_ Procédure ;
Ex: suppression de la procédure maj
Drop procédure maj;

Exemple de procédures
Écrire une procédure qui permet d’augmenter le salaire de tous les employés à 0.100;
CREATE PROCEDURE MAJ IS
BEGIN
UPDATE TEST SET SAL=SAL*0.100 ;
END;
/
Ex : Execute Maj;

modification de procédures
La modification d’une procédure stockée se fait par l’instruction REPLACE
PROCEDURE
Exemple : Écrire une procédure qui permet d’augmenter le salaire de tous les employés à
0.100;
CREATE OR REPLACE PROCEDURE MAJ IS
BEGIN
UPDATE TEST SET SAL=SAL*0.100 ;
END;
/

Recompiler une procédure
• Une procédure peut devenir invalide. Par exemple si elle est basée sur une table dont la
structure a changé.
• Il est possible dans ce cas de recompiler une procédure avec la commande ALTER
PROCEDURE RECOMPILE :
ALTER PROCEDURE nom_procédure compile;

Exemples de procédures
Exemple : écrire une procédure qui calcule la somme de deux entiers .

Procédures paramétrées
1) Déclaration des arguments
Syntaxe
<nom_argument> [ { IN | OUT | IN OUT } ] [ NOCOPY ] TYPE [ , . . . ]
IN indique que le paramètre transmis par le programme appelant n'est pas modifiable par la
fonction
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
fonction
NOCOPY indique que le paramètre est transmis par référence (pointeur) et non par copie de
la valeur
TYPE représente le type SQL ou PL/SQL du paramètre
:= représente le symbole d'assignation d'une valeur par défaut
DEFAULT identique à :=

Exemples de procédures paramétrées
Exemple :
CREATE OR REPLACE PROCEDURE Augmentation(Num IN test.id%Type, Pourcent
IN NUMBER) IS
BEGIN
Update test Set sal = sal * Pourcent
Where id= Num ;
END;
/
La procédure Augmentation reçoit deux paramètres
Num en entrée (IN) de même type que la colonne empno de la table test qui reçoit le numéro
d’identifiant.
Pourcent en entrée (IN) de type NUMBER qui reçoit le pourcentage d'augmentation

Lorsqu'un paramètre est passé en mode OUT, la procédure peut le modifier.
Le programme appelant doit avoir défini une variable correspondante dans sa section déclarative
Exemple :
CREATE OR REPLACE PROCEDURE Test_Augmentation
(Num IN test.id%Type , Pourcent IN OUT NUMBER ) IS
Salaire test.sal%Type ;
BEGIN
Select sal Into Salaire From test Where id = Num ;
Pourcent := Salaire * Pourcent ;
END;
/

Appel de la procédure
Declare
Pourcent NUMBER := 2;
Begin
Test_Augmentation( 1, Pourcent ) ;
dbms_output.put_line( 'identifiant 1 après augmentation : ' ||
To_char( Pourcent ) ) ;
End ;
/

Exemples : Écrire une procédure qui calcul le montant à payer sachant le prix et la quantité.
create or replace Procedure montant
(prix in number , quantite in number, resultat out number) IS
BEGIN
resultat := prix * quantite;
end;
/
Appel de la procédure
declare
resultat number;
begin
Montant (200 , 2,resultat);
DBMS_OUTPUT.PUT_LINE('Montant = ' || TO_CHAR(resultat));
end;
/

FONCTIONS STOCKEES
Une fonction est identique à une procédure à la différence qu'elle retourne obligatoirement une
valeur d'où le mot clé obligatoire RETURN .
CREATE indique que l'on veut créer une fonction stockée dans la base
La clause facultative OR REPLACE permet d'écraser une fonction existante portant le même
nom nom fonction est le nom donné par l'utilisateur à la fonction
AUTHID indique sur quel schéma la fonction s'applique :
• CURRENT_USER
Indique que la fonction utilise les objets du schéma de l'utilisateur qui appelle la fonction
• DEFINER(défaut) Indique que la fonction utilise les objets du schéma de création de la
fonction

Fonctions
Elle est identique à une procédure à la différence qu'elle retourne une valeur stockée dans la
base de données sous format compilé peut aussi recevoir des arguments (paramètres)
Syntaxe :
CREATE FUNCTION nom (arg1 IN type1, arg2 OUT type2, arg3 IN OUT
type3, . . .)
RETURN type IS variable4
type4 ;
...
BEGIN
...
RETURN valeur ;
END ;
/

Exemples
Ex : créer une fonction d’addition qui calcule la somme de deux entiers
CREATE FUNCTION addition
( val1 number , val2 number)
return number
IS
Somme number;
BEGIN
Somme := val1 + val2 ;
return (Somme);
END;
/

Exemples
Exemple: Écrire une fonction factorielle qui permet de calculer un nombre entier
CREATE FUNCTION fact ( Val NUMBER)
RETURN NUMBER IS
BEGIN
IF Val = 0 THEN RETURN 1;
ELSE
RETURN Val * fact(Val – 1);
END IF;
END;
/

Appel d’une fonction
Une fonction s’utilise comme une procédure stockée, mais aussi comme une table.
L’appel d’une fonction peut se faire avec l’instruction SELECT :
Syntaxes
En PL/SQL
BEGIN
<nom_variable> := <nom_fonction>[ (<argument1>, . . . ] ) ] ;
END;
SELECT <nom_fonction>[ (<argument1>, . . . ] ) ] from dual ;
Exemple :
Select addition (12 ,13) from dual ;
Select fact(5) from dual;

Suppression d’une fonction
Syntaxe
• DROP FONCTION <nom_fonction> ;
Exemple : supprimer la fonction d’addition
DROP FUNCTION ADDITION;

Fonction paramétrée
1) Déclaration des arguments
Syntaxe :
<nom_argument> [ { IN | OUT | IN OUT } ] [ NOCOPY ] TYPE [ , . . . ]
IN indique que le paramètre transmis par le programme appelant n'est pas modifiable par la
fonction
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 fonction
NOCOPY indique que le paramètre est transmis par référence (pointeur) et non par copie de
la valeur
TYPE représente le type SQL ou PL/SQL du paramètre
:= représente le symbole d'assignation d'une valeur par défaut
DEFAULT identique à :=

Exemples
CREATE OR REPLACE Function augmentation_test
(Num IN test.id%Type , Pourcent IN NUMBER )
RETURN NUMBER
IS
Salaire test.sal%Type ;
BEGIN
Select sal Into Salaire From test Where id = num;
Salaire := Salaire * Pourcent ;
RETURN (salaire);
END;
/
Ex:
Select augmentation_test (1,1.1) from dual ;

Exemples
Ex : appel de la fonction
Declare
salaire test.sal%type;
Begin
select sal into salaire from test where id=1;
To_char( salaire ) ) ;
To_char( augmentation_test(1, 1.1)) ) ;
END;
/

TRIGGERS LMD ORACLE
1)Définitions
Les déclencheurs ou triggers servent à étendre les mécanismes de gestion de l'intégrité à des contraintes
complexes et permettre le contrôle de saisie. Il s'agit de code déclenché lors de certains événements de la
base de données. Un déclencheur est toujours rattaché à une table ou à une vue. Il s'agit de code
déclenché lors de certains événements de la base de données. Un trigger est toujours rattaché à une table.
Les événements qui déclenchent un trigger sont :
 L'insertion de données (INSERT)
 La suppression de données (DELETE)
 La mise à jour (UPDATE)
. Les ordres SQL (SELECT, INSERT, UPDATE, DELETE) contenus dans le bloc PL/SQL et qui se
référent à la table sur laquelle s'exécute le déclencheur peuvent générer l'exception ORA-04091
Il ne peut donc pas contenir d'instruction COMMIT ou ROLLBACK ou toute instruction générant une fin
de transaction implicite (ordre DDL).

Déclencheurs sur table
Seules les colonnes de la ligne en cours de modification sont accessibles par l'intermédiaire de 2 variables
de type enregistrement OLD et NEW.
OLD représente la valeur avant modification
OLD n'est renseignée que pour les ordres DELETE et UPDATE. Elle n'a aucune signification pour un
ordre INSERT, puisqu'aucune ancienne valeur n'existe.
NEW représente la nouvelle valeur NEW n'est renseignée que pour les ordres INSERT et UPDATE. Elle
n'a aucune signification pour un ordre DELETE, puisqu'aucune nouvelle valeur n'existe.
Ces deux variables peuvent être utilisées dans la clause WHEN du déclencheur et dans la section
exécutable.
Dans cette section, elle doivent être préfixées comme des variables hôtes avec l'opérateur :
Les noms de ces deux variables sont fixés par défaut, mais il est possible de les modifier en précisant les
nouveaux noms dans la clause REFERENCING
REFERENCING OLD AS nouveau_nom NEW AS nouveau_nom

Déclaration de triggers LMD
Syntaxe:
CREATE OR REPLACE TRIGGER <nom_trigger>
AFTER | BEFORE INSERT or UPDATE or DELETE - -----------LMD
ON <nom_table> ------------ sur la table
FOR EACH ROW ----------pour chaque ligne
DECLARE
<Section déclaration des variables>
BEGIN
<Code de la logique du trigger>
EXCEPTION
<Gestion des exceptions>
END < nom_trigger >
/

Déclaration de triggers LMD
AFTER
Indique que le déclencheur est déclenché uniquement lorsque toutes les opérations spécifiées dans l'instruction SQL
de déclenchement ont été exécutées avec succès. Toutes les actions d'intégrité référentielle en cascade et les
vérifications de contrainte doivent aussi réussir pour que ce déclencheur puisse s'exécuter. AFTER est la valeur par
défaut, si FOR est le seul mot-clé spécifié. Les déclencheurs AFTER ne peuvent pas être définis sur des vues.
{ [DELETE] [,] [INSERT] [,] [UPDATE] }
Mots clés qui spécifient les instructions de modification des données qui, lorsqu'elles sont exécutées sur cette table
ou vue, activent le déclencheur. Vous devez spécifier au moins une option. Vous pouvez combiner toutes les options
dans n'importe quel ordre dans la définition du déclencheur. Si plusieurs options sont spécifiées, séparez-les par des
virgules.
Emplois typiques :
 suppression, insertion et mise à jour en cascade
 contrôle de validité
 respect d’intégrité complexe
 formatage de données
 archivage automatique

Exemples d’utilisation de triggers
Exemple : On va créer une table Employes.
CREATE TABLE employes
( no_emp number (4) PRIMARY KEY,
prenom_emp varchar2 (20),
nom_emp varchar2 (20),
fonction varchar2 ( 20),
salaire number(5),
embauche date,
naissance date,
pays varchar2(20)
);

Exemples d’utilisation de triggers
Exemple : On va créer une nouvelle table EMPAudit pour stocker les informations d’audit sur la
table Employes.
CREATE TABLE EmpAudit
( no_emp number (4) PRIMARY KEY,
prenom_emp varchar2 (20),
nom_emp varchar2 (20),
fonction varchar2 ( 20),
salaire number (5),
embauche date,
naissance date,
pays varchar2(20),
date_audit date,
type_operation varchar2(20)
);
Pour que le trigger se déclenche, on va insérer un nouvel employé dans la table EMPLOYES.

Trigger AFTER INSERT
Exemple : On va créer un trigger qui va se déclencher après chaque ligne insérer dans la table Employes. Le
trigger va insérer la même ligne dans la table EMPAudit.
CREATE OR REPLACE TRIGGER testAuditer
AFTER
INSERT ON EMPLOYES
FOR EACH ROW
BEGIN
INSERT INTO EMPAUDIT VALUES
( :NEW.NO_EMP,
:NEW.PRENOM_EMP,
:NEW.NOM_EMP,
:NEW.FONCTION,
:NEW.SALAIRE,
:NEW.EMBAUCHE,
:NEW.NAISSANCE,
:NEW.PAYS,
SYSDATE,
'INSERT');
END;
/

Exemple de trigger de suppression
TRIGGER BEFORE DELETE
EXEMPLE
Créer un trigger qui empêche la suppression d’un employé de la table EMPLOYES:
CREATE OR REPLACE TRIGGER EMPLOYE_DELETE
BEFORE DELETE ON EMPLOYES
FOR EACH ROW
BEGIN
RAISE_APPLICATION_ERROR (-20002, 'pas permission de supprimer un
employé');
END;
/

Exemple
Trigger BEFORE DELETE
Ex: Créons un déclencheur très basique qui ne fait qu'afficher le numéro et le nom d'un
employé que l'on veut supprimer de la table
CREATE OR REPLACE TRIGGER TRG_BDR_EMP
BEFORE DELETE -- avant supression
ON EMPLOYES -- sur la table employes
FOR EACH ROW -- pour chaque ligne
Declare
Chaine VARCHAR2(100);
Begin
dbms_output.put_line( 'Suppression de l''employee n° ' || To_char( :OLD.NO_EMP )
|| ' -> ' || :OLD.NOM_EMP ) ;
End ;
/
Tester : delete employes;

Exemple de trigger d’insertion
TRIGGER BEFORE INSERT
Exemple : désormais, tout nouvel employé devra avoir un numéro supérieur ou égal à 10000. Il faut donc
interdire toute insertion qui ne reflète pas cette nouvelle directive
CREATE OR REPLACE TRIGGER TRG_BIR_EMP
BEFORE INSERT -- avant insertion
ON EMPLOYES -- sur la table EMPLOYES
FOR EACH ROW -- pour chaque ligne
Begin
If :NEW.no_emp < 10000 Then
RAISE_APPLICATION_ERROR ( -20010, 'Numéro employé inférieur à 10000' ) ;
End if ;
End ;
/
RQ:
Si on insert dans la table emp le déclencheur execute le script pour refuser l’insertion car le numéro
employé doit étre supérieur à 10000.

Trigger de Modification
Fonction UPDATING : permet de tester si une colonne est visée par un changement de valeur.
IF [NOT] UPDATING(<colonne>) THEN <traitement>
END IF
Trigger BEFORE UPDATE
Exemple : Interdire la mise à jour du salaire sur la table Employes :
CREATE OR REPLACE TRIGGER employes_MAJ_SAL
BEFORE UPDATE ON EMPLOYES
BEGIN
IF UPDATING('SALAIRE') THEN
RAISE_APPLICATION_ERROR (-20002, 'pas touche au salaire');
END IF;
END;
/

Trigger de modification et suppression &insert
On peut combiner la modification et l’insertion ou la suppression avec l’option OR qu’on doit
mettre au niveau de la partie déclarative des instructions LMD .
Exemple :
Créer un trigger qui empêche la modification , la suppression d’un employé
CREATE OR REPLACE TRIGGER pasDELETUPDATEINSERT
BEFORE DELETE or UPDATE or INSERT ON emp
BEGIN
RAISE_APPLICATION_ERROR (20555 , ‘désolé pas possible ' ) ;
END;
/

Suppression ,modification,recompiler un trigger
Supprimer Trigger on utilise :
Syntaxe :
DROP TRIGGER NOM_TRIGGER;
Exemple : supprimer le trigger ou déclencheur de employes_delete
DROP TRIGGER EMPLOYES_DELETE ;
Modification Trigger
Syntaxe :
l’option REPLACE
Exemple :
CREATE OR REPLACE TRIGGER EMPLOYE _DELETE
Recompiler Trigger
Avec l’option ALTER TRIGGER NOM_TRIGGER
Exemple :
ALTER TRIGGER EMPLOYES_MAJ_SAL

SQL FUNDEMENTALS SQL ORACLE PREMIER NIVEAU

Contenu connexe

Similaire à SQL FUNDEMENTALS SQL ORACLE PREMIER NIVEAU (20)

Plus de LuneSabsPericolo1 (20)

SQL FUNDEMENTALS SQL ORACLE PREMIER NIVEAU