PL/SQL
Année universitaire: 2024-2025
1. Introduction
2. Structure d’un bloc PL/SQL
3. Les variables
4. Assignations des variables et affectation
5. Accès à la base de données et ordres SQL
PLAN DU 6. Structure de contrôle
COURS 7. Les curseurs
8. Gestion des erreurs et des exceptions
9. Les procédures et les fonctions stockées
10. Les packages
11. Les triggers
1. INTRODCUTION
2. STRUCTURE D’UN BLOC PL/SQL
3. LES VARIABLES
PARTIE 1 4. ASSIGNATIONS DES VARIABLES ET
AFFECTATION
5. ACCÈS À LA BASE DE DONNÉES ET
ORDRES SQL
PL/SQL (Procedural Language/Structured Query
Language) est un langage de programmation utilisé
avec les bases de données Oracle. Il combine les
fonctionnalités de SQL, le langage de requête standard
pour les bases de données, avec des capacités de
programmation procédurale.
Il permet de combiner des requêtes SQL (SELECT,
INSERT, UPDATE et DELETE) et des instructions
INTRODUCTION procédurales (boucles, conditions...),
• Créer des traitements complexes destinés à être
stockés sur le serveur de base de données (objets
serveur),
• Les structures de contrôle habituelles d’un langage
(IF, WHILE…) ne font pas partie intégrante de la
norme SQL. Oracle les prend en compte dans
PL/SQL.
Caractéristiques de PL/SQL:
1. Blocs de code: PL/SQL organise le code en blocs, chacun
contenant trois sections principales : la déclaration, l'exécution et
la gestion des exceptions.
2. Procédures et fonctions: il est possible de définir des procédures
et des fonctions pour encapsuler des logiques réutilisables.
3. Gestion des erreurs: PL/SQL permet de gérer les exceptions, ce
qui aide à traiter les erreurs de manière contrôlée.
INTRODUCTION 4. Intégration avec SQL: Il permet d'exécuter des instructions SQL
directement à l'intérieur des blocs PL/SQL, ce qui facilite la
manipulation des données.
5. Variables et types de données: PL/SQL prend en charge les
variables, les types de données personnalisés, et les structures de
contrôle (comme les boucles et les conditions).
6. Performances: En regroupant plusieurs opérations en un seul
bloc PL/SQL, il est possible d’améliorer les performances par
rapport à l'exécution de plusieurs requêtes SQL indépendantes.
Cas d’utilisation:
Automatisation des tâches: PL/SQL est souvent
utilisé pour automatiser les processus de base de
données, comme les sauvegardes ou les mises à jour.
INTRODUCTION Développement d’applications: Il est utilisé dans le
développement d'applications d'entreprise qui
nécessitent une logique métier complexe.
Triggers: PL/SQL permet de créer des triggers qui
exécutent automatiquement des actions en réponse
à des événements dans la base de données.
INTRODUCTION
Oracle
Client
Moteur PL/SQL
Code Procédurale
PL/SQL Bloc
PL/SQL Intructions procédurales
ARCHITECTURE SQL
Instructions SQL Moteur SQL
Dans un environnement
client/serveur, chaque
instruction SQL donne lieu à
l’envoi d’un message du client
vers le serveur suivi de la
réponse du serveur vers le
client.
PERFORMANCE
DE PL/SQL
Un bloc PL/SQL donne lieu à
un seul échange sur le réseau
entre le client et le serveur. Les
résultats intermédiaires sont
traités côté serveur et seul le
résultat final est retourné au
client.
Caractéristique SQL PL/SQL
Type de langage Langage de requête structuré Langage de programmation
procédural
Utilisation Interroger et manipuler des Logique métier, traitement de
données données
Structure Instructions individuelles Blocs de code (déclaration,
exécution, exception)
Gestion des erreurs Limitée (généralement une erreur Gestion des exceptions avancée
arrête l’exécution)
COMPARAISON Variables Pas de déclaration de variables Support pour la déclaration et
ENTRE SQL ET l’utilisation de variables
Fonctionnalités Requêtes, jointures, agrégations Procédures, fonctions, triggers,
PL/SQL packages
Contrôle de flux Non disponible Structures de contrôle (boucles,
conditions)
Performance Peut nécessiter plusieurs appels Regroupement des opérations
pour des opérations complexes pour réduire les allers-retours
Persistance Non persistant (les données ne Peut contenir des procédures et
sont pas conservées) fonctions persistantes dans la
base de données
Interopérabilité Utilisé avec n’importe quel SGBD Spécifique aux bases de données
compatible SQL Oracle
PL/SQL est un langage structuré en blocs constitués
d’un ensemble d’instructions;
Un bloc PL/SQL peut être externe, on dit alors qu’il
STRUCTURE est anonyme, ou alors stocké dans la base de
données sous forme de procédure, fonction ou
D’UN BLOC trigger (on lui affecte un nom);
PL/SQL
Un bloc PL/SQL contient trois parties:
1. Une partie déclaratives:
2. Une partie exécutable;
3. Une partie pour la gestion des exceptions
• La zone DECLARE sert à la déclaration des variables, des constantes, ou
[DECLARE]
des curseurs
..........
..........
• La zone BEGIN constitue le corps du programme.
BEGIN
• Définir les instructions exécutables
..........
STRUCTURE ..........
D’UN BLOC [EXCEPTION]
• La zone EXCEPTION permet de préciser les actions à entreprendre
..........
PL/SQL ..........
lorsque des erreurs sont rencontrées (pas de référence article trouvée pour
une insertion, ...).
END ;
• Le END répond au BEGIN précédent, il marque la fin du script.
/
• Le / permet de terminer le bloc PL/SQL
LES TYPES DE
BLOCS
PL/SQL
L’emplacement d’une variable
DECLARE
• Section DECLARE : déclaration de
• Variables locales simples
• Variables tableaux --déclarations
• cursors
• Section BEGIN
BEGIN
• Section des ordres exécutables
VARIABLES • Ordres SQL --exécutions
• Ordres PL/SQL EXCEPTION
• Section EXCEPTION
• Réception en cas d’erreur
• Exceptions SQL ou utilisateur --erreurs
END;
/
Déclarer des variables PL/SQL
Identifier [CONSTANT] datatype [NOT NULL] [:= | DEFAULT expr];
Exemples
VARIABLES DECLARE
v_DateNaissance DATE;
v_Ndept NUMBER(2) NOT NULL :=10;
v_Ville VARCHAR2(13) := ‘Rabat’;
c_CodeP CONSTANT NUMBER :=1400;
v_valide BOOLEAN :=TRUE;
Déclarer des variables PL/SQL
Les types d’oracle
VARIABLES
Déclarer des variables PL/SQL
Les types d’oracle
VARIABLES
Variables basées sur un type ou variables typées
La déclaration de variables PL/SQL en utilisant l’attribut
%TYPE permet de définir le type d’une variable en fonction du
type d’une colonne dans une table.
vsalaire employe.salaire%TYPE;
vnom etudiant.nom%TYPE;
vcomm vsalaire%TYPE;
VARIABLES
vsalaire employe.salaire%TYPE;
Cette déclaration crée une variable vsalaire qui prendra le
même type que la colonne salaire de la table employe. Cela
garantit que vsalaire a le même type de données que la
colonne même si celle-ci change dans la base de données.
Remarque: NOT NULL ne s’applique pas aux variables
déclarées avec %TYPE.
Variables basées sur un type ou variables typées
Caractéristiques des variables typées:
1. Liées à une table: elles sont directement liées au type
d’une colonne d’une table, ce qui garantit que leur type
est toujours conforme à celui de la colonne.
VARIABLES 1. Cohérence des types: si le type de la colonne change
dans la base de données, les variables typées
s’ajusteront automatiquement lors de la compilation,
ce qui réduit le risque d’erreurs de type.
1. Facilité de maintenance: elles simplifient la
maintenance du code, car nous n’avons pas besoin de
modifier manuellement le type des variables si les
définitions de la table changent.
Variables basées sur un type ou variables typées
%ROWTYPE est un attribut qui permet de déclarer une
variable qui représente une ligne complète d’une table. La
variable contiendra toutes les colonnes de la table avec
leurs types respectifs.
vemploye employe%ROWTYPE;
VARIABLES vetudiant etudiant%ROWTYPE;
vemploye employe%ROWTYPE;
Cette déclaration crée une variable vemploye qui peut
contenir une ligne entière de la table employe. Tous les
champs de la table seront accessibles via cette variable.
Variables basées sur un type ou variables typées
Avantages de %ROWTYPE
1. Simplicité: permet de manipuler facilement des
lignes complètes sans avoir à déclarer chaque
colonne individuellement.
VARIABLES 2. Cohérence: si la structure de la table change (ajout
ou suppression de colonnes), il n’est pas nécessaire
de modifier la déclaration de la variable.
1. Clarté: rend le code plus lisible et maintenable en
représentant directement les lignes des tables.
VARIABLES
Définition d’une structure
Une structure c’est quoi ?
• Type composé
• Permet de stocker des données structurées = enregistrement
• Syntaxe de déclaration d’un enregistrement
TYPE<nom_structure> IS RECORD ( <nom_champ1> TYPE [NOT NULL]
[:=EXPRESSION1], [, . . . ] );
• Syntaxe d’utilisation d’un enregistrement
<nom_enregistrement> <nom_structure>
VARIABLES
Exemple de structure
DECLARE
TYPE adresse IS RECORD (quartier varchar2(50),
code_p integer (5),
ville varchar2(50),
pays varchar2(50));
Mon_adresse adresse;
BEGIN
Mon_adresse.quartier:= ‘quartier les fleurs’;
Mon_adresse.code_p:=22000;
Mon_adresse.ville:=‘Casablanca’;
Mon_adresse.pays:=‘Maroc’;
DBMS_OUTPUT.PUT_LINE(Mon_adresse.quartier | | ‘__’ | | Mon_adresse.code_p);
END;
/
Type de variable
Type de variable: borné
SUBTYPE <nom_type> IS TYPE [ (constraint) ] [NOT NULL]
VARIABLES SET SERVER OUTPUT ON;
DECLARE
SUBTYPE type_nombre is number (3,0);
Commission type_nombre;
BEGIN
Commission:=123;
DBMS_OUTPUT.PUT_LINE (‘Valeur de commission est: ‘ | | Commission);
END;
/
Entrée/sortie PL/SQL
Il est possible d’utiliser des fonctions prédéfinies
d’entrée/sortie. Ces fonctions servent essentiellement
durant la phase de test des procédures PL/SQL.
• DBMS_OUTPUT.PUT_LINE (‘Test: ‘ || message); est utilisé
pour afficher des messages ou le contenu d’une variable
VARIABLES • ACCEPT msg PROMPT: pour entrer une valeur
SET SERVEROUTPUT ON;
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Bonjour tout le monde!’);
END ;
/
Bonjour tout le monde !
LES TABLEAUX
• Syntaxe de déclaration
TYPE <nom_tableau> IS TABLE OF <type_valeur> INDEX
BY {PLS_INTEGER | BINARY_INTEGER |
VARCHAR2(TAILLE) };
VARIABLES • Syntaxe d’utilisation
<nom_variable> <nom_tableau>
TABLEAUX D’ENTIERS
DECLARE
TYPE tableau IS TABLE OF INTEGER NOT NULL INDEX BY
BINARY_INTEGER;
Tab tableau;
BEGIN
VARIABLES Tab(1):=23;
Tab(2):=34;
Tab(3):=57;
DBMS_OUTPUT.PUT_LINE(……….):
END;
/
TABLEAUX DE STRUCTURE
SET SERVEROUTPUT ON;
DECLARE
TYPE salarie IS RECORD (
nom VARCHAR2(50),
prenom VARCHAR2(50),
fonction VARCHAR2(30)
);
TYPE tableau IS TABLE OF salarie NOT NULL INDEX BY BINARY_INTEGER;
Tab tableau;
BEGIN
-- Initialisation des enregistrements
Tab(1).nom := 'Kadiri';
Tab(1).prenom := 'Kenza';
Tab(1).fonction := 'Ingénieur';
Tab(2).nom := 'Rahmouni';
Tab(2).prenom := 'Ahmed';
Tab(2).fonction := 'Chef de projet';
-- Affichage des résultats
DBMS_OUTPUT.PUT_LINE(Tab(1).nom || '_' || Tab(1).prenom || '_' || Tab(1).fonction);
DBMS_OUTPUT.PUT_LINE(Tab(2).nom || '_' || Tab(2).prenom || '_' || Tab(2).fonction);
END;
/
TABLEAUX PREDIMENSIONNES
• Syntaxe de déclaration
TYPE nom_tableau is varray(TAILLE) of type_valeur not null;
• Syntaxe d’utilisation
<nom_variable> <nom_tableau>
TABLEAUX PREDIMENSIONNES
Exemple
SET SERVEROUTPUT ON;
DECLARE
-- Déclaration d'un VARRAY
TYPE tableau IS VARRAY(2) OF VARCHAR2(30) NOT NULL;
Tab tableau; -- Déclaration de la variable de type tableau
BEGIN
-- Initialisation du VARRAY
Tab := tableau('Salmi', 'Nada');
END;
/
ASSIGNATION
DES
VARIABLES ET
AFFECTATION
syntaxe
variable:= expression;
ASSIGNATION
DES
VARIABLES ET var:=150;
AFFECTATION nom:=‘Idrissi’;
prenom=‘Souad’;
ACCES A LA
BASE DE
DONNEES ET
ORDRES SQL
ACCES A LA BASE DE DONNEES ET ORDRES SQL
ORDRE SELECT
Interroger une base de données Oracle avec PL/SQL
Renvoyer un seul enregistrement
Syntaxe:
o SELECT EXPRESSION1 [,…] INTO VARIABLE1 [,…] FROM
TABLE [WHERE PREDICAT];
o SELECT * INTO STRUCTURE FROM TABLE [WHERE
PREDICAT];
ACCES A LA BASE DE DONNEES ET ORDRES SQL
ORDRE SELECT: EXEMPLE
DECLARE
Code number;
Libelle varchar2(30);
BEGIN
Select code_cat, lib_cat into code,libelle from categories where
fonction=‘directeur’;
DBMS_OUTPUT.PUT_LINE (‘le code est:’ || Code|| ‘le libelle est:’ ||Libelle);
END;
ACCES A LA BASE DE DONNEES ET ORDRES SQL
ORDRE SELECT: EXEMPLE
SET SERVEROUTPUT ON;
DECLARE
Code NUMBER;
Libelle VARCHAR2(30);
BEGIN
SELECT code_cat, lib_cat INTO code, libelle FROM categories WHERE fonction = ‘RH';
DBMS_OUTPUT.PUT_LINE('Le code est: ' || Code || ' | Le libelle est: ' || Libelle);
END;
/
ACCES A LA BASE DE DONNEES ET ORDRES SQL
INSERT EN PL/SQL
Syntaxe:
INSERT INTO <nom_table> VALUES <variable_enregistrement>;
ACCES A LA BASE DE DONNEES ET ORDRES SQL
UPDATE EN PL/SQL
Syntaxe:
UPDATE <nom_table> SET <nom_champ> = <variable_enregistrement> [WHERE
PREDICAT];
ACCES A LA BASE DE DONNEES ET ORDRES SQL
DELETE EN PL/SQL
Syntaxe:
DELETE <nom_table> [WHERE PREDICAT];
ACCES A LA BASE DE DONNEES ET ORDRES SQL
LES ATTRIBUTS DES ORDRES SQL
• SQL%FOUND
• Type BOOLEAN
• Renvoie TRUE si la précédente exécution (INSERT, UPDATE ou DELETE) a
modifié des enregistrements
• SQL%NOTFOUND
• Type BOOLEAN
• Renvoie TRUE si la précédente exécution (INSERT, UPDATE ou DELETE) n’a
modifié aucun enregistrement
• SQL%ROWCOUNT
• Type number
• Renvoie le nombre de ligne par la précédente exécution
ACCES A LA BASE DE DONNEES ET ORDRES SQL
CLAUSE SQL RETURNING
• Fonction qui permet de renvoyer les valeurs de champs des enregistrements
affectés par les ordres INSERT, UPDATE ou DELETE
• Limites
• Inutilisable avec un ordre INSERT qui insère plusieurs enregistrement à partir
d’une sous-requête
• Impossible d’utiliser « * » pour retourner l’ensemble des champs insérées
dans l’enregistrement
INSTRUCTIONS
DE BASE
• Objectifs
TRAITEMENTS
• Décrire les instructions de contrôle
ITERATIFS
• Apprendre à utiliser les traitements conditionnels
IF condition THEN
instruction1 ;
instruction 2 ;
……..
IF_THEN_END_IF instruction n ;
END IF;
Exemple
DECLARE
A integer := 120;
B integer := 20;
BEGIN
IF_THEN_END_IF IF A>B THEN
DBMS_OUTPUT.PUT_LINE(‘A est supérieur à B');
END IF;
END;
L’instruction IF-ELSE est une structure conditionnelle
composée d’une condition. Si cette condition est vraie,
alors les instructions après le IF sont exécutées.
Si la condition est fausse, ce sont les instructions sous
le ELSE qui sont exécutées.
IF_THEN_ELSE IF condition1 THEN
instruction1;
instruction 2;
ELSE
instruction3;
END IF;
Exemple
DECLARE
A integer := 120;
B integer := 20;
BEGIN
IF_THEN_ELSE IF A>B THEN
DBMS_OUTPUT.PUT_LINE(‘A est supérieur à B');
ELSE
DBMS_OUTPUT.PUT_LINE(‘A est inférieur à B');
END IF;
END;
IF condition1 THEN
instruction1;
instruction 2;
ELSIF CONDITION2 THEN
IF_THEN_ELSIF instruction3;
ELSIF CONDITION3 THEN
instruction4;
ELSE instruction5;
END IF;
Exemple
IF A=B THEN
DBMS_OUTPUT.PUT_LINE(‘A apartient à la
catégorie A');
ELSIF A=C THEN
DBMS_OUTPUT.PUT_LINE(‘A appartient à la
IF_THEN_ELSIF catégorie B');
ELSE IF A=D THEN
DBMS_OUTPUT.PUT_LINE(‘A appartient à la
catégorie C');
ELSE DBMS_OUTPUT.PUT_LINE(‘A appartient à la
catégorie D');
END IF;
Dans le langage SQL, la commande
« CASE…WHEN… » permet d’utiliser des conditions
de type « si/sinon » pour retourner un résultat
disponible entre plusieurs possibilités.
TRAITEMENTS • Case avec recherche
CONDITIONNELS • Syntaxe
AVEC CASE CASE
WHEN <condition_plsql> THEN <sequence de
commandes>
[ ELSE ] <sequence de commandes>
END CASE;
Exemple
DECLARE
Mention char(1);
BEGIN
CASE
TRAITEMENTS WHEN Mention=‘T’ THEN
CONDITIONNELS DBMS_OUTPUT.PUT_LINE(‘Mention Très bien’);
AVEC CASE WHEN Mention=‘B’ THEN
DBMS_OUTPUT.PUT_LINE(‘Mention bien’);
ELSE
DBMS_OUTPUT.PUT_LINE(‘Mention Passable’);
END CASE.
END;
LES BOUCLES
• Permet de répéter une séquence de commandes
• Syntaxe :
LOOP LOOP
Commandes pl/sql ;
EXIT WHEN <condition>;
END LOOP;
Exemple
DECLARE
Compte number;
BEGIN
LOOP LOOP
DBMS_OUTPUT.PUT_LINE(Compte);
Compte:=Compte+1;
EXIT WHEN Compte>10;
END LOOP.
END;
DECLARE
BEGIN
FOR FOR i IN 1..10 LOOP
DBMS_OUTPUT.PUT_LINE(i);
END LOOP;
END;
Permet de répéter une séquence de commandes tant que
la condition reste vraie
Syntaxe
WHILE WHILE <condition> LOOP
Commnades pl/sql;
END LOOP;
Exemple
DECLARE
i integer;
BEGIN
WHILE WHILE i<10 LOOP
DBMS_OUTPUT.PUT_LINE (i);
i:=i+1;
END LOOP;
END;
• Permet de répéter une séquence de commandes une
fois pour chaque élément dans l’intervalle délimité par
deux expressions
FOR • Syntaxe
FOR <indice> IN [ REVERSE ] <borne_inf>. .
<borne_sup> LOOP
Commande pl/sql;
END LOOP;
