Base de donnees Avancees et Intro à NoSQL.ppt

1
Filière (DUT) : Génie Informatique (S3)
Année Universitaire : 2018/2019 au 2023/2024
Diaporamas du cours :
Bases de données avancées
Préparé par : Idriss CHANA
Enseignant chercheur au Département Génie Informatique, EST-UMI
Meknès Email : i.chana@umi.ac.ma
Au Profit des Etudiants de La Deuxième Année de la filière GI inscrits en
semestre S3

Bases de données Avancées
• Vous permettre d’ exploiter les fonctionnalités avancées d’un SGBDR. (vue,
séquences, indexe, Synonymes, gestion des utilisateurs et leurs droits ….)
• Vous permettre de maitriser l’outil PLSQL Manipulation et
• Vous rendre capable de Programmer des procédures stockées et des
déclencheurs (Triggers).en utilisant un SGBDR Oracle .
• Vous permettre de vous initier au concept de Big Data et aux base de
donnes NoSql
2
Objectif du module

 Chap 1 : Introduction Générale :
1- Introduction sur les Base de données et SGBDR
2- Les fonctionnalités d’un SGBDR
 Chap 2 : Rappel Langage SQL : Mode interactif Langage (LDD) et (LMD)
 Chap 3 : Langage SQL avancé :
1. Les ordre SQL complexe ( agrégat , requête imbriquées, et la clause having)
2. La Création des Vues et des Index, les synonymes et Les Séquences
3. La Gestion de transactions
 Chap 4 : Langage SQL en mode procédural (PL/SQL):
1. PL/SQL Déclaration des variables, ,Curseurs, et gestion des exceptions
2. Procédures et fonctions stockées
3. Les Déclencheurs (Triggers)
 Chap 5 : Gestion et Administration des droits des Utilisateur Oracle
1. Dictionnaire de données , Gestion des utilisateurs
2. Privilèges et Rôle . Profil d'utilisateur .
3. Sécurité d’une base de données
 Chap 6 : Base de Donnes NO SQL ( Mongo DB)
1. Introduction au Bid Data
2. Type de bases de données Nosql.
3. Base de données NoSQL Orientée Documents « MongoDB »
Plan de module

4
-Cours et TD
-Travaux Pratiques
Modalité d’apprentissage

Technicien Spécialisé et BDA
5

Évaluation
• Cours & TD 50%
- DS théorique
- Participation pendant des séances de TDs et de cours
• TP 50%
- DS Pratique
- Participation active pendant des séances de TPs .
- Rapport rendu à la fin des séances des TPs
6

Chap I: Introduction aux bases de données et SGBD
Information :C’est un élément de connaissance concernant des faits,
des sujets ou des élément particulier
Donnée: est une information quelconque, aussi c’est une relation
entre des information
Exemples :
1-Brahim est une personne
2- Brahim étudie les base de données
Définitions
7

• Persistance de données
Entrée (données)+traitement Résultat durable .
• Quantité très importante de données à gérer et à manipuler
• Cohérence de données (intégrité ,identifiant..)
• Non redondance de données
8
Organisation logique et physiques des donnés, indépendance des traitements
Les Besoins :

Historiquement l’information a vu trois approches
 Approche Système de Gestion fichiers(SGF).
 Approche Base de données gérées par les SGBD et SGBDR
 Actuellement avec les Big data Sandbox ( données structurées et
non structurées)
Approches Gestions de l’information
9

Approche Système de Gestion de fichiers
Chap I :Introduction aux bases de données et SGBD
Utilisation d’un ensemble de fichiers de données
Définir les données en fonction des traitement (dépendance
données/programmes)
Toute application à ses propres programmes
Inconvénient :
Redondance (lorsque la volumétrie devient importante)
Lourdeur d’accès aux données (lorsque la volumétrie devient importante)
Difficulté des MAJ
Risque de perdre l’intégrité des données
1

Les données de la BD sont décrites hors des programmes
Approche Base de données.
Avantages :
Pas de Redondance
Vitesse d’accès au donnée
Facilité des MAJ
Respect de l’intégrité des données
11

Que doit permettre un SGBDR ?
1-Décrire les données
indépendamment des applications (de manière intrinsèque)
Langage de Définition de Données (LDD)
2-Manipuler les données
Interroger et mettre à jour les données sans préciser d'algorithme d'accès
dire QUOI sans dire COMMENT
langage de requêtes déclaratif ex.:
quels sont les noms des produits de prix < 100DH ?
Langage de Manipulation de Données (LMD)
12

3-Contrôler les données
Intégrité ; vérification de contraintes d'intégrité
ex.: la note doit être comprise entre 0 et 20
Que doit permettre un SGBD suite… ?
Question1 :Si la secrétaire a saisi par erreur la
note d’une matière (51/20 au lieu 15/20) qui ce qui se
passe et comment remédier à cette situation ??????
Confidentialité : contrôle des droits d'accès, autorisation
Question2 :est ce que un étudiant peut changer la
note qu’ il a eu dans une matière donnée et comment géré
ça ??????
Pour ces deux situation le SGBD doit permettre un :
Langage de Contrôle de Données (CLD)
13

4-Partage
Une BD est partagée entre plusieurs utilisateurs en même temps.
Il en déroule donc : Un contrôle des accès concurrents.
- notion de transaction
L'exécution d'une transaction doit préserver la cohérence de la BD
Question3 :Si je suis à Meknès et j’ai un compte
bancaire initialement ouvert à une agence bancaire
située sur Rabat comment est ce que je peux
consulté mon compte ??????
14

-Reprise après panne, journalisation
- Contrôle d’accès
index (hashage, arbres balancés ...)
5-Sécurité
6-Performances d'accès
Chap I:Introduction aux bases de données et SGBD
15

7-Indépendance physique
Pouvoir modifier les structures de stockage ou les index sans que cela ait de
répercussion au niveau des applications
Les disques, les méthodes d’accès, les modes de placement,
le codage des données ne sont pas apparents
Permettre aux différentes applications d’avoir des vues différentes des
mêmes données
Permettre au administrateur de la base de modifier le schéma logique
sans que cela ait de répercussion au niveau des applications
8-Indépendance logique
16

Structure de SGDB
Chap I Introduction aux bases de données et SGBD
17

Le concept de vue permet d'obtenir l'indépendance logique
La modification du schéma logique n’entraîne pas la modification des applications
(une modification des vues est cependant nécessaire)
Chaque vue correspond à la perception d’une partie des données,
mais aussi des données qui peuvent être synthétisées à partir des
informations représentées dans la BD (par ex. statistiques)
Le niveau Logique( conceptuel tables vues ect …. )
il contient la description des données et des contraintes d’intégrité
(Dictionnaire de Données) le schéma logique découle d’une activité de modélisation
Le niveau externe
Le niveau interne ou dit physique
il correspond aux structures de stockage et aux moyens d’accés
Structure de SGDB Suite …
18

19
Résumé:
Les fonctions des SGBD
1-DEFINITION DES DONNEES
Langage de définition des données (DDL)
(conforme à un modèle de données)
2-MANIPULATION DES DONNEES
Interrogation
Mise à jour(insertion, suppression, modification)
Langage de manipulation des données (DML)
(langage de requête déclaratif)
3-CONTRÔLE DES DONNEES
Contraintes d'intégrité
Contrôle des droits d'accès
Gestion de transactions
Langage de contrôle des données (DCL)

20

Système de Gestion de Base de Données (SGBD) (DBMS en anglais ):
programme qui permet la définition, la mise en œuvre, et l’exploitation
d’une BD (à un niveau plus abstrait que celui fournit par les OS usuels
(gestion de fichiers de droits etc. …)).
1)
Base de données (BD)(DB en anglais ) :
ensemble cohérent, intégre, partagé de données structurées défini pour les
besoins d’une application
21
Questions
1) Donnez une définition aux :
-Base de données
-SGBD ?
2) Quel est le cycle de vie d’une base de données ?
2) Voir le slide précèdent

22
Maître d’oeuvrage
Partie porteuse du besoin qui définit l’objet du projet, le calendrier et le
budget
Maître d’oeuvre
Partie en charge de la réalisation technique du projet
Acteurs de développement

Chapitre 2: SQL : LDD, LMD et
contraintes
Rappel Langage SQL-LDD et LMD :
 Langages (LDD)
 Langages (LMD)
 Les contrainte d’intégrité CIF et CIR
 Exercices d’application

SQL ne se résume pas aux requêtes d'interrogation d'une base.
Ce langage permet aussi de :
- créer des tables
- de modifier la structure de tables existantes
- de modifier le contenu des tables
Le LDD est le Langage de Définition de Données (DDL en anglais).
Il permet de:
 créer des tables par l'instruction CREATE TABLE et de:
 Modifier la STRUCTURE (et non le contenu) des TABLES avec
ALTER TABLE
 Supprimer une table avec DROP TABLE.
Le LMD est le langage de manipulation de données. Parfois on inclut le
LID (langage d'interrogation de données) dans cette partie. Il permet de
modifier le CONTENU d'une table en
 Ajoutant de nouvelles lignes INSERT INTO nom_table
 Modifiant une ou plusieurs lignes UPDATE nom_table SET
 Supprimant des lignes DELETE FROM nom_table
Chapitre 2: SQL : LDD, LMD et
contraintes

Langage de Définition de Données ( LDD)
• Syntaxe simple :
CREATE TABLE nom_table
(
nom_col_1 type_col_1,
nom_col_2 type_col_2,
…
nom_col_n type_col_n
);
Création d'une table : CREATE TABLE
Les principaux types autorisés sont :
Char(n) Chaîne de caractè. de long fixe = n
Varchar2(n)/ Varchar(n) Chaîne de caractè. longueur
variable
Varchar )  2000 Octet (standart ANSI)
Varchar2  4000 Octet ( Oracle)
Number Entier ou réel
 Number (p) Entier (d’au plus p chiffres)
Number(p,d) Décimal sur p positions en tout
(séparateur décimal compris), dont d chiffres décimaux
Date le format dépend de la configuration d'Oracle. Le
plus souvent c'est jj/mm/aaaa
Long Chaîne longue ; restriction : par table, pas plus
d’une colonne de type long

