Plan du cours – Partie 1

 Langage plSQL
 Extension du langage (Environnement Client-Serveur)
 Gestion des vues
 Gestion des procédures stockées
 Gestion des déclencheurs (Triggers)
 Gestion des transactions

02/02/2023 1
 Plan du cours – Partie 2

 Installation et configuration d’un serveur SQL

(Pratique)
 Gestion des utilisateurs
 Stratégie de Sauvegarde et de restauration
 Importation et exportation des données

02/02/2023 2
 PL/SQL

• Pourquoi PL/SQL?
• Variables, structures de contrôle,
• Curseurs, interaction avec la base,
• Sous-programmes, paquetages,
• Exceptions,
• Déclencheurs (triggers)

02/02/2023 3
 Procédural Language/SQL
• PL/SQL est un langage procédural qui intègre des
ordres SQL,
• Initialement typiquement Oracle ; apparaît dans la
norme SQL3,
• Il permet l’utilisation des blocs SQL et d’exprimer
des règles de gestion complexes sous forme de
procédures stockées et de triggers,
• Il permet de lier plusieurs requêtes SQL avec des
variables et dans des structures de programmation
habituelles.

02/02/2023 4
 Procédural Language/SQL
• Programme PL/SQL = bloc (procédure
anonyme, procédure nommée, fonction
nommée) :
• PL/SQL n’interprète pas une commande, mais
un ensemble de commandes contenues dans un
bloc PL/SQL. Ce bloc peut comporter plusieurs
sous blocs,

02/02/2023 5
 Procédural Language/SQL

02/02/2023 6
 Structure d’un bloc PL/SQL
DECLARE
-- section de déclarations
-- section optionnelle …
BEGIN
-- traitement, avec d’éventuelles directives SQL
-- section obligatoire …
EXCEPTION
-- gestion des erreurs
-- section optionnelle …
END;

02/02/2023 7
 Blocs imbriqués
-- BLOC A
DECLARE
BEGIN
-- BLOC B
DECLARE
BEGIN
-- BLOC C
DECLARE
BEGIN
EXCEPTION
END;
EXCEPTION
END;
EXCEPTION
END;

02/02/2023 8
 Les variables PL/SQL
Types de variables PL/SQL :

• Scalaires : par exemple NUMBER (5,2), VARCHAR2,

DATE, BOOLEAN, CHAR, <Attribut>%TYPE…
• Composites : %ROWTYPE, RECORD, TABLE

Remarques :

• Jusqu’à 30 caractères,
• Insensible à la casse ! ,

02/02/2023 9
 Les variables PL/SQL

• On peut documenter un code PL/SQL. Les différentes

façons d’introduire des commentaires :
– -- Commentaire sur une seule ligne
– /* Commentaire sur plusieurs
lignes */
• Toute variable PL/SQL doit obligatoirement être déclarée
avant utilisation. Cette déclaration s’effectue dans la
zone DECLRAE.

02/02/2023 10
 Les variables PL/SQL
nomvariable [CONSTANT]
{type | variable%TYPE | table.%ROWTYPE }
[NOT NULL]
[{:= | DEFAULT } expression PL/SQL]

Exemples de déclaration :
vNumCli NUMBER(5) ;
vNomCli VARCHAR2(12) ;
vDateCde DATE ;
vPoids NUMBER(5,2) ;
vSexe CHAR(1) ;

02/02/2023 11
 Les variables PL/SQL
vNomClient clients.clinom%TYPE;
vAdresseClient clients.cliadr%TYPE;

Déclaration %ROWTYPE

PL/SQL permet de déclarer une variable composite de

même type que les tuples d’une table.
vLignesClients clients%ROWTYPE;
Les composantes de la variable composite, identifiées par
vLignesClients.nomColonne, sont du même type que les
colonnes correspondantes de la table.

02/02/2023 12
 Affectation des valeurs aux variables PL/SQL
On peut affecter des valeurs aux variables PL/SQL soit :
• En utilisant l’opérateur d’assignation :=
vAge := SYSDATE – vDateNaissance ;
vNomClient := UPPER ('Nom') ;
• A partir d’un ordre SELECT
…
SELECT clinom, cliadresse
INTO vNom, vAdresse
FROM clients
WHERE clinum = 1200 ;
…