Exemple1 : CREATE TABLE employe
(
empno number(8) not null,
nom varchar2(20),
Fonction varchar2(10),
Sal number(8,2),
code_service char(3),
date_embauche date ) ;
Les autres propriétés possibles ( quelques Contraintes d’intégrité
fonctionnelles
NOT NULL : Indique qu'on est obligé de mettre une valeur dans la colonne
UNIQUE : Indique que les valeurs dans la colonne doivent être toutes différentes
(comme pour les clés, sauf que ce n'est pas une clé)
DEFAULT : Permet d'indiquer une valeur par défaut à la création d'une nouvelle
ligne Exemple 2 CREATE TABLE compte
(
num_cpte NUMBER(11) NOT NULL,
type_cpt VARCHAR2(8) DEFAULT ‘chèque’,
solde NUMBER(10, 2) DEFAULT 0 );

Ajouter /Supprimer une ou plusieurs colonne
ALTER TABLE nom_table ADD (nom_colonne1 type_colonne1, nom_colonne2
type_colonne, …. );
ALTER TABLE nom_table drop(nom_colonne1 , nom_colonne2, …);
Exemple:
ALTER TABLE service ADD (budget number(6), sous_traitant varchar2(30) ) ;
ALTER TABLE Album DROP (RUNK) ;
La modification d'une table : ALTER TABLE
 Modifier le type ou tout autre propriété d'une colonne
ALTER table nom_table Rename COLUMN nom_colonne to New nom_colonne
ALTER TABLE nom_table MODIFY (nom_colonne
nouveau_type_et/ou_nouvelle_propriété);
Exemples:
1) ALTER TABLE employe MODIFY (sal number(10,2), fonction
varchar2(30) ) ;

Renommer et supprimer une table
 Supprimer une table
DROP TABLE nom_table;
 Exemple : DROP table employe ;
 Renommer une table:
• RENAME TABLE nom_table TO nouveau_nom_table;
 Exemple : RENAME TABLE employe to salarie ;

Le LDD Avancée
 Les contraintes d'intégrité
Une contrainte d'intégrité est une règle qui permet d'assurer la validité (cohérence) des
données stockées dans une base.
Le SGBD contrôle les contraintes d'intégrité à chaque modification dans les tables
(saisies, modification ou suppression).
Les différentes contraintes que l'on peut définir sont :
 non nullité (obligation) : NOT NULL : La colonne ne peut pas contenir de valeurs
NULL.
 unicité : UNIQUE Toutes les valeurs de la (des) colonnes doivent être différentes ou
NULL
 clé primaire : PRIMARY KEY : primary key = unique + not null
valeur par défaut : DEFAULT Permet de spécifier une valeur par défaut à la colonne
(dans le cas où aucune valeur n'est explicitement donnée)
 intégrité de domaine : CHECK Permet de spécifier les valeurs acceptables pour une
colonne.
intégrité référentielle (clé étrangère) : FOREIGN KEY Cette colonne fait référence à
Attention, on ne met pas de virgule entre la définition de la colonne et celle de
la contrainte.

• Cette contrainte permet de rendre obligatoire la saisie d'une colonne.
 Exemple :
CREATE TABLE PERSONNE
(
NomPers Varchar2(30) NOT NULL,
PrénomPers Varchar2(30)
);
D’après cette contrainte on aura :
• INSERT INTO PERSONNE VALUES ('Dupont', 'Jean'); autorisé
• INSERT INTO PERSONNE VALUES ('Martin', NULL); autorisé
• INSERT INTO PERSONNE VALUES (NULL, 'toto'); refusé
• INSERT INTO PERSONNE(PrénomPers) VALUES ('titi'); refusé
Question :
• INSERT INTO PERSONNE(NomPers) VALUES (‘Harish'); refusé/ autorisé
?
1- Contrainte d'obligation : NOT NULL
car il faut obligatoirement que le nom ait une valeur.

Sur une seule colonne
(…
Téléphone CHAR(10) UNIQUE
);
Sur plusieurs colonnes :
( NomPers Varchar2(30) NOT NULL,
PrénomPers Varchar2(30),
UNIQUE (NomPers, PrénomPers)
);
Une telle contrainte indique qu'on ne pourra pas avoir deux
personnes ayant le même nom et le même prénom.
2 Contrainte d'unicité : UNIQUE
Cette contrainte permet de contrôler que chaque ligne a une valeur
unique pour la colonne ou l'ensemble de colonne unique (pas de
doublons)

CREATE TABLE PERSONN
(NomPers Varchar2(30) PRIMARY
KEY,
PrénomPers Varchar2(30) PRIMARY
KEY,
…);
(NomPers Varchar2(30),
PrénomPers Varchar2(30),
PRIMARY KEY (NomPers, PrénomPe rs)
);
3-Contrainte de clé primaire:
La contrainte de clé primaire permet d'indiquer que la ou les colonnes
sont uniques et ne peuvent pas avoir de valeur nulle.
1er cas : Si la table possède une clé composée d'une seule colonne, alors il
est possible de l'indiquer juste après la colonne clé.
( idPers number(20) PRIMARY KEY,
noms varchar(10)
… );
2em cas :
Si la table a une clé compose de plusieurs colonnes, alors il est impossible
d'indiquer  PRIMARY KEY au niveau des colonnes.

Ainsi, si on insère la personne toto de la manière suivante :
INSERT INTO PERSONNE (idPers, NomPers) VALUES
(100, 'toto');
Alors les valeurs de ses champs seront :
4-Contrainte Valeur par défaut : DEFAULT
(idPers PRIMARY KEY,
PrénomPers Varchar2(30) DEFAULT 'prénom
inconnu',
DateNaiss Date DEFAULT CURRENT DATE);
100, 'toto', 'prénom inconnu', ‘02/10/2023'

 Syntaxe : après le mot clé CHECK, on indique entre
parenthèses le critère à vérifier.
5-Contrainte de domaine : CHECK
La définition des types de données pour chaque colonne définit déjà un domaine
pour les valeurs. On peut encore restreindre les domaines grâce à la clause
CHECK.
Attention  cette contrainte est très "coûteuse" en terme du temps, car elle est
basé sur une comparaison pouvant contenir une requête de type SELECT. Pour
valider la contrainte, le prédicat doit être évalué à TRUE ou UNKNOWN (présence
de NULL
 Exemple: CREATE TABLE personne ( idpers Number PRIMARY KEY,
PrenomPers Varchar2(30) DEFAULT 'prénom inconnu',
age Number CHECK (age >= 0 AND age < 18),
etat_civil Varchar2(20) CHECK (etat_civil IN ('marié(e)', célibataire',
'veuf(ve)', 'divorcé(e)') );

Il est possible de donner un nom à chaque contrainte (sinon le système en donne un par défaut).
Il suffit de faire précéder la contrainte par le mot-clé CONSTRAINT suivi de son nom.
6 Exemple récapitulatif
(
idpers Number CONSTRAINT clé_primaire PRIMARY KEY,
nom Varchar2(30) CONSTRAINT nom_existant NOT NULL,
prenom Varchar2(30) CONSTRAINT prénom_par_défaut DEFAULT
'prénom inconnu',
age Number CONSTRAINT verify_age CHECK (age >= 0 AND age
< 130),
etat_civil Varchar2(20) CONSTRAINT domaine_état_civil
CHECK (etat_civil IN ('marié(e)', célibataire', 'veuf(ve)', 'divorcé(e)')
);

5- Intégrité référentielle :
5-1 : REFERENCES
L'intégrité référentielle permet de vérifier la cohérence des liens entre tables, lors de
l'ajout, de la suppression et de la modification de lignes. Elle est utilisée lorsqu'on a
une clé étrangère. Elle permet d'assurer que toute valeur de clé étrangère
correspond bien à une valeur de clé primaire de la table liée. Voyons tout d'abord la
syntaxe avec un exemple:
Soit le modèle relationnel suivant :
CLIENT (id_client, Nom_client, …)
FACTURE (code_fact, #id_client, …)
Voilà comment on le traduit en SQL : CREATE TABLE FACTURE
(
code_fact Number PRIMARY KEY,
id_client Number REFERENCES
CLIENT(id_client)
…
);
CREATE TABLE CLIENT
(
id_client Number PRIMARY
KEY,
Nom_client Varchar2(30) NOT
NULL,
…

5-2 Intégrité référentielle : Conséquences
L'application de l'intégrité référentielle implique plusieurs choses :
 On ne peut pas ajouter une facture avec un id_client qui n'existe pas dans la
table client (sinon un message d'erreur apparaît). Il faut d'abord créer le
client avant de créer sa facture.
 On ne peut pas supprimer un client s'il existe des factures qui lui
correspondent. Il faut d'abord supprimer toutes les factures qui le concernent
avant de pouvoir le supprimer
 On ne peut pas modifier l'id_client dans la table client s'il existe des factures
qui le concernent.
 On peut modifier l'id_client de facture seulement si on choisit un id_client
qui existe dans la table client.
Cela revient à vérifier que toutes les factures correspondent toujours à un client
qui existe

5-2 Options
Options des contraintes d'intégrité référentielles Effacer en cascade
ON DELETE CASCADES.
Si on ajoute cette option à la contrainte d'intégrité référentielle, alors si on
supprime une ligne de client, toutes les factures de ce client seront
supprimées.
Attention :
cette contrainte s'applique à la table facture ('enfant') mais elle est vérifiée
lorsqu'on modifie la table client ('parent')
CREATE TABLE FACTURE
(
code_fact Number PRIMARY KEY,
id_client Number REFERENCES CLIENT(id_client) ON DELETE
CASCADE
…
);

5-3 Références à des colonnes multiples
CREATE TABLE RESERVATION ( id_resa Number PRIMARYKEY,
id_hotel Number,
num_ch Number,
date Date NOT NULL,
FOREIGN KEY (id_hotel, num_ch)
REFERENCES CHAMBRE (id_hotel,
num_ch) );
Il arrive qu'une clé primaire, composée de plusieurs colonnes, soit elle-même
clé étrangère d'une autre table.
On indique alors cette clé étrangère composée après la définition des colonnes,
grâce au mot clé FOREIGN KEY suivi des colonnes clés étrangères, puis de
REFERENCES, le nom de la table référencée ainsi que le nom des colonnes
référencées entre parenthèses.
Exemple : soit le schéma relationnel suivant
CHAMBRE(id_hotel, num_ch, tarif)
RESERVATION(id_resa, #id_hotel, #num_ch, date)

CREATE TABLE LIGNE_COMMANDE
(
id_commande Number REFERENCES COMMANDE(id_commande),
ref_produit Varchar2(10) REFERENCES PRODUIT(ref_prod),
quantité Number DEFAULT 1,
PRIMARY KEY (id_commande, ref_produit)
);
5-4 La clé primaire est composée de plusieurs clés étrangères
Remarque :
dans la table PRODUIT, la référence est codée par ref_prod
et dans la table COMMANDE, c'est ref_produit

 Ajout/ modification ou suppression d'une
contrainte
Exemple 2 : On ajoute la contrainte de vérification de l'âge d'une personne:
Sql> ALTER TABLE PERSONNE ADD CONSTAINT verif_age CHECK
(age <= 130);
Exemple1 : On ajoute la contrainte d'intégrité référentielle dans la table
COMMANDE.
Sql> ALTER TABLE COMMANDE ADD CONSTAINT FK_idclient FOREIGN KEY
(id_client) REFERENCES CLIENT(id_client);
Syntaxe générale :
ALTER TABLE nom_table ADD CONSTRAINT Nom_Constraint
TYPE_CONTRAINTE (colonne(s));
ALTER TABLE nom_table DROP CONSTRAINT <Nom_constaint>;
Pour ajouter/supprimer ou modifier une contrainte à une table existante,
il suffit d'utiliser la commande:
 ALTER TABLE
Exemple 3 : Supprimer la contrainte de vérification de l'âge d'une personne:
Sql> ALTER TABLE PERSONNE Drop CONSTAINT verif_age);
alter table nom_table modify (col default ‘Val_par_defau);
 ALTER TABLE cas particulier : la proprité « par defautlt » n’est
pas une contraite oracle :

Exercices d’application(TD/TP 1)
Soit le schéma logique suivant
1- Créer les tables en respectant le type de donnée de chaque attribut. La
création va se faire comme suite:
- 1er Créer la table STYLES en déclarant la Clés primaire en même temps
-2ém Créer la table ARTIST en déclarant la Clés primaire en même
temps
-3ém Créer la table ALBUM sans mentionner les clés
-4ém Créer la table STYLE sans mentionner les clés
2- En utilisant les contraintes, déclarer les clés primaires et étrangères
pour les deux tables : ALBUM et STYLE
P= clé primaire
F= Clé étrangère
FP= les deux
clés

3- Ajouter une colonne Role de type quelconque à la table STYLE
4- Ajouter une contrainte à la colonne PRICE de la table ALBUM ( PRICE> 30)
5. Affecter la valeur 0 à tous les RANK de tous les ALBUM existants
6. Modifier la colonne RANK de la table Album pour qu'elle prenne la valeur 0 par
défaut
7- Supprimer la colonne Role de la table STYLE
8. Ajouter:
- un nouveau STYLES
- un nouveau ARTIST
- un nouveau ALBUM
- un nouveau STYLE
9. Donner les albums dont le prix est inférieur à 9 euros.
10. Donner les albums qui sont sortis après le 18 mai 1999.
11. Donner les artistes dont l’album a atteint un rank supérieur ou égal à 25000.
8. Changer le rang de l’artiste « BOB » à 30
Exercices d’application
(Suite)

CREATE TABLE ALBUM
(
ASIN INT (38) NOT NULL ,
TITLE VARCHAR (30) NOT NULL ,
IDARTIST INT (38) NOT NULL ,
PRICE number(10) ,
`RELEASE` DATE,
RANK number (28) ,
IDLABEL number (38) NOT NULL
);
CREATE TABLE ARTIST
(
ID Number (38) NOT NULL ,
NOM VARCHAR (30) NOT NULL
);
ALTER TABLE ALBUM ADD CONSTRAINT PK_ALBUM PRIMARY KEY (ASIN);
ALTER TABLE ALBUM ADD CONSTRAINT FK_ALBUM_ARTIST Foreign Key
(IDARTIST) REFERENCES ARTIST (ID);
ALTER TABLE ALBUM ADD CONSTRAINT FK_ALBUM_LABEL Foreign Key
(IDLABEL) REFERENCES LABEL (ID);
ALTER TABLE ARTIST ADD CONSTRAINT PK_ARTIST PRIMARY
KEY (ID);
Exercices d’application (Creation des tables))

ALTER TABLE STYLE ADD CONSTRAINT PK_STYLE PRIMARY KEY (ASIN);
ALTER TABLE STYLE ADD CONSTRAINT FK_STYLE_ALBUM
Foreign Key (ASIN)REFERENCES ALBUM (ASIN);
ALTER TABLE STYLE ADD CONSTRAINT FK_STYLE_STYLES
Foreign Key (STYLE) REFERENCES STYLES (STYLE);
CREATE TABLE STYLES
(
STYLE VARCHAR (24) NOT NULL
);
ALTER TABLE STYLES ADD CONSTRAINT PK_STYLES
PRIMARY KEY (STYLE);
CREATE TABLE STYLE
(
ASIN INT (38) NOT NULL ,
STYLE VARCHAR (24) NOT
NULL
);
Exercices d’application (Création des tables suite …)

• Requêtes imbriquées
• Agrégat
• Regroupement
• La gestion des Vues et des Index, des synonymes et des Séquences
• La Gestion de transactions
Chapitre 3 : Requêtes Complexes

Motivation
• Les requêtes déjà vues ne correspondent qu’à des opérations
simples
• Vers le PL/SQL
• Requête imbriquée
 Parfois la valeur d’un test doit être calculé comme le résultat d’une autre
requête
• Agrégat
 Opération destinée à agréger plusieurs valeurs de tuples en une seule
valeur (en les additionnant, en calculant leur moyenne, etc.)
• Regroupement
 Décomposition d’une table en plusieurs sous-tables sur lesquels des
opérations seront effectuées sous-table par sous-table (des agrégats par
exemple)

SQL : Requêtes imbriquées
• Requête imbriquée dans la clause WHERE d'une requête externe:
• Opérations ensemblistes
 Le résultat d’une requête (imbriquée) est une table, c’est-à-dire un
ensemble de tuples.
 Les opérations possibles sont donc ensemblistes.
SELECT …
FROM …
WHERE [Expression] Opérateur (SELECT
…
FROM …
WHERE …);
Requête
imbriquée
Requête
externe
4

Opérateurs
ensemblistes
• IN
 appartenance ensembliste
 (A1,…An) IN <sous-req>
• EXISTS
 test d’existence
 EXISTS <sous-req>
• COMPARAISON
 comparaison avec chaque élément d’un ensemble
 (A1,…An) ALL <sous-req>
 opérateur
5
de comparaison (<,>,<=,>=,<>)

Expression IN
5
• Sémantique :
 la condition est vraie si tuple désigné par (A1,…,
appartient au résultat de la requête interne.
• Algorithme
An)de la requête externe
 Pour chaque tuple des tables de la requête externe, extraire et calculez le
sous-tuple (A1,…An)
 Si le tuple obtenu appartient au résultat de la requête imbriquée,
calculezet ou afficher les expressions de projection de la clause
SELECT.
SELECT …
FROM …
WHERE (A1,…,An)IN (SELECT B1,…,Bn
FROM …
WHERE …);

Expression NOT IN
5
• Sémantique :
 la condition est vraie si tuple désigné par (A1,…, An)de la requête externe
n’appartient pas au résultat de la requête interne.
• Algorithme
 Si le tuple obtenu n’appartient pas au résultat de la requête
imbriquée, calculer et/ou afficher les expressions de projection
de la clause SELECT.
SELECT …
FROM …
WHERE (A1,…,An)NOT IN (SELECT B1,…,Bn
FROM …
WHERE …);

Exemple avec IN
53
• Noms des employés qui travaillent
dans des villes où il y a des projets
de budget inférieur à 50?
SELECT Ename
FROM
WHERE
Emp
City IN
(SELECT City
FROM Project
WHERE Budget < 50);
Emp (Eno, Ename, Title, City)
Pay(Title, Salary)
Project(Pno, Pname, Budget, City)
Works(Eno, Pno, Resp, Dur)
• Noms des employés qui travaillent
dans des villes où il n’y a pas de
projets de budget inférieur à 50?
SELECT Ename
FROM Emp
WHERE City NOT IN
(SELECT City
FROM Project
WHERE Budget
< 50);

ALL
• est une comparaison :
• Sémantique
{<, <=, >, >=, <>}
 ALL ( ) : la condition est alors vraie si la comparaison est vraie pour
tous les tuples résultats de la requête interne.
• Algorithme
 Si la comparaison de (A1,..,An) est vraie avec tous les tuples de
la requête imbriquée, alors calculer et/ou aficher les
expressions de projection de la clause SELECT.
SELECT …
FROM …
WHERE (A1,…,An) ALL (SELECT B1,…,Bn
FROM …
WHERE …);
54

Exemple avec ALL
• Noms des projets qui ont le plus gros budget ?
SELECT DISTINCT Pname
FROM Project
WHERE Budget >= ALL (SELECT Budget
FROM Project)
Pay(Title, Salary)
5

ANY
• est une comparaison :
• Sémantique
{<, <=, >, >=, <>}
 ANY: la condition est alors vraie si la comparaison est vraie avec au
moins un tuple résultats de la requête interne.
• Algorithme
 Si la comparaison de (A1,..,An) est vraie avec au moins un tuple
de la requête imbriquée, alors calculer et/ou afficher les
expressions de projection de la clause SELECT.
SELECT …
FROM …
WHERE (A1,…,An) ANY (SELECT B1,…,Bn
FROM …
WHERE …);
56

Exemple avec ANY
5
• Noms des villes qui ont au moins un projet de budget supérieur à
50000 ?
SELECT DISTINCT City
FROM Project
WHERE Budget = ANY
(SELECT Budget
FROM Project
WHERE Budget > 50000)
Pay(Title, Salary)

EXISTS
• EXISTS retourne VRAI ou FAUX
• Sémantique :
– La condition EXISTS est vraie si la requête imbriquée n’est pas vide.
• Algorithme
 Pour chaque tuple des tables de la requête externe, extraire et
calculez le sous-tuple (A1,…An)
 Si le résultat de la requête imbriquée n’est pas vide, alors
calculer et/ou aficher les expressions de projection de la clause
SELECT.
SELECT …
FROM R1 ,X, …
WHERE EXISTS (SELECT B1,…,Bn
FROM …
WHERE Condition(x) …);
Les deux requêtes
5
sont généralement
corrélées, la
requête imbriquée
dépend de la
valeur de x.

Exemple avec EXISTS
• Noms des employés qui travaillent dans une ville où il y a au
moins un projet?
SELECT
FROM
WHERE
e.Ename Emp
e
EXISTS (SELECT
FROM
*
Project
WHERE e.City=Project.City)
• Noms des projets qui emploient des ‘Elect Eng’ ?
Pay(Title, Salary)
5
SELECT
FROM
WHERE
p.Pname
Project p
EXISTS(SELECT *
FROM Works w, Emp e
WHERE w.Pno=p.Pno and e.Eno=w.Eno
and e.Title=’Elect.Eng.’)

Exemple avec EXISTS
La requête imbriquée ne dépend pas de p : elle retourne
l’ensemble des employés de titre ‘Elect. Eng.’,
indépendamment du projet sélectionné dans la requête externe.
La clause EXISTS retourne donc toujours vraie (on suppose
qu’il existe un tel employé) et la requête externe retourne tous
les noms de projets.
Pay(Title, Salary)
6
SELECT p.Pname
FROM Project p
WHERE EXISTS
(SELECT * FROM Works w, Emp e
WHERE e.Eno=w.Eno
Ande.Title=’Elect.Eng.’)

NOT EXISTS
• NOT EXISTS retourne VRAI ou FAUX
• Sémantique :
– La condition NOT EXISTS est vraie si la requête imbriquée est vide.
• Algorithme
• Pour chaque tuple des tables de la requête externe, extraire et
calculez le sous-tuple (A1,…An)
• Si le résultat de la requête imbriquée est vide, alors calculer et/ou
aficher les expressions de projection de la clause SELECT.
SELECT …
FROM R1 x…
WHERE NOT EXISTS (SELECT B1,…,Bn
FROM …
WHERE Condition(x));
Les deux requêtes
6
sont généralement
corrélées, la
requête imbriquée
dépend de la
valeur de x.

Exemple avec NOT EXISTS
6
• Noms des projets qui n’emploient aucun ‘Elect Eng’ ?
SELECT
FROM
WHERE
p.Pname
Project p
NOT EXISTS (SELECT *
FROM Works w, Emp e
WHERE w.Pno=p.Pno
and e.Eno=w.Eno
and e.Title=’Elect.Eng.’);
Pay(Title, Salary)

Fonctions d'agrégation
• Une fonction d’agrégation permet de calculer une seule valeur
numérique à partir des valeurs de plusieurs tuples pour un attribut
donné
 Exemple: la somme des budgets des projets
• Une fonction d’agrégation prend un attribut en paramètre
• On utilise une fonction d’agrégation
 dans la clause SELECT pour effectuer un calcul post-projection
 dans la clause WHERE pour remplacer une valeur par un calcul dans une
condition. Ce calcul est le résultat de l’agrégation d’une requête imbriquée.
SELECT
FROM
WHERE
6
AggFunc(Ai), …, AggFunc(Aj)
R1, ..., Rm
conditions;

Fonctions d’agrégation
6
Fonction Description
COUNT([DISTINCT]x,y,…) Décompte des tuples du résultat par
projection sur le ou les attributs
spécifiés (ou tous avec ‘*’).
L’option DISTINCT élimine les
doublons.
MIN(x), MAX(x), AVG(x),
SUM(x)
Calculent respectivement le
minimum, le maximum, la
moyenne et la somme des valeurs
de l’attribut X.

Exécution d’une requête d’agrégation
6
1. La requête est exécutée classiquement et retourne une table
résultat temporaire dont les colonnes sont les attributs Ai, …, Aj
utilisées dans les fonctions d’agrégation
2. Les fonctions d’agrégation sont appliquées sur les colonnes de la
table résultat
3. Le résultat de la requête est une table
 dont les colonnes sont les noms des expressions de la clause
SELECT
 contenant un seul tuple

Requête d’agrégation
Personnes
SELECT sum(salaire)
FROM Personnes
Sum(salaire)
9700
Etape 1)
Table-Temp =
SELECT salaire
FROM Personnes
T
able-T
emp
Etape 2)
Table-Resultat =
SELECT sum(salaire)
FROM Table-Temp
agrégation
T
able-Resultat
67
nom prénom salaire
Martin Pierre 2500
Dupond Jean 3000
Dupond Marc 4200
salaire
2500
3000
4200

Exemples d'agrégation
dans la clause SELECT
6
• Budget max des projets de Paris?
SELECT
FROM
WHERE
MAX(Budget)
Project
City = ’Paris’;
• Affichage du nombre d’employés
SELECT COUNT(*) FROM Emp;
Emp (Eno, Ename, Title, City) Project(Pno, Pname, Budget, City)
Pay(Title, Salary) Works(Eno, Pno, Resp, Dur)
• Nombre de villes où il y a un projet avec
l'employé E4?
SELECT
FROM
WHERE
AND
COUNT(DISTINCT City)
Project, Works
Project.Pno = Works.Pno
Works.Eno = ’E4’;

Exemple d'agrégation
dans la clause WHERE
6
Emp (Eno, Ename, Title, City) Project(Pno, Pname, Budget, City)
Pay(Title, Salary) Works(Eno, Pno, Resp, Dur)
• Noms des projets dont le budget est supérieur au budget
moyen?
SELECT Pname
FROM Project
WHERE Budget > (SELECT AVG(Budget)
FROM Project);

Exemples d'agrégation
• Budget max des projets de Paris avec identifiant ?
SELECT Pno, MAX(Budget)
FROM Project
WHERE City = ’Paris’;
• Budget max des projets de Paris avec identifiant ?
Pay(Title, Salary)
Impossible de mélanger une
fonction d’agrégation avec un
attribut sans agrégation s’il n’y a
pas de clause GROUP BY !
7
SELECT Pno, Budget
FROM Project
WHERE City = ’Paris’
AND Budget = (SELECT MAX(Budget) FROM
Project and
City=‘Paris’);

Requêtes de groupement :
GROUP BY
• Sémantique
 Partitionne les tuples résultats en fonction des valeurs de certains attributs
• Algorithme
1. Calcul de la requête brute (sans regroupement ni agrégation)
2. Regroupement horizontal des lignes en sous-tables possédant les mêmes
valeurs de regroupement Aj …, Ak
3. Pour chaque sous-table, calcul des valeurs agrégées pour les attributs non
regroupés
SELECT
FROM
WHERE
GROUP
7
A1, …, An,
R1, …, Rm
…
BY A1 …, An
AggFunc(An+1), …, AggFunc(An+p)

GROUP BY
SELECT A1, B1, sum(A2)
FROM R1, R2
WHERE A1 < 3
GROUP BY A1, B1
R1
7
R2
B1
a
group by
where select
A1A2
2 6
1 1
2 8
3 3
1 2
3 3
A1 A2 B1
2 6 a
1 1 a
2 8 a
1 2 a
A1 A2 B1
2 6 a
1 1 a
2 8 a
3 3 a
1 2 a
3 3 a
A1 B1 sum(A2)
1 a 3
2 a 14
A1 B1 A2*
1 a 1
2
2 a 6
8
from

GROUP BY
7
• Règles de regroupement
 Tous les attributs Ai, …, An dans la clause SELECT qui ne sont pas
impliqués dans la clause GROUP BY doivent être inclus dans une
opération d'agrégation
• SELECT Pno, count(Eno) FROM Works
GROUP BY Pno;
• Sélection des tuples
 La clause WHERE permet de sélectionner les tuples appartenant aux sous-
tables. La condition est évaluée AVANT le regroupement.
• SELECT Pno, count(Eno) FROM Works
WHERE Dur >10
GROUP BY Pno;

Exemples de groupement
• Numéros des projets avec le nombre d’employés impliqués par
projet ?
SELECT Pno, Count(Eno)
FROM Works
GROUP BY Pno;
• Noms des villes avec la durée moyenne et la durée maximale de
participation de tout les employé par ville et par nom de
projet ?
Pay(Title, Salary)
7
SELECT
FROM
WHERE
Pname, AVG(Dur), MAX(Dur)
Works, Project
Works.Pno=Project.Pno
GROUP BY City, Pname;

Exemple de groupement ordonné
Classement des produits par la valeur totale vendue pour les
produits
SELECT DISTINCT produit.nom, SUM(vente.qt *
AS total
FROM produit, vente
produit.prix)
WHERE
GROUP
ORDER
produit.id = vente.produit_idx
BY produit.nom
BY total;
Le tri des résultats se fait
APRES le regroupement
et l’agrégation.
7

Sélection sur des groupes
GROUP BY Aj …, Ak
HAVING condition
• Sémantique
 Sélectionne les groupes (partitions) qui satisfont une certaine condition .
• Algorithme
1. Sélectionne tous les tuples qui satisfont les conditions de la clause WHERE.
2. Forme les groupes qui partagent les mêmes valeurs de la clause GROUP BY.
3. Supprime tous les groupes qui ne satisfont pas les conditions de la clause
HAVING
4. Applique les fonctions d’agrégation pour chaque groupe.
5. Retourne les valeurs des colonnes et des agrégation de la clause SELECT.
7
SELECT
FROM
WHERE
Ai, …, An,
R1, …, Rm
…
[AggFunc(Ai), …, AggFunc(Aj), …]

Sélection sur des groupes
7
• Règle : La condition de la clause HAVING porte
 Soit sur des valeurs atomiques retournées par un opérateur d'agrégation sur
les attributs qui n’apparaissent pas dans le GROUP BY
 Soit sur des opérations d’agrégation sur des attributs qui apparaissent dans
le GROUP BY
• Exemple
SELECT DISTINCT produit.nom,
SUM(vente.qt*produit.prix) AS "total produit",
vente, produit
produit.id = vente.produit_idx
and nom like’a%’
BY produit.nom
FROM
WHERE
GROUP
HAVING MIN(vente.qt)>1;

Exemples de groupement avec sélection
7
• Villes dans lesquelles habitent plus de 2 employés?
SELECT City FROM Emp GROUP BY City
HAVING COUNT(ENO) > 2;
• Projets dans lesquels 2 employés ou plus partagent une
responsabilité?
Pay(Title, Salary)
SELECT DISTINCT Pno
FROM Works where resp=‘Oui’
GROUP BY Pno, Resp
HAVING COUNT(DISTINCT ENO) >=2;

Exemples de groupement avec sélection
8
SELECT DISTINCT model FROM voiture
SELECT DISTINCT produit.nom, SUM(vente.qt * produit.prix) AS total
FROM produit, vente WHERE produit.id=vente.produit_idx
And produit.nom like ’M%’
GROUP BY produit.nom , produit_idx
ORDER BY total;
Classement des produits par la valeur totale vendue pour les produits commençant par
la lettre ‘M’.
Produit( id, nom, prix,…)
vente( id_vente, produit_idx*, qt, …,…)
Afficher Les modèles de voitures qui proposent un choix de plus de 10 couleurs.
Voiture ( id_voiture, model, couleur,…)
GROUP BY model
HAVING COUNT(couleur) > 10;
Est-ce Correcte ?!

8
 Langage SQL avancé :
1- Les ordre SQL complexe ( agrégat , requête
imbriquées, et la clause having)
2- Les Vues et Index,
3- Les Séquences et Les synonymes
4- La Gestion de transactions
Chapitre 3(Suite)

Les Vues
(VIEW)
8
 une vue est une table virtuelle résultat d’une requête
 Rôle d’une vue
 Réduire la complexité syntaxique des requêtes
 Améliorer les performances de certains traitements
 Définir les schémas externes.
 Définir des contraintes d’intégrité.
 Définir un niveau additionnel de sécurité en restreignant l’accès à un sous ensemble
de lignes et/ ou de colonnes.
Les vues font partie du Schéma externe, schéma visible par les applications utilisant la
base de données.

83
La requête SQL peut s'appliquer à une table ou une vue (exception faite
de la vue que l'on est en train de définir, i.e. on ne peut pas créer une
définition récursive). La définition de la vue est stockée dans le
dictionnaire ce qui permet de traduire toute requête utilisant des vues en
une requête sur les tables.
Une vue permet de donner un nom à une requête.
La syntaxe SQL de création d'une vue est simplement
create [or replace] view nom_vue as
requete_sql [option]

• On crée les vues suivantes Nom_Emp et som_sal
1- Nom_Emp: Create view Nom_Emp as select * from EMPLOYEES
where last_name like ‘ J%’
2- som_sal : create or replace view SOM_SAL as select J.job_title J_titl,
sum(E.SALARY) somme_sal from employees E,jobs J where E.job_id=J.job_id
group by job_title
• Soit les tables suivante de Schéma HR de oracle
EMPLOYEES(EMPLOYEE_ID , FIRST_NAME , LAST_NAME ,EMAIL,PHONE_NUMBER
,HIRE_DATE ,JOB_ID,SALARY, COMMISSION_PCT, MANAGER_ID,DEPARTMENT_ID)
JOBS(JOB_ID, JOB_TITLE, MIN_SALARY, MAX_SALARY)

• Modification au travers d'une vue
Les instructions de mise à jour de la vue doivent être traduites en mise à jour sur les
tables de base. Ceci n'est pas possible dans le cas général. Pour cette MAJ Il faut que
:
1- Chaque colonne de la vue doit correspondre à une colonne d'une table.
2- La vue ne doit pas contenir :
un opérateur ensembliste
un opérateur DISTINCT
une fonction de groupe, ou une fonction mathématique
une clause GROUP BY, ORDER BY
des jointures (avec quelques exceptions ( notion de clé préservée dans la vue) )
On peut interdire de modifier une vue, avec l'option WITH READ ONLY. (Sous Oracle,
mais je n'ai pas vu cette option dans la norme SQL).
8

8
La clause WITH CHECK OPTION
Cette option (définie dans la norme SQL) permet de vérifier que lorsqu'on modifie
une vue, les lignes concernées par la modification sont bien sélectionnées par la
requête qui définit la vue.
Sans cette option, voici le genre de problèmes que l'on peut avoir :
- Create view Nom_Emp as select * from EMPLOYEES where last_name like ‘ JOHN’
Vue bien crée
- insert into Nom_Emp
values(6666,'TATA','TINTIN','TINGBB','777','17/06/15','AD_PRES’,'24000',NULL,NUL
L,'90');
Ligne bien crée
Attention on se retrouve dan la vue avec des données non
souhaitées
-Update et delete aussi vont être bien exécutés sur la vue.

8
La clause WITH CHECK OPTION permet d'éviter les problèmes précédents
- Create view Nom_Emp as select *
from EMPLOYEES where last_name
like ‘ JOHN’ with check option
Vue bien crée
insert into Nom_Emp
values(6666,'TATA','TINTIN','TINGBB','777','1
7/06/15','AD_PRES’,'24000',NULL,NULL,'90');
ERREUR à la ligne 1: ORA-01402: vue
WITH CHECK OPTION - violation de
clause WHERE
Pour renommer une vue : Rename ancien_nom to
nouveau_nom;

Rappels sur les indexes : Principes choix et
création : index btree , BitMap

L’index est utile pour accélérer l’exécution d’une requête SQL qui lit des données et ainsi
améliorer les performances d’une application utilisant une base de données
Les 2 types d’index les plus utilisé dans Oracle :
Arbres équilibrés (B-arbre) : toutes les branches de l’arbre ont la même longueur
Il est efficace lorsque les données indexés ne sont pas répétés ( Clé primaire , données uniques)
 Bitmap : Si peu de valeurs sont possibles pour les données répétées, une chaine de bits pour
chaque valeur
Un index est un objet complémentaire (mais non indispensable) à la base de données permettant d'"indexer"
certaines colonnes dans le but d'améliorer l'accès aux données par le SGBDR, au même titre qu'un index
dans un livre ne vous est pas indispensable mais vous permet souvent d'économiser du temps lorsque vous
recherchez une partie spécifique
Qu'est-ce qu'un index?

De manière générale, un index est créé automatiquement lors de la création de la
clé primaire d'une table ;
de la même manière, il est d'usage d‘en créer un pour chaque clé étrangère afin
d'améliorer la vitesse lors des jointures.
Un index peut être :
 Simplement le stockage des données d'une colonne de table qui sera souvent
sollicitée (surtout au niveau des recherches)
 L'ensemble de plusieurs colonnes qui feront l'objet de requête pour les
recherches.
Création de l’index

• Quand créer un index
-----------------------------
 Attributs utilisées dans des jointures,
 Attributs servant souvent pour les sélections,
 Table de gros volume dont la majorité des
interrogations sélectionne moins de 15% des
lignes,
• Quand ne pas créer un index
-------------------------------
 Attributs souvent modifiés (index à
recréer...),
 Table de petit volume,
 si requêtes sur NULL car les NULL, non
stockés dans l’index. (ex : WHERE ... IS
NULL).
Bitmap : attribut à peu de valeurs distinctes,
B-arbre : attribut à beaucoup de valeurs
Création de l’index

La création d'index en SQL se fait grâce à la clause INDEX précédée
de la clause CREATE. Elle permet de définir un index désigné par son nom, portant
sur certains champs d'une table.
La syntaxe est la suivante :
CREATE [UNIQUE] [BITMAP]INDEX Nom_de_l_index ON Nom_de_la_table
(Nom_de_champ [ASCDESC], ...)
[Tablespace nom_tablespace_des_index] ;
•L'option UNIQUE permet de définir la présence ou non de doublons pour les
valeurs de la colonne
•L'option BITMAP Index de type bitmap
•Les options ASCDESC permettent de définir un ordre de classement des valeurs présentes
dans la colonne
•Supprimer l’INDEX  DROP INDEX Nom_Index

0-100
-----------
--
101-200
-----------
-------
………
….
-----------
------
301-
400-
Branches
( Branch
Blocks)
0-33
-----------
34-67
----------
68-100
101-134
-----------
135-167
----------
167-300
0 Rowid
-----------
1 Rowid
----------
…
-------
33 Rowid
34
Rowid
-----------
35
Rowid
----------
…
-------
67
Rowid
68 Rowid
-----------
69 Rowid
----------
…
-------
100Rowi
d
101
Rowid
-----------
102Rowid
----------
…
-------
134Rowid
135Rowi
d
-----------
136Rowi
d
----------
…
-------
167Rowi
d
168Rowi
d
-----------
169Rowi
d
----------
…
-------
300Rowi
d
Nœud racine
( Root Node)
Feuilles
( Leaf Blocks)
Le segment de la table
Table segment

22
-3
8
5
6
7
2
35
30
20
-5
25
12
10
6
22
-3
8
5
20
7
2
35
30
6

Les valeurs inférieures sont à gauche
Les valeurs Supérieures sont à droit
Comment ça marche L’index B-Tree ( L’arbre Binnaire)

Comment ça marche L’index B-Tree ( L’arbre
Binnaire)
La Recherche
20
10
8
6
5

Binnaire)
L’Insertion
20
10
11
5 11

Binnaire)
Suppression
20
10
5 7
8
6
7

Binnaire)
Suppression
2
5
2

Binnaire)
Suppression
20
20
30
25
22
22

L’index Bitmap Select nom, prenom, job_id from employees
ID NOM Prenom Job_id-
---------------------------------------------------------------------------
101 Neena Kochhar
AD_VP
102 Lex De Haan AD_VP
103 Alexander Hunold IT_PROG
104 Bruce Ernst IT_PROG
107 Diana Lorentz IT_PROG
108 Nancy Greenberg FI_MGR
109 Daniel Faviet FI_ACCOUNT
110 John Chen FI_ACCOUNT
111 Ismael Sciarra FI_ACCOUNT
112 Jose Manuel Urman FI_ACCOUNT
113 Luis Popp FI_ACCOUNT
115 Alexander Khoo PU_CLERK
116 Shelli Baida PU_CLERK
117 Sigal Tobias PU_CLERK
118 Guy Himuro PU_CLERK
119 Karen Colmenares PU_CLERK
120 Matthew Weiss ST_MAN
121 Adam Fripp ST_MAN
122 Payam Kaufling ST_MAN
123 Shanta Vollman ST_MAN
124 Kevin Mourgos ST_MAN
125 Julia Nayer ST_CLERK
126 Irene Mikkilineni ST_CLERK
127 James Landry ST_CLERK
128 Steven Markle ST_CLERK
105 David Austin IT_PROG
106 VallPataballa IT_PROG
1 2 3 4 5 6 7 8 …
ST_CLERK 0 0 0 0 0 0 0 0 .
.
ST_MAN 0 0 0 0 0 0 0 0 .
.
FI_ACCOU
NT
0 0 0 0 0 0 1 1 .
.
PU_CLERK 0 0 0 0 0 0 0 0 .
.
IT_PROG 0 0 1 1 1 0 0 0 .
.
AD_VP 1 1 0 0 0 0 0 0 .
.
Select * from employees where job_id like ‘FI_ACCOUNT’
L’index Bitmap n’est pas utilisé (exploité)
quand la clause est ( not like , not in , different
<>, null)

Exemple de création d’index
Créer l’index :
CREATE UNIQUE INDEX idx_clients ON clients(no_client)
CREATE BITMAP INDEX idx_empl ON departments (department_name)
Supprimer l’index  DROP index idx_empl

• Une séquence est un objet de base de données Oracle,
au même titre qu'une table, une vue,
• Elle appartient à un utilisateur, on peut donc si on a les
droits nécessaires :
 La manipuler,
 La modifier,
 La supprimer
 …..
Les Séquence

Définir une séquence équivaut à définir une
suite de nombres entiers.
L'évolution de cette suite est régie par un
certain nombre de paramètres,
L'utilisation d'une séquence permet donc
d'avoir à disposition une suite de valeurs.
Les Séquence
Définition d'une séquence

Création D’une Séquence
•  SQL> CREATE SEQUENCE ma_sequence;
• La séquence a 2 Pseudo-colones
• 1- La pseudo-colonne CURRVAL retourne la valeur courante de la séquence.
• 2- La pseudo-colonne NEXTVAL incrémente la séquence et retourne la nouvelle
valeur.
L'ordre SQL minimal de création d'une séquence :
SQL> select ma_sequence.nextval from dual;
NEXTVAL
1
SQL> select ma_sequence.currval from dual;
CURRVAL
---------
1
SQL> select ma_sequence.nextval from dual;
NEXTVAL
---------
2

Création D’une
Séquence
D’autre option de création d'une séquence :
Valeur initiale et incrément:
Les paramètres START WITH et INCREMENT BY.
RQ: ces paramètres peuvent s'utiliser indépendamment.
CREATE SEQUENCE ma_sequence START WITH 4 INCREMENT BY 2;
Dans cet exemple, on a défini la suite 4, 6, 8, 10,12, 14, 16,…., etc
Pour faire une suite descendante, il suffit d'indiquer une valeur négative au paramètre
CREATE SEQUENCE ma_sequence INCREMENT BY -10;
Valeur MAXI et MINI
CREATE SEQUENCE ma_sequence MAXVALUE MINVALUE;
CREATE SEQUENCE ma_sequence MINVALUE -20 MAXVALUE 40;
CREATE SEQUENCE ma_sequence START WITH 1 INCREMENT BY 1 MAXVALUE 9999;
CREATE SEQUENCE ma_sequence START WITH -1 INCREMENT BY -1 MINVALUE -9999;

• Lorsque la séquence atteint sa valeur maxi (resp. mini), on peut lui demander de s'arrêter
(Oracle retournera une erreur lors de la prochaine tentative d'utilisation de NEXTVAL), ou de
reprendre à sa valeur mini (resp. maxi) et reprendre son compte.
Cas N°1 :
• CREATE SEQUENCE ma_sequence_NC START WITH 1 MINVALUE -10 MAXVALUE 10
NOCYCLE;
Cette séquence comptera jusqu'à 10 puis retournera une erreur au NEXTVAL suivant
• Cas N°2 :
• CREATE SEQUENCE ma_sequence_WC START WITH 1 MINVALUE -10 MAXVALUE 10
CYCLE;
• Cette séquence (ma_sequence_WC ) comptera de 1 à 10, puis de -10 à 10, puis de -10 à
10... :
• Par défaut, une séquence ne reboucle pas (cas n°1)
Reboucler la séquence

•
SQL> create sequence seq_no_cli start with 1000 increment by 100;
• SQL> insert into clients (no, nom) values (seq_no_cli.nextval,'Martin');
Pour Supprimer une Séquence: DROP SEQUENCE
nom_de_la_sequence;
Pour Réinitialiser une séquence soit par Alter ou bien un Programme
PL/SQL
Exemple d’utilisation d’une la séquence

Les synonymes
• Un Synonyme: est un alias d’un objet base de données (tables, vues,indexes, synonymes,
séquences, déclencheurs, procédures, fonctions…)
•
• Si on crée le synonyme emp sur la tables hr.employee, alors manipuler emp, revient
• à manipuler hr.employee :
• SELECT * FROM employee équivaut à SELECT * FROM hr.employee
• Il existe deux types de synonymes :
• Synonyme privé : accessible uniquement à partir du schéma dans lequel il a été créé
• CREATE SYNONYM nom_syn FOR schema.nom_objet
• Synonyme public : accessible à partir de tout schéma
• CREATE PUBLIC SYNONYM nom_syn FOR schema.objet

Transactions
• Cohérence et Transaction :
• Un SGBD doit supporter :
• Plusieurs utilisateurs  utilisation en parallèle
•  Lecture et écriture Mise à jours
- Tout en garantissant la cohérence de la base de données
• Une transaction est une suite d’instructions qui réussissent ou qui échouent en
totalité (pas de réussite partielle).
• Ou encore c’est ensemble des ordre SQL indivisible faisant passer la base de
donnée d’un état cohérant à un autre en une seule étape

On dit qu’une transaction est ACID :
• Atomique, au sens où on ne peut pas la diviser en une partie qui échoue
et une partie qui réussit ;
• Cohérente, au sens où une fois la transaction terminée, la base est de
nouveau dans un état cohérent ;
• Isolée, au sens où une transaction considère que, pendant son exécution,
les données qu’elle manipule ne sont pas modifiées par une autre
transaction ;
• Durable, au sens où les modifications opérés par la transaction sont
enregistrées de façon permanente (et recouvrables en cas de
reconstruction de la base).
Transactions

• Opération commit , rollback
Transactions
Commit : Validation entière d’une transaction
Rollback : Annule entièrement une transaction
Savepoint : point de contrôle, état de la base où l’on pourra revenir plus tard
Rollback to savepoint nom_save_point
Exemple :
MAJ 1 ;
MAJ 2 ;
savepoint SV__A;
MAJ 3;
MAJ 4 ;
Si ( Condition est vraie)
Rollback to savepoint SV__A;
Fin si
commit
Si la condition est vraie le MAJ 3 et MAJ 4
seront annullées et les MAJ 1 et MAJ 2
seront validées
Si la condition est fausse le commit qui
vient après va valider les 4 mises à jour

• Exemples de
transactions
Insert into tabale_1 values ( ‘val1’, ’val2
‘….,’valn’);
Delete from Table_2 where champ1 like ‘toto’;
Commit;
Transaction
1
Insert into tabale_3 values ( ‘val1’, ’val2
‘….,’valn’);
Commit;
Transaction
2
Transactions

Exercice
Le pseudo code Numéro
Instruction
Questions
Insert into T1 values( ……) ;
Commit ;
Update T2 set col1 where …… ;
Delete from T1 where …… ;
Savepoint SV1 ;
Update T1 set colTT where …… ;
Si (condition est vraie) alors
Update T1 set colTT where …… ;
Commit ;
Sinon rollback to Savepoint
SV1 ;
Fin Si
1
2
3
4
5
6
7
Question 1) Quelles sont les
instructions qui sont validés si la
condition est vraie (
Réponse (écrire juste les numéros
des instructions) :
…………………………………………
…………………………………………
…………………………………………
……………………………………..
Question 2) Quel est le nombre des
transactions qui seront executées
dans ce programme Selon la
condition
Réponse :
- cas condition est vraie
……………………….

CHAPITRE 4 PL/SQL
 Langage SQL en mode procédural (PL/SQL):
1) Introduction et Blocs PL/SQL
2) PL/SQL Déclaration des variables , boucle, alternatives, affichage , GOTO
3) La gestion des exceptions
4) Curseurs
5) Procédures et fonctions stockées
6) Sous-blocs PL/SQL
7) Les Déclencheurs (Triggers)

Pourquoi PL/SQL ?
PL/SQL = PROCEDURAL LANGUAGE/SQL
 SQL est un langage non procédural
 Les traitements complexes sont parfois difficiles à écrire si on ne peut
utiliser des variables et les structures de programmation comme les
boucles et les alternatives
 On ressent vite le besoin d’un langage procédural pour lier plusieurs
requêtes SQL avec des variables et dans les structures de
programmation habituelles
▴
Langage PL/SQL

Principales caractéristiques
 Extension de SQL : des requêtes SQL cohabitent avec les structures de
contrôle habituelles de la programmation structurée (blocs, alternatives,
boucles).
 La syntaxe ressemble au langage Pascal.
 Un programme est constitué de procédures et de fonctions.
 Des variables permettent l’échange d’information entre les requêtes SQL
et le reste du programme
▴
Langage PL/SQL

 PL/SQL peut être utilisé pour l’écriture des procédures stockées et des
triggers.
(Oracle accepte aussi le langage Java)
 PL/SQL convient aussi pour écrire des fonctions utilisateurs qui peuvent être
utilisées dans les requêtes SQL (en plus des fonctions prédéfinies).
▴
Langage PL/SQL
Utilisation de PL/SQL

Utilisation de PL/SQL (suite)
 Le PL/SQL peut être utilisé sous 3 formes :