02/02/2023 13
 Affectation des valeurs aux variables PL/SQL
Remarque:

L’ordre SELECT doit retourner une seule ligne, dans le cas

contraire une erreur est générée.

02/02/2023 14
 Les Collections et les enregistrements
• Une collection est un ensemble ordonné d'éléments de même type.
• Elle est indexée par une valeur de type numérique ou
alphanumérique
• Un enregistrement est composé de champs qui peuvent être de type
différents. Il est similaire à une structure C.

Variables RECORD

Alors que la directive %ROWTYPE permet de déclarer une structure

composée de colonnes de tables, elle ne convient pas à des structures
de données personnalisées.

02/02/2023 15
 Les Collections et les enregistrements
• La syntaxe générale pour déclarer un RECORD est la suivante

TYPE nomRecord IS RECORD ( nomChamp typeDonnées [[NOT NULL] {:= |

DEFAULT} expression] [,nomChamp typeDonnées… ]… );
L’exemple suivant décrit l’utilisation d’un record
DECLARE
--Déclaration du RECORD contenant trois champs ; initialisation du champ job
par défaut.
TYPE emp_rec IS RECORD (
numEmp NUMBER(5),
nomEmp VARCHAR2(12),
foncEmp VARCHAR2(125) := ‘ANALYST',
);

02/02/2023 16
 Les Collections et les enregistrements

--Déclaration de deux variables de type RECORD.

rec1_emp emp_rec;
rec2_emp emp_rec;

BEGIN
--Initialisation des champs d’un RECORD.
rec1_emp.empno := 7788;
rec1_emp.ename := ‘SCOTT';
--Affectation d’un RECORD.
rec2_emp := rec1_emp;
END;

02/02/2023 17
 Les Collections et les enregistrements

Variables tableaux (type TABLE)

• Taille dynamique
• Déclaration d'une collection de type index by
TYPE nom type IS TABLE OF type élément [NOT NULL] INDEX BY
index_by_type ;

index_by_type représente l'un des types suivants :

BINARY_INTEGER
PLS_INTEGER(9i)
VARCHAR2(taille)
LONG

02/02/2023 18
 Les Collections et les enregistrements
• Exemple d’un tableau de type TABLE
DECLARE
-- collection de type index by
TYPE TAB_ENT IS TABLE OF NUMBER INDEX BY BINARY_INTEGER ;
tab TAB_ENT ;
BEGIN
FOR I IN 1..100 LOOP
tab (I):= I;
DBMS_OUTPUT.PUT_LINE(tab(I));
END LOOP ;
END;
/

02/02/2023 19
 Les Collections et les enregistrements
Les collections de type VARRAY

• Ce type de collection possède une dimension maximale qui doit être

précisée lors de sa déclaration.
• Elle possède une longueur fixe et ses éléments sont numérotés à partir de
la valeur 1

Déclaration d'une collection de type VARRAY

TYPE nom type IS VARRAY (taille maximum) OF type élément [NOT

NULL] ;

02/02/2023 20
 Les Collections et les enregistrements
Exemple d’un tableau de type VARRAY

DECLARE
TYPE TAB_VAR IS VARRAY(30) OF VARCHAR2(100) ;
tab TAB_VAR := TAB_VAR('','','','','','','','','','');
BEGIN
FOR I IN 1..10 LOOP
tab(I):= TO_CHAR(I) ;
DBMS_OUTPUT.PUT_LINE(tab(I));
END LOOP ;
END;
/

02/02/2023 21
 Les Collections et les enregistrements
• Fonctions pour les tableaux
• PL/SQL propose un ensemble de fonctions qui permettent de manipuler des
tableaux (également disponibles pour les nested tables et varrays). Ces
fonctions sont les suivantes (les trois dernières sont des procédures) :
•
• EXISTS(x) Retourne TRUE si le xe élément du tableau existe.
• COUNT Retourne le nombre d’éléments du tableau.
• FIRST / LAST Retourne le premier/dernier indice du tableau (NULL
si tableau vide).
• PRIOR(x) / NEXT(x) Retourne l’élément avant/après le xe élément du
tableau.
• DELETE Supprime un ou plusieurs éléments au tableau.
• DELETE(x)
• DELETE(x,y)