1
un bloc de code, exécuté comme une unique commande SQL, via un
interpréteur standard (SQLplus ou iSQL*PLus)
2
un fichier de commande PL/SQL
3
un programme stocké (procédure, fonction, trigger)
▴
Langage PL/SQL

Blocs
Un programme est structuré en blocs d’instructions de 3 types :
procédures ou bloc anonymes, SQL> start script.sql ou SQL>@ script.sql
procédures nommées,
fonctions nommées.
Un bloc peut contenir d’autres blocs.
Langage PL/SQL

Structure d’un bloc anonyme
DECLARE
−- d e f i n i t i o n d e s v a r i a b l e s
BEGIN
−− c o d e du programme
EXCEPTION
−− c o d e de g e s t i o n d es erreurs
END ;
Seuls BEGIN et END sont
obligatoires
Les blocs se terminent par un ;
Faisons ensemble un exemple sur SQL developer
Langage PL/SQL

-- Pour une fin de ligne
/* Pour
plusieurs
lignes */
Langage PL/SQL
Commentaires

Langage PL/SQL
Affichage : PROMPT , dbms_output.put_line
Lecture : ACCEPT en précédant par & la variable à lire
pour paramétrer la variable
Exemple : voir les exemples de slide suivant ( n oublier pas
celui du commentaire)