02/02/2023 22
 Structures de contrôle
1. Traitement conditionnel
Syntaxe
IF condition_1 THEN
Instructions_1;
ELSIF condition_2
Instructions_2;
ELSE
Instructions_3;
END IF;
Les opérateurs relationnels sont: =, <, >, !=, >=, <=, IS NULL, IS NOT
NULL, BETWEEN, LIKE, AND, OR

02/02/2023 23
 Structures de contrôle
Le switch du langage C s’implémente en PL/SQL de la façon suivante :
CASE /∗ variable ∗/
WHEN /∗ valeur 1 ∗/ THEN
/∗ instructions 1
WHEN /∗ valeur 2 ∗/ THEN
instructions 2
WHEN /∗ valeur n ∗/ THEN
/∗ instructions n ∗/
ELSE
/∗ instructions par défaut ∗/
END CASE;

02/02/2023 24
 Structures répétitives
La boucle de base
PL/SQL permet d’effectuer des traitements répétitifs grâce
à la clause LOOP.

BEGIN
…
LOOP
Instructions
END LOOP;
…
END;

02/02/2023 25
 Affectation des valeurs aux variables PL/SQL
Remarque :
La boucle ci-dessus s’exécute indéfiniment,
l’instruction EXIT permet de stopper l’exécution de
la boucle LOOP.
BEGIN BEGIN
… …
LOOP LOOP
Instructions Instructions
EXIT WHEN condition; IF condition THEN
END LOOP; EXIT;
… END IF;
END; END LOOP;
…
END;

02/02/2023 26
 Structures répétitives

La boucle FOR : La boucle WHILE :

Syntaxe Syntaxe

FOR compteur IN WHILE condition

val_1..val_2 LOOP
LOOP instructions;
instructions; END LOOP;
END LOOP;

02/02/2023 27
 Curseurs
Un curseur est une zone mémoire de taille fixe capable de
stocker plusieurs enregistrements et de gérer l’accès à ces
enregistrements.

Types de curseurs :

– Curseurs implicites :
Déclarés implicitement et manipulés par SQL pour toute
requête SQL et pour les interrogations qui retournent un
seul enregistrement

02/02/2023 28
 Curseurs
– Curseurs explicites :
Déclarés et manipulés par l’utilisateur pour les
interrogations qui retournent plus d’un enregistrement.

Etapes d’utilisation d’un curseur :

– Déclaration
– Ouverture
– Traitement des lignes
– Fermeture

02/02/2023 29
 Déclaration d’un curseur
Syntaxe :
CURSOR nom_curseur IS requête ;

Cette déclaration se fait dans la section DECLARE.

Exemple :
DECLARE
CURSOR c_clients IS
SELECT clinum, clinom, cliadresse
FROM clients;
BEGIN
…
END;

02/02/2023 30
 Déclaration d’un curseur
L’ensemble de lignes renvoyées par une interrogation multi lignes
s’appelle un ResultSet (jeu de résultats).

ResultSet
1100 VAUDAN 31, Rue Tanger 75015 Paris
curseur
1200 HOMEYER 1, Av Foch 67000 Strasbourg
1300 BUELLET 27, Rue Pierre Avia 75015 Paris

02/02/2023 31
 Ouverture d’un curseur
Elle permet :
• L’allocation mémoire du curseur,
• L’analyse syntaxique et sémantique de la requête,

Elle se fait dans la section BEGIN.

Syntaxe :
OPEN c_clients ;

02/02/2023 32
 Ouverture d’un curseur
Exemple :

DECLARE
CURSOR c_clients IS
SELECT clinum, clinom, cliadresse
FROM clients;
BEGIN
OPEN c_clients;
…
END;

02/02/2023 33
 Traitement des lignes
Les lignes retournées par l’ordre SELECT sont traitées une
par une. La valeur de chaque colonne doit être stockée
dans une variable réceptrice.
Syntaxe :
FETCH c_salaries INTO variables_receptrices ;