set serveroutput on;
declare
r number;
n1 number;
n2 number;
Begin
n1:=6;
n2 := 12;
r:=n2/n1;
dbms_output.put_line('rrr est egale à : '||r);
exception
when zero_divide then
dbms_output.put_line(‘impossible de diviser par 0’);
end ;
/
Exemple de base d’un bloc PL/SQL
Langage PL/SQL

Déclaration, initialisation des variables
 Identificateurs Oracle :
30 caractères au plus,
commence par une lettre,
peut contenir lettres, chiffres,_ $ et # pas sensible à la casse.
 Portée habituelle des langages à blocs
 Doivent être déclarées avant d’être utilisées
Langage PL/SQL

Déclaration et initialisation
Syntaxe : Nom_variable type_variable := valeur;
Initialisation
Nom_variable := valeur;
Déclarations multiples interdites.
Exemples
age integer;
nom varchar(30);
dateNaissance date;
 ok boolean := true;
▴
Langage PL/SQL

Plusieurs façons d’affecter une valeur à une variable
Opérateur d’affectation n:=
Directive INTO de la requête SELECT.
Exemples
dateNaissance := to_date(’10/10/2004’,’DD/MM/YYYY’);
Attention
Pour eviler les conflits de nommage, préfixer les variables PL/SQL par v_
V_sal:= 4000
Select departement_id into det_id from employees where id_employees =509;
SELECT nom INTO v_nom FROM employees WHERE id_employees =509;
Langage PL/SQL

SELECT ...INTO ...
Instruction :
SELECT expr1,expr2, ...INTO var1, var2, ...
Met des valeurs de la BD dans une ou plusieurs variables var1, var2, ...
Le SELECT ne doit retourner qu’une seule ligne
Avec Oracle il n’est pas possible d’inclure un SELECT sans INTO dans un programme
PL/SQL.
Pour retourner plusieurs lignes, voir la suite du cours sur les curseurs.
▴
Langage PL/SQL

Types de variables
VARCHAR2
Longueur maximale : 32767 octets ;
Exemples :
name VARCHAR2(30);
name VARCHAR2(30) := ’toto’ ;
NUMBER(long,dec)
Long : longueur maximale ;
Dec : longueur de la partie décimale ;
Exemples.
Num_tel number(10);
Salaire number(5,2):=142.12 ;
▴
Langage PL/SQL

DATE
Fonction TO DATE ;
Exemples :
Start_date := to_date(’29-SEP-2003’,’DD-MON-YYYY’);
La vraible sttart date est evaluée et analysée par oracle par 2 chiffre pour le jour, trois
letters pour le mois et l’année sur 4 chirffrer separées par un tiret (-)
start_date := to _date(’29-SEP-2003:13:01’,’DD-MON-YYYY:HH24:MI’) ;
Ici La vraible start_date est evaluée et analysée par oracle par 2 chiffre pour le jour,
trois letters pour le mois et l’année sur 4 chirffrer separées par un tiret (-). Avec aussi
l’heurs et les minutes
BOOLEAN
TRUE
FALSE
NULL
▴
Types de variables (suite)
Langage PL/SQL

Déclaration %TYPE et %ROWTYPE
V_nom emp.nom%TYPE
On peut déclarer qu’une variable est du même type qu’une colonne
d’une table (ou de meme type qu’ autre variable).
V_employe emp%ROWTYPE;
Une variable peut contenir toutes les colonnes d’un tuple d’une table
(la variable v_employe contiendra une ligne de la table emp).
Important pour la robustesse du code
▴
Langage PL/SQL

DECLARE
v_employe EMPLOYEES%ROWTYPE;
v_nom EMPLOYEES.FIRST_NAME%TYPE;
BEGIN
SELECT * INTO v_employe FROM EMPLOYEES
WHERE employee_id=100 ;
v_nom :=v_employe.FIRST_NAME;
v_employe.department_id:=20;
v_employe.employee_id:=7777;
v_employe.EMAIL:='changyah';
INSERT into employees VALUES v_employe;
dbms_output.put_line ('ttt '|| v_employe.employee_id);
END;
Vérifier à bien retourner un seul tuple
avec la reqête SELECT ...INTO ...
▴
Déclaration %TYPE et %ROWTYPE
-Exemple
Langage PL/SQL

Exercice :
a- Créer un bloc PL/SQL pour insérer un nouveau département dans la table
DEPARTEMENTS (DEPT_ID, DEPT_NAME, LOCATION_ID)
- Utiliser la séquence DEPT_ID_SEQ pour générer un numéro de département
(DEPT_ID).
- Créer un paramètre pour lire le nom du département du clavier.
- Laisser le numéro de LOCATION_ID à NULL.
- Afficher le numéro de département qu’on vient d’inserer
b- enregistrer le code dans le fichier scipt1.sql , donner la commande d’exécution
de scipt1.sql .