La clause FETCH ne récupère qu’un seul enregistrement.

Pour accéder à l’ensemble des lignes de l’ordre SELECT, il
faut prévoir une boucle.
Le traitement des lignes se fait dans le corps du bloc
PL/SQL.

02/02/2023 34
 Exemple d’utilisation d’un curseur
DECLARE IF vSalaire < 1000 THEN
UPDATE emp
vNumero empno.emp%TYPE;
SET sal = sal*1.1
vSalaire sal.emp%TYPE; WHERE empno = vNumero;
-- Déclaration du curseur ELSIF vSalaire BETWEEN 1000 AND 3000
CURSOR c_emp IS THEN
UPDATE emp
SELECT empno, sal
SET sal = sal*1.05
FROM emp WHERE sal = vNumero;
ORDER BY sal; ELSE
BEGIN UPDATE emp
SET comm = comm + 300
OPEN c_emp;
WHERE sal = vNumero;
LOOP END IF;
FETCH c_emp INTO vNumero, vSalaire; EXIT WHEN vSalaire > 3000
END LOOP;
CLOSE c_emp;
END;

02/02/2023 35
 Fermeture d’un curseur
Syntaxe :
CLOSE c_emp;
Libération de la place mémoire allouée.

Attributs d’un curseur:

Les attributs permettent de connaître l’état d’un curseur.
%FOUND et %NOTFOUND déterminent si toutes les
lignes retournées par le curseur ont étés traitées.
%ISOPEN précise si le curseur est ouvert.
%ROWCOUNT indique le nombre de lignes déjà traitées.

02/02/2023 36
 Curseurs explicites paramétrés
Objectif : paramétrer la requête associée à un curseur pour éviter
de multiplier les curseurs similaires dans le même bloc PL/SQL.

Syntaxe :

CURSOR nom_curseur (param1 type1, param2 type2, …]) IS …;

Les valeurs des paramètres sont transmises à l’ouverture du

curseur :

OPEN nom_curseur (valeurPar1, valeurPar2, …);

Il faut évidemment fermer le curseur avant de l’appeler avec

d’autres valeurs pour les paramètres.

02/02/2023 37
 Simplification d’écriture des curseurs : Exemple
DECLARE UPDATE emp
CURSOR c_emp IS SET sal = sal*1.1
SELECT empno, sal WHERE empno = enreg_emp.empno;
FROM emp ELSIF enreg_emp.salBETWEEN 1000 AND
ORDER BY sal; 3000 THEN
--Déclaration d’une structure UPDATE emp
enreg_emp c_emp%ROWTYPE; SET sal = sal*1.05
BEGIN WHERE empno = enreg_emp.empno;
OPEN c_emp; END IF;
LOOP EXIT WHEN c_emp%NOTFOUND ;
FETCH c_emp INTO enreg_emp; END LOOP;
IF enreg_emp.sal < 1000 THEN CLOSE c_emp;
END;

02/02/2023 38
 Simplification d’écriture des curseurs : Exemple
DECLARE
BEGIN
FOR enreg_emp IN ( SELECT empno, sal
FROM emp
ORDER BY sal
)
LOOP
IF enreg_emp.sal < 1000 THEN
UPDATE emp
SET sal = sal*1.1
WHERE empno = enreg_empno.empno;
ELSIF enreg_emp.sal BETWEEN 1000 AND 3000 THEN
UPDATE emp
SET sal = sal*1.05
WHERE empno = enreg_emp.empno;
END IF;
END LOOP;
END;

02/02/2023 39
 Procédures et fonctions
Définition :

Ce sont les sous programmes hébergés par la base de

données : ils peuvent être appelés à partir d’une autre
procédure, fonction ou encore depuis un programme
exécutable extérieur à la base de données.
Un sous programme est un bloc PL/SQL nommé qui peut
accepter des paramètres et être appelé.

02/02/2023 40
 Procédures et fonctions

• Les performances sont assurées par les facteurs suivants :