Solution
set serveroutput ON
ACCEPT p_dept_nom PROMPT ‘Entrer un nom de département : ‘
Declare
Numd number;
BEGIN
INSERT INTO departments VALUES (dept_id_seq.NEXTVAL, '&p_dept_nom', NULL,null);
COMMIT;
Select dept_id_seq.CURRVAL into Numd from dual;
dbms_output.put_line ('num depart inseré est '|| Numd);
END;
/
Execution ( le code est enregistré dans le fichier script1.sql
SQL> start script1.sql
Ou
SQL> @ script1.sql

Exercice 2
Créer un bloc PL/SQL pour supprimer le département créé
précédemment en
-Créant r un paramètre pour le numéro de département à supprimer
,
-A ffichant le nombre de département avant et après la suppression

1
Langage PL/SQL : Commandes
Les alternatives (if , else, elesif, case )
Les boucles (loop, while , for )
Affichage dbms_output.put_line ()
et retour chariot chr(10)
La commande GOTO

Test conditionnel
IF-THEN
IF v_date > ’01−JAN−08’ THEN
V_salaire := V_salaire *1.15;
END I F ;
IF-THEN-ELSE
IF v_date > ’01−JAN−08’ THEN
V_salaire := v_salaire ∗ 1.15;
ELSE
V_salaire := v_salaire ∗ 1.05;
END I F ;
▴

IF-THEN-ELSIF
IF v_nom =’PARKER’ THEN
V_salaire:= V_salaire * 1.15;
ELSIF v_nom =’ SMITH ’ THEN
V_salaire:= V_salaire *1.05
END I F ;
▴
Test conditionnel(2)

CASE
CASE selection
WHEN expression1 THEN resultat1 ou instruction 1
WHEN expression2 THEN resultat2 ou instruction 2
ELSE autre resultat ou autre instruction
END ;
CASE renvoie une valeur qui
vaut resultat1 ou resultat2 ou . . . ou
resultat par défaut
.
Exemple de Case Dans une requette SQL
▴
SELECT last_name, first_name ,job_id,
CASE
WHEN job_id='AD_PRES' THEN 'C est le président'
WHEN job_id='AD_VP ' THEN ' Vice Président chargé de la Administration'
WHEN job_id='FI_MGR' THEN ' Administrateur Financier'
WHEN job_id='FI_ACCOUNT' THEN ' Comptable'
WHEN job_id='AC_ACCOUNT' THEN ' Trésorier'
ELSE 'Autre fonction'
END
FROM employees;

Declare
LN$Num integer := 0 ;
Begin
LN$Num := '&entre' ;
CASE LN$Num
WHEN 1 Then dbms_output.put_line( ' premier' ) ;
WHEN 2 Then dbms_output.put_line( 'deuxieme' ) ;
WHEN 3 Then dbms_output.put_line( 'troisiem' ) ;
ELSE dbms_output.put_line( 'rang supérieur' ) ;
END CASE ;
End ;
/
CASE : Exemple dans un bloc PL/SQL
Case Simple

DECLARE
v_prix_vente NUMBER(9,2);
v_Value NUMBER(9,2) := &v_prix_vente;
v_taux_Commission NUMBER(3,2);
BEGIN
CASE
WHEN v_Value <= 100 THEN v_taux_Commission := 0.03;
ELSE v_taux_Commission := 0.10;
END CASE;
DBMS_OUTPUT.PUT_LINE('Montant de la Commission est : '
|| TO_CHAR(v_taux_Commission * v_Value) || 'Dirhames');
END;
CASE : Exemple dans un bloc PL/SQL
Pour le CASE l'omission de la clause ELSE provoque une erreur
s’il rencontre un cas non traité
Case de recherche

LOOP
instructions ;
EXIT [WHEN condition ] ;
instructions ;
END LOOP ;
WHILE condition LOOP
instructions ;
END LOOP ;
Exemple
LOOP
Monthly_value := daily_value*31
EXIT WHEN monthly_value > 4000;
END LOOP ;
Obligation d’utiliser la commande EXIT
pour éviter une boucle infinie.
▴
Les boucles : LOOP

Exemple : Insérer 10 articles avec la date d’aujourd’hui.
declare
. . .
V_Date DATE;
V_compteur NUMBER( 2 ) := 1 ;
BEGIN
. . .
V_Date := SYSDATE;
LOOP
INSERT INTO article ( Artno , ADate )
VALUES ( v_compteur , v_Date ) ;
V_compteur := V_compteur + 1 ;
EXIT WHEN V_compteur > 1 0;
END LOOP;
. . .
END;/
Les boucles : LOOP

FOR indice IN [ REVERSE ] debut . . fin
LOOP
instructions ;
END LOOP ;
Le mot clef REVERSE
à l’effet escompté.
Exemple
FOR ii IN REVERSE 1..15
LOOP
jj:=ii*31;
END LOOP
▴
Ne pas déclarer indice,
il est déclaré implicitement.
Les boucles : FOR
- La boucle FOR du PL/SQL s'incrémente (ou se décrémente)
forcément de 1 en 1.
- On pourra également utiliser un curseur dans la clause IN
- Vous pouvez cependant simuler un pas supérieur, comme le montre
cet extrait de la doc :
DECLARE
step INTEGER := 2;
BEGIN FOR i IN 1..5
LOOP DBMS_OUTPUT.PUT_LINE (i*step);
END LOOP;
END;
Exemple

GOTO
GOTO <libelé>;
PL/SQL contient aussi la commade GOTO qui permet de
faire le branchement d’un programme d’un point un autre
point durant son execution, ça syntaxe est :

DECLARE
v_compteur NUMBER(2) := 1;
BEGIN
LOOP
v_compteur := v_compteur + 1;
IF v_compteur > 5 THEN
GOTO stop_processing;
END IF;
DBMS_OUTPUT.PUT_LINE('v_compteur est : '
|| v_compteur);
END LOOP;
<<stop_processing>>
DBMS_OUTPUT.PUT_LINE(' la valeur finale de
v_compteur final est ' || v_compteur );
END;
GOTO

Activer le retour écran : set serveroutput on size 10000
Sortie standard : dbms_output.put_line (chaıne);
Concaténation de chaînes : opérateur ||
Exemple
DECLARE
i number (2);
BEGIN
FOR i IN 1 .. 5 LOOP
dbms_output.put_line('Nombre: ‘|| i );
END LOOP;
END ;
/
’
Le caractère / seul sur une ligne déclenche l’évaluation.
▴
Si on veut un retour chariot
on place le caractére suivant:
chr(10)
Affichage

Exemple bis
DECLARE
compteur number(3);
BEGIN
SELECT COUNT( ∗ ) INTO compteur
FROM Etudiant ;
FOR i IN 1.. compteur LOOP
dbms_output.put_line(‘Nombre : ‘|| i);
END LOOP ;
END ;
Affichage

Gestion des Erreurs
 Section Exception
 Anomalie programmeur
 Erreur Oracle

Section Exception
 Notion d’exception: traitements d’erreurs
 Types d’erreurs:
 Erreurs internes Oracle (Sqlcode <> 0)
 Erreurs programme utilisateur
 Règles à respecter
 Définir et donner un nom à chaque erreur
 Associer ce nom à la section Exception (partie declare)
 Définir le traitement dans la partie Exception

Gestion des Exceptions
EXCEPTION
WHEN nom_exception1 THEN
instructions_PL_SQL;
…
WHEN nom_exceptionN Then
instructions PL/SQL;
…
[WHEN OTHERS THEN
instrctions_PL/SQL;]
END;
Sortie du bloc après exécution du traitement
Syntaxe

DECLARE
.....
nom_erreur EXCEPTION;
BEGIN
.....
IF anomalie THEN RAISE nom_erreur ;
.....
EXCEPTION
WHEN nom_erreur THEN traitement;
END;
Gestion des Exceptions
Syntaxe : en cas de déclaration définition

Gestion d’une erreur : exemple
DECLARE
sal_nul EXCEPTION;
sal employees.salary%TYPE;
BEGIN
SELECT salary INTO sal FROM employees where employee_id=60000;
IF sal > 100000
THEN RAISE sal_nul;
Else
dbms_output.put_line(‘vous pouvez augmenter le salaire de vos employés’);
END IF;
dbms_output.put_line(‘ Bye’);
EXCEPTION
WHEN sal_nul THEN
dbms_output.put_line(‘plafond dépassé’);
When zero_divide then
dbms_output.put_line(‘attention ‘);
END;

Exceptions Prédéfinies
• DUP_VAL_ON_INDEX
– Lorsqu’une instruction SQL tente de créer une valeur dupliquée dans
une colonne sur laquelle un index unique a été défini
• INVALID_NUMBER
– Lorsqu’une instruction SQL spécifie un nombre invalide (conversion
d’un caractère à un entité
ex: select * from employees where employee_id=‘Chaine_de_caractère‘
- lors d’une insertion
• NO_DATA_FOUND
– Lorsqu’une instruction Select ne retourne aucune ligne
• TOO_MANY_ROWS
– Une instruction Select ne peut pas renvoyer plus d’une ligne sans
provoquer l’exception TOO_MANY_ROWS
• VALUE_ERROR
– Provoquée dans des situations d’erreur résultant de valeurs
tronquées ou converties ( exp: taille de la variable petite que le
nombre à affecter)
• ZERO_DIVIDE: au cas ou il y a une instruction qui effectue une division par
Zéro

Exemple
Declare emp_Rec employees%ROWTYPE;
Begin
select *
into emp_Rec
from employees
where employee_ID = 777;
Exception
when No_Data_Found then
dbms_output.put_line(‘Aucune donnée retournée’);
when other then null;
End;
/
Aucune donnée retournée
Procedure PL/SQL terminé avec succès.

Déclaration d’une Exception
Declare
pas_comm EXCEPTION;
salaire employees.salary%TYPE;
commi employees.commition%TYPE;
numero employees.employee_id%TYPE;
Begin
Select salary, commition, employee_id into salaire, commi, numero
from employees where employee_id := &num_emp;
If commi = 0 or commi is null
then raise pas_comm
else traitement …
end if;
Exception When pas_comm then
dbms_output.put_line(‘ Pas de commission pour l’employé ID: ’|| numero);
End;
NB: num_emp fait référence à une variable extérieure au bloc
PL/SQL)

Test d’exécution avec SQLCODE et SQLERRM
• SQLCODE
– Fonction prédéfinie qui renvoie le statut d’erreur système de l’instruction
qui vient d’être exécutée (si sans erreur, SQLCODE = 0).
• SQLERRM
– Fonction prédéfinie qui renvoie le message d’erreur associé à la valeur
retournée par SQLCODE (si sans erreur, SQLERRM = ‘ORA-0000’).
Declare
Begin
dbms_output.enable; // equivalente à set serveroutput on
dbms_output.put_line(‘SQLCODE: ‘ || to_char(SQLCODE));
dbms_output.put_line(‘SQLERRM: ‘ || SQLERRM);
End;
/
SQLCODE: 0
SQLERRM: ORA-0000: exécution normale, terminé avec succès
Exemple 1:

Declare
v number;
Begin
select salary into v from employees;
dbms_output.enable; -- equivalente à set serveroutput on
Exception
when TOO_MANY_ROWS then
dbms_output.put_line('SQLCODE:'|| to_char(SQLCODE));
dbms_output.put_line('SQLERRM:' || SQLERRM);
End;
Exemple 2:

Declare
pas_err EXCEPTION;
v number;
Begin
select salary into v from employees where employee_id=100;
if(SQLCODE=0) then raise pas_err;
end if;
Exception
when TOO_MANY_ROWS then
when NO_DATA_FOUND OR TOO_MANY_ROWS then
WHEN pas_err THEN
dbms_output.put_line('C''est corecte ');
End;
Exemple 3: complet

Les curseur
• Définition
– Un curseur est un mécanisme permettant de rechercher
un nombre arbitraire de lignes avec une instruction
SELECT.
• Deux types de curseurs:
– Le curseurs implicite: généré et géré par le noyau pour
chaque ordre SQL d’un bloc
– Le curseur explicite: généré para l’utilisateur pour traiter
un ordre SELECT qui ramène plusieurs lignes.

Quatre Étapes de traitement d’un curseur
explicite
Les curseurs explicites sont traitées en suivant un modèle en
quatre étapes.
 Déclarer le CURSEUR: le curseur doit apparaitre dans la partie
déclaration de bloc pl/sql
 Ouvrir le CURSEUR : par l’instruction OPEN,
 Parcourir les ligne du CURSEUR : par l’ instruction
FETCH.
 Fermer le CURSEUR : une instruction close .

Déclaration d’un curseur explicite
• Se fait dans la section Declare
Syntaxe : cursor nom_curseur is ordre_select
Declare
cursor dept_10 is select first_name , salary From employees
where department_id= 10 order by salary;
nom employees .first_name%TYPE;
salaire employees . salary%TYPE;
Begin
…
End;
Exemple :

• L’ouverture:
– Allocation de mémoire pour le lignes du curseur
– L’analyse syntaxique et sémantique du select
– Le positionnement de verrous éventuels
• L’ouverture se fait dans la section Begin
• Syntaxe: OPEN nom_curseur;
Declare
Begin
…;
open dept_10;
…;
End;
Ouverture d’un curseur : Open

 Les lignes ramenées sont traitées une par une,
la valeur de chaque colonne doit être stockée dans
une variable réceptrice
 Syntaxe:
Fetch nom_curseur into liste_variables;
 Le Fetch ramène une ligne à la fois.
Traitement des lignes : Fetch

Exemple : Fetch
Declare
Begin
Open dept_30;
Loop
Fetch dept_30 into nom, salaire;
If salaire > 2500
then insert into résultat values (nom,salaire);
end if;
exit when salaire >= 5000;
end loop;
…
End;

Fermeture : close
• Syntaxe: Close nom_curseur;
• Action: libère la place de mémoire
Declare
Begin
Open dept_10;
Loop
If salaire > 2500 then
insert into résultat values (nom,salaire);
end if;
exit when salaire >= 5000;
end loop;
close dept_10;
End;

Exemple : close
Declare
Cursor c1 is select first_name, salary from employees order by
sal desc;
v_ename employees. first_name %TYPE;
v_sal employees.salary%TYPE;
Begin
open c1;
loop
fetch c1 into v_ename, v_sal;
Exit when (c1%notfound) ;
insert into resultat values (v_sal, v_ename);
end loop;
close c1
End;

• Définition indicateurs sur l’état d’un curseur.
 %FOUND : nom_curseur%FOUND
 TRUE: le dernier FETCH a ramené une ligne
 FALSE: plus de ligne
 %NOTFOUND: nom_curseur%NOTFOUND
 TRUE: le dernier FETCH n’a pas ramené de ligne
 %ISOPEN: nom_curseur%ISOPEN
 TRUE: le curseur est ouvert
 %ROWCOUNT: nom_curseur%rowcount
 Nbre de lignes ramenées par le Fetch
Les attributs d’un curseur

Pour manipuler les attribut d’un curseur implicite on utilise
SQL%Attribut
Exemples :
 SQL%FOUND ,
SQL% ROWCOUNT
Pour manipuler les attribut d’ un curseur explicite on utilise
nom_curseur%Attribut
Exemples :
nom_curseur%FOUND ,
nom_curseur % ROWCOUNT)
Utilisation des attribut du curseur

Utilisation des attribut du curseur
Curseur Implicite : utilisation de l’attribut par SQL%Attribut
CREATE TABLE temp_Employee9 AS SELECT * FROM Employees;
DECLARE
e_DeptNumber employees.Department_id%TYPE :=9;
BEGIN
DELETE FROM temp_Employee9
WHERE Department_id <> e_DeptNumber;
IF SQL%FOUND THEN – Il y a des enregistrement supprimmée
DBMS_OUTPUT.PUT_LINE('Nombre des enregistrement
supprimés: ‘ || TO_CHAR(SQL%ROWCOUNT));
ELSE
DBMS_OUTPUT.PUT_LINE('AUCUN enregistrement
n''supprimés ');
END IF;
END;

Exemple - %FOUND
Declare
cursor dept_ 30 is select first_name , salary From employees
Begin
Open dept_30;
While dept_30%FOUND Loop
If salaire > 2500 then insert into résultat values (nom,salaire);
end if;
end loop;
close dept_30;
End;

Exemple - %NOTFOUND
Declare
Begin
Open dept_10;
Loop
Exit when dept_10%NOTFOUND;
bdms_output.put_line( nom ||’ ,’ ||salaire);
end if;
end loop;
close dept_10;
End;

Exemple - %ISOPEN
Declare
Begin
If not(dept_10%ISOPEN) then
Open dept_10;
end if;
Loop
Exit when dept_10%NOTFOUND;
insert into résultat values (nom,salaire);
end if;
end loop;
close dept_10;
End;

Exemple - %ROWCOUNT
Declare
Begin
Open dept_10;
Loop
Exit when dept_10%NOTFOUND or dept_10%ROWCOUNT > 15;
If salaire > 2500
then insert into résultat values (nom,salaire);
end if;
end loop;
close dept_10;
End;

Boucle LOOP Exit when pour un curseur
declare
cursor c is
select department_id, first_name from employees
where department_id = 10;
Name employees.first_name%type;
Dept employees. department_id%type;
Begin
Open c;
LOOP
FETCH c into dept, name ;
Exit when c%NOTFOUND ;
dbms_output.put_line(name );
END LOOP;
CLOSE c;
end;
Dans cette boucle on est
obligé d’utiliser :
Open
LOOP
FETCH
CLOSE
Exit when

Utiliser WHILE élimine le
besoin de l’instruction EXIT
WHEN en intégrant l'utilisation
de l'attribut % FOUND.
2 instructions FETCH (Une juste
avant le while et l’autre avant le
END LOOP)
Boucle WHILE pour un curseur
declare
cursor c is select department_id, first_name
from employees
Name employees.first_name%type;
Dept employees.department_id%type;
Begin
Open c;
while c%FOUND loop
dbms_output.put_line(name);
End loop;
CLOSE c;
end;

‰
Elle simplifie la programmation car elle évite d’utiliser explicitement les
instruction open, fetch, close, exit
‰
En plus elle déclare implicitement une variable de type « row » associée
au curseur
Boucle FOR pour un curseur
declare
cursor c is
select department_id, first_name from employees
begin
FOR emp IN c LOOP
dbms_output.put_line(emp.first_name);
END LOOP;
end;

declare
n NUMBER := 14;
CURSOR C IS SELECT * FROM EMPLOYEES WHERE employee_id>= n ;
BEGIN
FOR CUR IN C LOOP
DBMS_OUTPUT.PUT_LINE ( CUR.FIRST_NAME) ;
END LOOP ;
END ;
/
Curseur avec des paramètres
A votre avis, le code suivant est-il valide ?
Non. La requête d’un curseur ne peut pas contenir de variables dont les
valeurs ne sont pas fixées.
Pourquoi ? Parce que les valeurs des ces variables sont susceptibles de
changer entre la déclaration du curseur et son ouverture.
Le remède est un curseur paramétré.

Vous pouvez modifier les lignes de données renvoyées dans un jeu de
résultats en généralisant code PL/SQL grâce à l'utilisation des paramètres.
Les paramètres peuvent être utilisés pour spécifier les critères de sélection
de la requête lorsque vous ouvrez le curseur.
Déclarer curseurs entre parenthèses par nom et type de données, comme
indiqué ici. Lorsque vous avez besoin de spécifier plusieurs parameter pour
un curseurs, séparez les entrées par une virgule.
 La syntaxe est :
CURSOR mycursor (param1 NUMBER, param2, type2 ....,
paramn typen ) IS SELECT ...... FROM tables WHERE
(condition sur les parameters)

Ouverture
On ouvre un curseur paramétré en passant en paramètre
les valeurs des variables :
OPEN Nom_curseur ( liste de sparamètres )
Exemple OPEN enfants ( 1 ) ;
Lecture par la Boucle FOR
FOR variable IN nom_curseur ( liste paramètre s )
LOOP
/∗ instructions ∗/
END LOOP ;

Declare
CURSOR mycursor (param1 number, param2 number) is select Employee_ID ,
salary
from employees where employee_id between param1 and param2;
e_Record mycursor%rowtype;
BEGIN
OPEN mycursor('102','110');
FETCH mycursor INTO e_Record;
loop
DBMS_OUTPUT.PUT_LINE('Salare de ' || e_Record.Employee_ID || ': ' ||
e_Record.Salary ||' $');
FETCH mycursor INTO e_Record;
exit when mycursor%notfound;
end loop;
CLOSE mycursor;
/
Passer des paramètres à un curseur
Exemple Recapitulatif

Exercices :
1) En utilisant un Curseur, Écrivez un programme PL/SQL qui
calcule la moyenne des salaires des employés dont la date de
recrutement est entre 01/01/2002 et 01/01/2005.
Comparer avec la requête ci-dessous, vous devez trouver la
même chose
(SELECT avg(salary) FROM employees
WHERE ( to_date(hire_date,'DD/MM/YY') between '01/01/02' and
'01/01/05' );
2) Refaire la meme question en passant les deux dates
01/01/2002 et 01/01/2005. En paramètre de curseur

Procédures et Fonctions stockées
Décrire les différentes utilisation des procédure
et fonctions
Créer des procédures et fonction stockées
Appeler une procédure et une fonction
Supprimer une procédure et une fonction
Objectifs:

Procédures stockées
Tout comme n’importe quel autre langage procédural, PL / SQL a des
blocs de code qui sont appelées procédures.
Vous pouvez appeler ces procédures par les autres blocs de code, ou
directement à partir de SQL * Plus (ou par un autre programme client).
GRANT CREATE PROCEDURE TO utilisateur_désiré;
Avant de créer des procédure il faut avoir les droits nécessaire

CREATE or replace PROCEDURE Bonjour IS
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Bonjour Tout le monde’ );
END;
Un Simple exemple de procédure
Dans un autre bloc PL/SQL
BEGIN
Bonjour();
END;
Appel de la procédure
Par commande SQL*Plus
exec Bonjour();
Ou bien
Call Bonjour();

CREATE OR REPLACE
PROCEDURE nom_procedure ( paramètres IN , OUT ) IS
BEGIN
Corps_de_la_procedure
END;
nom_procedure : est le nom de la procédure, il doit être significatif
Corps_de_la_procedure: est une suite d’instruction PL/SQL qui
définissent la suite logique de la procédure
Syntaxe générale

Paramètres
Les paramètres sont optionnels dans les procédure, dans
l’exemple que nous avons déjà vu il n y a pas de paramètres
CREATE OR REPLACE
PROCEDURE HELLOWORLD IS
BEGIN
DBMS_OUTPUT.PUT_LINE(’Hello World!’);
END;
Où cas où il y a des paramètres on les introduit comme on le fait
lors de la création des tables  (nom_param type )
Exemple ( N int , titre varchar)

CREATE OR REPLACE
PROCEDURE DISPN (N INT) IS
BEGIN
DBMS_OUTPUT.PUT_LINE(‘N est : ‘ || N);
END;
Nous allons écrire une simple procédure admettant un seul
paramètre
Cette procédure affiche la valeur de nombre N passé
en paramètre
SQL>call DISPN(555)
N est : 555
1 seul paramètre: Exemple

CREATE OR REPLACE
PROCEDURE DISP_AB (A INT, B INT) IS
BEGIN
DBMS_OUTPUT.PUT_LINE(’A + B = ’ || (A + B));
DBMS_OUTPUT.PUT_LINE(’A * B = ’ || (A * B));
END;
Plusieurs paramètres: Exemple
SQL> CALL DISP_AB(17,23);
A + B = 40
A * B = 391

paramètres: Exemple avec une chaine de caractère
CREATE OR REPLACE
PROCEDURE DISP_NAME (NAME VARCHAR) IS
BEGIN
DBMS_OUTPUT.PUT_LINE(’Hi ’ || NAME || ’!’);
END;
SQL> CALL DISP_NAME(’Billal Merssi’);
Hi Billal Berssi !

Quand on ne fait pas d’option les paramètres sont
considérer comme IN par défaut
IN : pour un paramètre en entrer  il est généralement
placé après l’affectation ( := )
OUT: pour un paramètre qui va recevoir des données dans le
corps de la procédure il est généralement placé avant
l’affectation ( := )
IN OUT: pour des paramètre qui sont à la fois des IN et des
OUT
Options : IN, OUT, IN OUT

CREATE OR REPLACE
PROCEDURE SUM_AB (A INT, B INT, C OUT INT) IS
BEGIN
C := A + B;
END;
DECLARE
R INT;
BEGIN
SUM_AB(23,29,R);
DBMS_OUTPUT.PUT_LINE(’SUM IS: ’ || R);
END;
Options : IN, OUT, IN OUT: exemple
Faites appel à la procédure dans un bloc PL/SQL !

CREATE OR REPLACE
PROCEDURE DOUBLEN (N IN OUT INT) IS
BEGIN
N := N * 2;
END;
DECLARE
R INT;
BEGIN
R := 7;
DBMS_OUTPUT.PUT_LINE(’BEFORE CALL R IS: ’ || R);
DOUBLEN(R);
DBMS_OUTPUT.PUT_LINE(’AFTER CALL R IS: ’ || R);
END;
Faites appel à la procédure dans un bloc PL/SQL !
Exemple avec : IN OUT

CREATE PPROCEDURE baisse_prix( nprod IN NUMBER, Taux IN
NUMBER ) IS
BEGIN
if Taux <1 then
UPDATE produit SET PU= PU* ( 1 - Taux) WHERE Nump= nprod ;
end if;
END
Exemple : Créer une procédure qui permet de baisser le prix d'un produit de
la table: Produit (Nump, nomp, pu, qstock)

Une fonction est un bloc PL/SQL nommé qui peut accepter des
paramètres et être appelé.
En règle générale, vous utilisez une fonction pour calculer une
valeur
Une fonction doit comporter une clause RETURN dans l'en-tête,
et au moins une instruction RETURN dans la section exécutable.
Les fonctions peuvent être stockées en tant qu'objets de schéma
dans la base de données en vue d'exécutions répétées.
Fonctions stockées

Fonctions stockées
CREATE [OR REPLACE] FUNCTION num_fonction [(
param1 [mod1] datatype1, param2 [mod2] datatype 2,
….)]
RETURN datatype
IS|AS
Block PL/SQL ;
Syntaxe pour créer une fonction

Paramètre Description
function_name Nom de la fonction.
parameter Nom d'une variable PL/SQL dont la valeur est transmise à
la fonction.
mode Type du paramètre. Seuls les paramètres IN doivent être
déclarés.
datatype Type de données du paramètre.
RETURN datatype Type de données de la valeur RETURN qui doit être fournie
par la fonction.
PL/SQL block Corps de la procédure qui définit l'action exécutée par la
fonction.
Fonctions stockées
Description des paramètres

Fonctions stockées
Exemple de création d’une fonction stockée
get_salaty.sql
create or replace function get_sal
(p_id in employees.employee_id%type)
return number
is
v_salary employees.salary%type:=0;
begin
select salary into v_salary from employees where
employee_id=p_id;
return v_salary;
end ;
/

1- Créez le script pour définir la fonction get_salary. avec un
paramètre IN pour renvoyer une valeur numérique.
2- Exécutez le script pour créer la fonction get_salary.
3- Appelez la fonction dans une expression PL/SQL, pour elle
renverra une valeur à l'environnement appelant, ( par exemple
affichage la valeur )
Remarque:
- La section de traitement des exceptions peut également contenir
une instruction RETURN.
Fonctions stockées
Exemple suite

Fonctions stockées
Appel d'une procédure ou fonction
SQL> Declare
A employees.employee_id%type;
S number
BEGIN
A := &Numero_de_employe; --lire à partir du clavier
S :=get_sal (A);
dbms_output.put__line(S );
END ;
/

Exemple 2
-Créer une fonction TAX qui sera appelée à partir d'une instruction SELECT.
- La fonction accepte un paramètre NUMBER et renvoie la taxe après avoir
multiplié la valeur du paramètre par 0,08.
Create or replace function tax( p_value in number) Return number is
Begin
Return (p_value * 0.08);
End tax;
Fonctions stockées
SELECT employee_id, first_name,tax(salary) FROM employees
WHERE tax(salary)>(SELECT MAX(tax(salary)) FROM employees
WHERE department_id = 30) ORDER BY tax(salary) DESC;
- Appelez la fonction TAX au sein d'une interrogation affichant:
le code, le nom le prélèvement fiscal de l'employé dont la tax est sup au
max des tax de département 30
Appel d'une procédure ou fonction (suite)

Si la base de données évolue, il faut recompiler les procédures
existantes pour qu’elles tiennent compte de ces modifications
La commande est la suivante:
ALTER { FUNCTION | PROCEDURE } nom COMPILE
Exemple:
ALTER PROCEDURE Baisse_prix COMPILE;
ALTER FUNCTION NomClient COMPILE;
Fonctions stockées
Modification d’une procédure ou fonction

Lorsqu'une fonction stockée n'est plus nécessaire, vous pouvez
la supprimer en utilisant une instruction SQL
Pour supprimer une fonction stockée en exécutant
la commande SQL
DROP FUNCTION nom_fonction
DROP PROCEDURE nom_procedure;
La commande CREATE OR REPLACE est comparé à
DROP puis CREATE
Supprimer des fonctions et procédure
Fonctions stockées

•Un bloc PL/SQL peut contenir un sous bloc:
Declare
Variables
Begin
…..
Declare
Variables
Begin
….
End;
…..
End;
Les sous-blocs

Declare
a number; b varchar2(30); c number;
Begin
a:=10; b:='Imagination'; c:= 20;
Declare
d number;
Begin
d:=c+5;
a:=40 ;b:='programmation';
End;
b:=b||' Esprit'; a:=a+d;
dbms_output.put_line(a||'' ''||b||'' ''||c));
End;
Exemple
Les sous-blocs

Les Déclencheurs (Triggers) DANS PL/SQL
 Définir un Déclencheur (Trigger)
 Décrire les différents types de triggers
 Décrire les triggers de la base de données et leurs utilisation
 Créer des triggers
 Décrire les régles de déclenchement des triggers
 Gérer ( supp. , modif, dé/activation les triggers

Définition :
Un Trigger : Est un bloc ou d'une procédure PL / SQL
associé à une table, une vue, un schéma ou à une donnée
qui s’exécute implicitement(automatiquement) à chaque
fois qu'un événement particulier a lieu.
Type de Triggers
Triggers d’application: est déclenché chaque fois qu'un événement se
produit avec une application particulière
Triggers base de données: est déclenché chaque fois qu'un
événement de données (comme DML) ou un événement du système
(telles que l'ouverture de session ou d'arrêt) se produit sur un schéma
ou base de données

Directives pour la conception Triggers
Vous pouvez concevoir les Triggers pour :
 Effectuer des actions connexes
 Centraliser des opérations globales
Vous ne devez pas concevoir Triggers Si :
 Leurs fonctionnalités est déjà intégrée dans le serveur Oracle
 ils dupliquent la même tache d'autres Triggers
Vous pouvez créer des procédures stockées et les invoquer dans un
Triggers, si le code PL / SQL est très longue.
L'utilisation excessive de Triggers peut entraîner des interdépendances
complexes, ce qui peut être difficile à maintenir dans de grandes
applications

CREATION de TRIGGER
CREATE [OR REPLACE] TRIGGER nom_trigger
Quand
Evenement 1 [OR Evenement 2 OR Evenement3]
ON nom_Objet
[[REFERENCING OLD AS old | NEW AS new]
FOR EACH ROW // pour chaque ligne
[WHEN (condition)]]
Begin
Corps de trigger (PL/SQL bloc )
End;

nom_trigger : unique pour les trigger du meme schéma.
Quant : indique quand le trigger va se déclancher en fonction
avec l’evenement qui va se passer dans la BD :
BEFORE, AFTER, et INSTEAD OF.
Evenement : identifie l’opération DML qui provoque le declenchement
INSERT, UPDATE [OF column], et DELETE.
Nom_objet : indique la table ou la vue associés au trigger.
Les composantes de la syntaxe de creation de Triggers :

Pour le trigger ligne vous pouvez specifier :
REFERENCING : pour corréler les valeur old et new pour la ligne
courante (par default OLD et NEW)
FOR EACH ROW : pour indiquer que le trigger est une trigger ligne
WHEN : clause pour appliquer un filtre, qui sera mis entre
parentheses,
Corps de trigger : C’est l’action à efectuer par le trigger, qui est
implementé comme suit:
 Un bloc anonyme PL/SQL (DECLARE ou BEGIN, et
un END)
 Appel à une procedure/fonction stoquée ou bien un
package (CALL , EXECUTE)
Les composantes de la syntaxe de creation de Triggers
(Suite) :

Le type de trigger DML determine Si le Corps de trigger s’exécute pour
chaque ligne ou une seule fois pour l’evenement déclanchant:
Type 1: Les trigger de table (Trigger STATEMENT) :
Excecutés une fois pour l’evenement déclanchante
C’est le type par défaut des triggers
Déclanchés meme s’il n y a aucune ligne affécté par l”evnement
Type 2: Les Triggers ligne :
Exécutés « séparément » pour chaque ligne affécté par l”evnement
Ne sont pas executé Si l’evenement n’a affecté aucun ligne
Sont indiqués en précisant la clause FOR EACH ROW
Types de Triggers DML

Quand le trigger se déclence ?
BEFORE: (Avant) Executer le trigger avant de proceder à
l’evenement DML sur la table.
AFTER (Aprés) Executer le trigger aprés l’evenement DML sur la
table.
INSTEAD OF: (au lieu de) Executer le corps de trigger au lieu de
l’évenement. Ceci est utilisé pour les VUES qui ne sont pas
modifiable
Note: Si plusieurs Triggers sont définis pour un meme objet leurs
déclancement est arbitraire

Séquence de déclenchement de Trigger
Utilisez la séquence de déclenchement suivante pour un Trigger
sur une table quand une seule ligne est manipulé:
INSERT INTO departments (department_id,department_name,
location_id) VALUES (400, 'CONSULTING', 2400);
.…
BEFORE avant le trigger tables
BEFORE avant le trigger ligne
AFTER Aprés le trigger ligne
AFTER Aprésle trigger tables
… … …

UPDATE employees SET salary = salary * 1.1
WHERE department_id = 30;
BEFORE avant le trigger tables
AFTER (Aprés )le trigger tables
BEFORE (avant) le trigger ligne
AFTER (aprés) le trigger ligne
BEFORE (avant) le trigger ligne
AFTER (aprés) le trigger ligne
….
….

Les types d’événement et le corps de triggers
Événement de trigger :
Determine quel Order DML va déclencher l’execution de
trigger. Ils sont :
INSERT
UPDATE [OF column]
DELETE
Corps de triggers :
Détermine l'action a effectuée
Est-ce un bloc PL / SQL ou un appel à une procédure

Application
INSERT INTO EMPLOYEES...;
table EMPLOYEES
trigger SECURE_EMP
CREATE OR REPLACE TRIGGER secure_emp
BEFORE INSERT ON employees
BEGIN
IF (TO_CHAR(SYSDATE,'DY') IN ('DIM.','SAM.')) OR
(TO_CHAR(SYSDATE,'HH24:MI') NOT BETWEEN '08:00' AND ‘18:00')
then
RAISE_APPLICATION_ERROR(-20500,'Vous ne pouvez inserer dans la table
employes que durant les heures de travail');
END IF;
END;
Création d’un trigger pour sécurisé l’insertion dans la table employees

Base de donnees Avancees et Intro à NoSQL.ppt

Base de donnees Avancees et Intro à NoSQL.ppt

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Base de donnees Avancees et Intro à NoSQL.ppt

Similaire à Base de donnees Avancees et Intro à NoSQL.ppt (20)

Dernier

Dernier (20)

Base de donnees Avancees et Intro à NoSQL.ppt