– Les procédures stockées n’ont pas besoin d'être
analysées une seconde fois à l'exécution (gain de temps :
pas de recompilation ).
– Un gain de place en mémoire contribue à cette
amélioration de performances car la procédure chargée en
mémoire pour son exécution est partagée par tous les
objets qui la demandent (applications) . De plus la
procédure s’exécute immédiatement si elle en mémoire
(réduction des accès disque),
– Réduction du trafic sur le réseau (soumission d'un bloc
PL/SQL au moteur au lieu d'une commande Sql),

02/02/2023 41
 Procédures PL/SQL
Syntaxe :

PROCEDURE laProcedure (param1 IN | OUT | IN type 1, param2…)

IS
BEGIN
…
EXCEPTION
END;
Une procédure se termine à la fin du bloc ou par une instruction
RETURN.

02/02/2023 42
 Fonctions PL/SQL
Syntaxe :

FUNCTION laFonction (param1 IN | OUT | IN type 1, param2…)

RETURN type_variable IS
BEGIN
RETURN variable;
EXCEPTION
END;

Une fonction se termine par l’instruction RETURN qui doit renvoyer un

résultat.

02/02/2023 43
 Procédures et fonctions PL/SQL
Remarque :
Comme tout objet SQL, une procédure ou une fonction
peut être créée, modifiée ou supprimée.

Création CREATE PROCEDURE… CREATE FUNCTION…

Modification CREATE OR REPLACE CREATE OR REPLACE

PROCEDURE… FUNCTION…

Suppression DROP PROCEDURE… DROP FUNCTION…

02/02/2023 44
 Procédures et fonctions PL/SQL
Exécution et utilisation de procédures et de fonctions

SQL> CREATE OR REPLACE FUNCTION leDouble (p_telNombre

IN NUMBER)
RETURN NUMBER IS
le_double NUMBER;
BEGIN
le_double := p_telNombre*2;
RETURN le_double;
END ;
/

02/02/2023 45
 Procédures et fonctions PL/SQL

SQL> DECLARE
v_leNombre NUMBER := 12;
v_ledouble NUMBER;
BEGIN
le_double := leDouble(v_telNombre);
END ;

Remarques :
Pour repérer les erreurs, on dispose de la commande SHOW
ERRORS.
Pour afficher les variables contenues dans un bloc PL/SQL, il faut
inclure le package (définit plus loin) standard dbms_output.put_line.

02/02/2023 46
 Paquetages

Un paquetage PL/SQL permet de regrouper un ensemble

de procédures, de fonctions, de variables et de curseurs au
sein d’un ensemble cohérent de services.

Distinction entre ce qui est accessible depuis l’extérieur et

ce qui n’est accessible qu’à l’intérieur du paquetage :
encapsulation.

02/02/2023 47
 Paquetages

Structure :

– Section de spécification : déclarations des variables,

curseurs, sous-programmes accessibles depuis
l’extérieur,

– Section d’implémentation : code des sous-programmes

accessibles depuis l’extérieur + sous-programmes
accessibles en interne (privés).

02/02/2023 48
 Paquetages
Packages prédéfinis :
Parmi eux, le package DBMS_OUTPUT : affichage pour la
mise au point des programmes PL/SQL. Il est utilisé pour
envoyer des messages contrôlant l’exécution d’un
programme PL/SQL ou en encore lors du débogage.

Exceptions
PL/SQL permet de définir dans une zone particulière (de
gestion d’exception), l’attitude que le programme doit avoir
lorsque certaines erreurs définies ou prédéfinies se
produisent.

02/02/2023 49
 Paquetages

Un certain nombre d’exceptions sont prédéfinies sous

Oracle. Citons, pour les plus fréquentes :
NO_DATA_FOUND (devient vrai dès qu’une requête
renvoie un résultat vide), TOO_MANY_ROWS (requête
renvoie plus de lignes qu’escompté),
CURSOR_ALREADY_OPEN (curseur déjà ouvert),
INVALID_CURSOR (curseur invalide)...

02/02/2023 50
 Paquetages
Le développeur peut définir ses propres exceptions. Dans
ce cas, il doit définir celles ci dans la zone de déclaration.
Exemple :
v_exception EXCEPTION ;
Puis, cette exception est levée quelque part dans le
programme (après un test non concluant, par exemple), par
l’instruction :
RAISE v_exception ;
Enfin, dans la zone d’exception un traitement est affecté à
chaque exception possible (définie ou prédéfinie) :

02/02/2023 51
 Paquetages
EXCEPTION
WHEN <exception1> [OR <exception2> OR ...] THEN
<instructions>
WHEN <exception3> [OR <exception2> OR ...] THEN
<instructions>
WHEN OTHERS THEN <instructions>
END;

Evidemment, un seul traitement d’exception peut se

produire avant la sortie du bloc.

02/02/2023 52
 Les exceptions internes
Une erreur interne est produite quand un bloc PL/SQL viole une
règle d'Oracle ou dépasse une limite dépendant du système
d'exploitation.
Les erreurs Oracle générées par le noyau sont numérotées, or le
gestionnaire des exceptions de PL/SQL, ne sait que gérer des
erreurs nommées.
Pour cela PL/SQL a redéfini quelques erreurs Oracle comme
des exceptions. Ainsi, pour gérer d'autres erreurs Oracle,
l'utilisateur doit utiliser le gestionnaire OTHERS ou
EXCEPTION_INIT pour nommer ces erreurs.
Les exceptions fournies par Oracle sont regroupées dans ce
tableau

02/02/2023 53
 Paquetages
Valeur Sql Erreur Valeur Erreur
Nom d'exception Nom d'exception
Code Oracle Sql Code Oracle

CURSOR_ALREADY_OPEN -6511 ORA-06511 NOT_LOGGED_ON -1012 ORA-01012

DUP_VAL_ON_INDEX -1 ORA-00001 PROGRAM_ERROR -6501 ORA-06501

INVALID_CURSOR -1001 ORA-01001 STORAGE_ERROR -6500 ORA-06500

INVALID_NUMBER -1722 ORA-01722 TIMEOUT_ON_RESOURCE -51 ORA-00051

LOGIN_DENIED -1017 ORA-01717 TOO_MANY_ROWS -1422 ORA-01422

NO_DATA_FOUND -1403 ORA-01413 TRANSACTION_BACKED_OUT -61 ORA-00061

VALUE_ERROR -6502 ORA-06502 ZERO_DIVIDE -1476 ORA-01476

02/02/2023 54
 Paquetages
OTHERS : toutes les autres erreurs non explicitement nommées.
Pour gérer les exceptions, le développeur doit écrire un
gestionnaire des exceptions qui prend le contrôle du
déroulement du bloc PL/SQL en présence d'une exception.

Chaque gestion d'exception consiste à spécifier son nom

d'erreur après la clause WHEN et la séquence de la commande
à exécuter après le mot clé THEN.

02/02/2023 55
 Les déclencheurs (“triggers”)
Les déclencheurs ou ”triggers” sont des séquences d’actions
définis par le programmeur qui se déclenchent, sur des actions
modifiant les données de la table sur laquelle porte le trigger.
Un trigger sera un objet stocké (comme une table ou une
procédure).

Syntaxe :
CREATE [OR REPLACE] TRIGGER <nomTrg>
{BEFORE|AFTER} {INSERT|DELETE|UPDATE} ON <nomTable>
[FOR EACH ROW [WHEN (<condition>)]]
<corps du trigger>

02/02/2023 56
 Les déclencheurs (“triggers”)
Le type d’action qui déclenche le trigger détermine son moment
d’exécution : il est précisé au début de l’écriture du code de
trigger.
(INSERT|DELETE|UPDATE)
Le trigger peut être déclenché avant ou après cette action
(BEFORE|AFTER)
L’option FOR EACH ROW [WHEN (<condition>)] fait
exécuter le trigger à chaque modification d’une ligne de la
table spécifiée (on dit que le trigger est de ”niveau ligne”).
En l’absence de cette option, le trigger est exécuté une
seule fois (”niveau table”).

02/02/2023 57
 Les déclencheurs (“triggers”)
Caractéristiques

• Un déclencheur a un nom.
• Il est associé à une table et une seule.
• Il peut être actif ou inactif.
• Il est opérationnel jusqu’à sa suppression ou la
suppression de la table à laquelle il est associé.

02/02/2023 58
 Les déclencheurs (“triggers”)
Référence aux colonnes d’une table
• Dans le code associé aux déclencheurs de niveau ligne,
on peut accéder aux valeurs des attributs de la ligne
modifiée par les variables.:old et :new
• Pour un déclencheur sur INSERT, les nouvelles valeurs
sont dans :new.<nom attribut>
• Pour un déclencheur sur UPDATE, les anciennes
valeurs sont dans :old.<nom d’attribut>. Les nouvelles
valeurs sont dans :new.<nom d’attribut>
• Pour un déclencheur sur DELETE, les anciennes valeurs
sont dans :old.<nom d’attribut>

02/02/2023 59
 Les déclencheurs (“triggers”)
Remarques
• N’utilisez pas les triggers pour effectuer des contrôles
d’intégrité.
• Pour éviter de supprimer et recréer un trigger : create or
replace trigger
• Pour un trigger relatif à plusieurs événements, utiliser les
prédicats inserting, updating, deleting
if inserting then …end if;
if updating then …end if;
if deleting then …end if;

02/02/2023 60
 Les déclencheurs (“triggers”)
Activer/désactiver

Un trigger est crée par la clause CREATE TRIGGER ou

CREATE OR REPLACE TRIGGER. Un trigger existant peut être
détruit par DROP TRIGGER.

ALTER TRIGGER nomTrigger ENABLE; -- active le trigger

ALTER TRIGGER nomTrigger DISABLE; -- désactive le trigger
ALTER TABLE nomTable ENABLE ALL TRIGGERS;
ALTER TABLE nomTable DISABLE ALL TRIGGERS;

02/02/2023 61
 Exercice

Soit une base de données dont le schéma est le suivant :

CLIENTS(ci,civilité,nom,prénom,sexe,adr_lib,adr_cp,adr_ville)
COMMANDES(ref, datec, montant, ci#)
LIGNES_CDES(numéro, qte, remise, ref#, cp#)
PRODUITS(cp, libelle, prix_u, catégorie)

02/02/2023 62
 Notions de transactions

• Une transaction est une unité logique de traitement

formée d’une suite d’opérations.
• Cette unité logique de traitement est limitée par une
opération de validation ou d’annulation

Exemple : Environnement bancaire, transfert d’une somme

d’un compte à un autre

02/02/2023 63
 Principe : ACID
• Atomicité

Certaines transactions se terminent anormalement

(panne, erreur, blocage, violation de contrainte, …).

– Pour éviter les incohérences, le SGBD garantit l’atomicité des

transactions: une transaction doit être exécutée entièrement ou
pas du tout.

– Une transaction arrêtée avant la fin est « défaite » (rollback) : les

opérations déjà effectuées sont annulées

02/02/2023 64
 Principe : ACID
• Cohérence

– Une transaction préserve la cohérence des objets

qu’elle manipule. La base est cohérente à l’état initial
et à l’état final

– Les contraintes d’intégrité sont vérifiées après les

mises à jour. Si une contrainte est violée, la
transaction est annulée.

02/02/2023 65
 Principe : ACID
• Isolation
– Les effets d’une transaction sont invisibles aux transactions
concurrentes. Permet d’éviter les interférences entre
transactions (protège les transactions des effets des transactions
concurrentes)
• Durabilité
– Les effets d’une transaction validée sont permanents. Si la
transaction a fait un COMMIT, les mises à jour ne sont pas
perdues, et sont écrites dans la base, même en cas de panne.
– Gestionnaire de pannes : journalisation des opérations,
algorithme REDO.
– Point fort des SGBD, qui peuvent résister aux pannes, sans
perdre de données et en restituant la base dans un état
cohérent.
•
02/02/2023 66
 Validation partielle : SAVEPOINT

• Transaction T
……
COMMIT;
INSERT
INSERT
SAVEPOINT;
DELETE
UPDATE
SAVEPOINT;

INSERT
COMMIT;
02/02/2023 67
 ?

02/02/2023 68