Environnement de développement de

BD : Le langage PL/SQL

Samya SAGAR Ep. NAOUAR

 Introduction

2 SAGAR Samya
Pourquoi un langage de programmatio ?

3 SAGAR Samya
Pourquoi PL/SQL ?
 SQL est un langage ensembliste, non procédural
 La nature relationnelle, déclarative de SQL rend l’expression des requêtes
très naturelle
…mais les applications complexes exigent plus :
 Pour la facilité et l’efficacité de développement : gérer le contexte et lier entre elles
plusieurs requêtes, créer des librairies de procédures cataloguées réutilisables
 Pour l’efficacité de l’application : diminuer le volume des échanges entre client et serveur
(un programme PL/SQL est exécuté sur le serveur)
 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
Nécessité d’étendre les fonctionnalités de SQL.

4 SAGAR Samya
Présentation de PL/SQL
 PL/SQL = Procedural Language / Structured Query Language
 Langage procédural d’Oracle corporation étendant SQL.
 Extension du langage standard SQL par des capacités procédurales.

 PL/SQL permet de combiner la puissance et les avantages d’un

langage de programmation classique (structures conditionnelles,
boucles…) avec la puissance et la flexibilité qu'offre SQL ;
 Les instructions de manipulation des données, de description des
données, de contrôle des transactions,
 les fonctions SQL peuvent être utilisées avec la même syntaxe.

5 SAGAR Samya
Principales caractéristiques de PL/SQL
 PL/SQL: Langage procédural de 4ème génération
 La syntaxe ressemble au langage Ada
 PL/SQL = la plupart des déclarations SQL combinées avec les
principales instructions des langages de programmation
 Déclaration de variables typées et constantes
 Des variables permettent l’échange d’information entre les requêtes SQL et
le reste du programme
 Traitements itératifs
 Traitements conditionnels
 Définition de procédures et fonctions
 Gestion des erreurs à l'exécution

6 SAGAR Samya
Avantages
 Support de SQL, y compris en dynamique : un paramétrage et la création
d'ordres SQL dynamiques
 Amélioration des performances: permet le traitement par bloc de SQL et
donc optimise le trafic réseau
 Portabilité: indépendant du système d'exploitation et des plate-formes
 Intégration avec Oracle: supporte tous les types de données SQL
 Utilisation de variable de stockage et de type simple et structuré
dynamique (%TYPE, %ROWTYPE), et la gestion des structures de contrôle,
augmente la capacité de traitement des données
 Traitements plus complexes, notamment pour la gestion des curseurs, cas
particuliers et des erreurs (traitement des exceptions), accroît les
possibilités de traitement
 Utilisation de librairies standards prédéfinies (supplied PLSQL
packages, comme les RDBMS_xxx),

7 SAGAR Samya
Utilisation de PL/SQL
 PL/SQL peut être utilisé pour l’écriture des méthodes
(fonctions et procédures) de type, triggers, packages,
procédures et fonctions stockées.
 Il convient aussi pour écrire des fonctions utilisateurs qui
peuvent être utilisées dans les requêtes SQL (en plus des
fonctions prédéfinies)
 Il est aussi utilisé dans des outils Oracle, Forms et Report en
particulier
 Le PL/SQL peut être utilisé sous 3 formes :
 un bloc de code, exécuté comme une commande SQL, via un interpréteur
standard (SQL+ ou iSQL*PLus); « Bloc anonyme »
 un fichier de commande PL/SQL
 un programme stocké (procédure, fonction, package ou trigger)

8 SAGAR Samya
Ordres SQL supportés dans PL/SQL
 Seules les instructions du langage de manipulation de
données (LMD) et certaines instructions de gestion de
transaction sont supportés, à savoir :

 INSERT, UPDATE, DELETE, SELECT,

 COMMIT, ROLLBACK, SAVEPOINT,
 LOCK TABLE,
 SET TRANSACTION READ ONLY.

9 SAGAR Samya
Requêtes SQL
 Chaque requête ‘client’ est transmise au serveur de
données pour être exécutée avec retour de résultats

CLIENT SERVEUR
INSERT INTO … Exécute INSERT
Résultat
DELETE FROM … Exécute DELETE
Résultat
UPDATE … Exécute
Résultat
UPDATE
SELECT …
Exécute SELECT
……. Résultat

10 SAGAR Samya
Bloc PL/SQL
 Le bloc de requêtes est envoyé sur le serveur. Celui-ci
exécute le bloc et renvoie 1 résultat final.

CLIENT SERVEUR

BEGIN
Exécution
INSERT …
SI …. ALORS du bloc
SELECT … PL/SQL
FSI
END;
Résultat

11 SAGAR Samya
 Structure d’un programme

12 SAGAR Samya
Le bloc PL/SQL
 PL/SQL est un langage structuré en blocs, constitués d'un
ensemble d'instructions et qui ne génère qu'un accès à la base.
 Types de bloc PL/SQL
 Bloc anonyme
 Stocké en-dehors de la base de donnée
 Compilé et exécuté à la volée
 Procédure stockée
 Compilée séparément
 Stockée de façon permanente dans la BD
 Déclencheur (trigger)
 Procédure stockée associée à une table
 Exécution automatique sur événement

13 SAGAR Samya
Le bloc PL/SQL
 Un bloc PL/SQL est intégralement envoyé au moteur PL/SQL,
pour être compilé et exécutés.

 Ce moteur traite chaque instruction PL/SQL et sous-traite les

instructions purement SQL au moteur SQL, afin de réduire le
trafic réseau.

 Ce moteur est intégré au moteur de la base de données et

dans un certain nombre d'outils (Forms, Report).

14 SAGAR Samya
Le bloc PL/SQL
Le moteur PL/SQL

15 SAGAR Samya
Le bloc PL/SQL
Structure d’un bloc
 Le bloc est le concept de base de PL/SQL
 Un bloc regroupe les déclarations et instructions reliées logiquement
 Chaque bloc PL/SQL peut être constitué de 3 sections :
 Une section facultative de déclaration et initialisation de types, variables et constantes
 Une section obligatoire contenant les instructions d'exécution
 Une section facultative de gestion des erreurs

[DECLARE
… déclarations et initialisation]
BEGIN
… instructions exécutables
[EXCEPTION
… interception des erreurs]
END;

16 SAGAR Samya
Le bloc PL/SQL
Contenu d’un bloc
 Seuls BEGIN et END sont obligatoires, forment le corps du programme
 Le corps d’un bloc PL-SQL peut contenir:
 des instructions PL/SQL (assignements, boules, appel de procédure,…)
 toute instruction SQL du LMD (SELECT, INSERT, UPDATE, DELETE)
 les commandes SQL de gestion des transactions (COMMIT, ROLLBACK (TO), SAVEPOINT)
 tout prédicat utilisable dans SQL
Attention :Ce sont les seuls ordres supportés, pas d’instruction du LDD (ex. DROP, ALTER, …)
 Les sections DECLARE et EXCEPTION sont optionnelles
 Chaque instruction se termine par « ; »
 Les blocs, comme les instructions, se terminent par un « ; »
 Remarque applicative: sous SQL*PLUS,
 DECLARE ou BEGIN signifie que c’est le début d’un bloc PL/SQL
 Le « END; », n’indique pas la fin du bloc, car contrairement au PL/SQL, le « ; » ne signifie pas la
fin du bloc. Sous SQL*plus n’est qu’un indicateur de terminaison d’instruction
 Utilisation du « / » (raccourci de la cmde RUN), signifie que le bloc est terminé
17 SAGAR Samya
Le bloc PL/SQL
Blocs imbriqués
 Les blocs peuvent être imbriqués
 les sous-blocs ont la même structure que les blocs

DECLARE Bloc imbriqué, ou

BEGIN sous-bloc ou bloc
…
enfant
DECLARE
BEGIN
EXCEPTION
END; Des sous-blocs peuvent être
… définis dans le corps du bloc et
EXCEPTION dans la partie exception
…
DECLARE
BEGIN
EXCEPTION
END; Les variables sont locales au bloc
… dans lequel elles sont déclarées
END;
/

18 SAGAR Samya
Le bloc PL/SQL
Blocs imbriqués : Portée et visibilité des variables
DECLARE
A CHAR;
/* A (INTEGER) B, C (REAL) */
B REAL;
BEGIN
si dans un bloc, une variable du
/* A (CHAR) B (REAL) */ même nom que la variable
DECLARE GLOBALE existe c'est la variable
A INTEGER; LOCALE qui s'impose
C REAL;
BEGIN
…. un bloc ne peut utiliser les
END; variables d'un autre bloc de
DECLARE même niveau
D CHAR;
BEGIN
… /* A, D (CHAR) B (REAL) */
END;
/* A (CHAR) B (REAL) */
END;

 La portée d’un identificateur : un descendant peut accéder aux identificateurs

déclarés par un parent, pas l’inverse.
19 SAGAR Samya
Le bloc PL/SQL
 Identificateur Oracle(variable, curseur, exception, etc.) :
 Commence par une lettre
 Peut contenir : lettres, chiffres, $, #, _
 Interdits : &, -, /, espace
 Jusqu’à 30 caractères
 Insensible à la casse; majuscule vs minuscule (nompilote = NomPILOTE)

 Commentaires :
-- Commentaire sur une seule ligne
/* Commentaire sur plusieurs
lignes */

20 SAGAR Samya
 Variables et Types

21 SAGAR Samya
Les Variables en PL/SQL
 Types de variables PL/SQL :
 Scalaires, les types habituels correspondants aux types SQL2 ou
Oracle : NUMBER(5,2),VARCHAR2, DATE, BOOLEAN, …
 Composites, adaptés à la récupération des colonnes et lignes des
tables SQL :%ROWTYPE, %TYPE, RECORD, TABLE
 Référence : REF
 LOB (Large OBject jusqu’à 4 Go ; pointeur si externe)
 Un programme PL/SQL peut également manipuler des
variables non PL/SQL :
 Variables de substitution ou globales définies dans SQL*Plus
 Variables hôtes (définies dans d’autres programmes et utilisées par le
programme PL/SQL)
 Toute variable PL/SQL doit obligatoirement être déclarée
dans une section DECLARE avant utilisation
22 SAGAR Samya
Types PL/SQL
Types scalaires
Nombre Caractère Date/heure

BINARY_INTEGER
DEC CHAR
DECIMAL CHARACTER DATE
DOUBLE PRECISION LONG INTERVAL DAY TO SECOND
FLOAT LONG INTERVAL YEAR TO MONTH
INT RAW TIMESTAMP
INTEGER NCHAR NVARCHAR2 TIMESTAMP WITH LOCAL TIME ZONE
NATURAL RAW ROWID TIMESTAMP WITH TIME ZONE
NATURALN STRING
NUMBER UROWID
NUMERIC VARCHAR VARCHAR2
PLS_INTEGER
POSITIVE Booléen
POSITIVEN REAL
SIGNTYPE
SMALLINT BOOLEAN

 Note :les types Oracle sont en gras, les autres sont les sous-types
compatible ANSI/ISO
23 SAGAR Samya
Types PL/SQL
Types scalaires
 Nouveaux types numériques prédéfinis PL/SQL
 BINARY_INTEGER : entiers signés entre –231 et 231 (Utilise les fonctions de la
librairie arithmétique)
 BINARY_FLOAT (10g): Nombre à virgule flottante simple précision au format
IEEE 754. Un littéral de ce type est écrit avec un f terminateur (ex. 3.125f)
 BINARY_DOUBLE (10g) : Nombre à virgule flottante double précision au
format IEEE 754. Un littéral de ce type est écrit avec un d terminateur (ex.
3.12548d)
 PLS_INTEGER : entiers signés entre –231 et 231 ; plus performant que NUMBER
et BINARY_INTEGER (Plus rapide, car il utilise les registres du processeur) au
niveau des opérations arithmétiques ; en cas de dépassement, exception levée

24 SAGAR Samya
Types PL/SQL
Types scalaires
 Les Types caractères prédéfinis PL/SQL
Type de données CHAR VARCHAR2 LONG RAW LONG RAW

Longueur maximales 32767 32767 32760 32767 32760

Largeur maximale de colonne 255 2000 2147483647 255 2147483647

 RAW[(n)] : Chaîne de caractères ou données binaires de longueur variable. Le

contenu d'une variable de ce type n'est pas interprété par PL/SQL (pas de
gestion des caractères nationaux)
 LONG RAW: Identique au type LONG (Chaîne de caractères de longueur
variable) qui peut contenir des données binaires

25 SAGAR Samya
Types PL/SQL
Types scalaires
 Jeu de caractères multi-octets
 NCHAR[(n)] : Chaîne de caractères de longueur fixe avec n compris entre 1
et 32767 (par défaut 1)
 NVARCHAR2[(n)] : Chaîne de caractères de longueur variable avec n compris
entre 1 et 32767. Le nombre de caractères réellement stockés dépend du
nombre d'octets utilisés pour coder chaque caractère
 UROWID, ROWID : Permet de stocker l'adresse absolue d'une ligne dans une
table sous la forme d'une chaîne de caractères. Le format d'une telle variable est
le suivant : 000000FFFBBBBBBRRR
 000000 représente le numéro de l'objet qui possède cette ligne (dans le cas de cluster,
plusieurs objets peuvent partager le même segment)
 FFF représente le numéro du fichier qui contient la ligne
 BBBBBB représente le numéro du bloc dans le fichier
 RRR représente le numéro de ligne dans le bloc

26 SAGAR Samya
Types PL/SQL
Types composés Types références
RECORD
TABLE REF CURSOR
VARRAY REF type_objet

Types grands objets Types références

BFILE
BLOB SYS.ANYDATA
CLOB SYS.ANYTYPE
NCLOB SYS.ANYDATASET
XMLTYPE
URITYPE
MDSYS.SDO_GEOMETRY
ORDSYS.ORDAUDIO
ORDSYS.ORDIMAGE
ORDSYS.ORDVIDEO
ORDSYS.ORDDOC
ORDSYS.ORDIMAGESIGNATURE

27 SAGAR Samya
Une base de données pour les exemples
 avion:

 pilote:

 vol:

28 SAGAR Samya
 Variables scalaires
Déclaration
Identificateur [CONSTANT] type [[NOT NULL] {:= |DEFAULT} expression];

 CONSTANT : c’est une constante (sa valeur ne peut pas changer, doit être initialisée
lors de la déclaration)
 NOT NULL : indique que la variable ne peut pas être NULL, et dans ce cas
expression doit être indiqué (en cas de tentative, une exception VALUE_ERROR
est levée)
 Initialisation : affectation ":=" ou DEFAULT
 Pas de déclaration multiple dans PL/SQL
number1, number2 NUMBER; ← déclaration incorrecte
 Autre possibilité pour affecter une valeur à une variable
SELECT … INTO identificateur FROM … ;

29 SAGAR Samya
Les Opérateur supportés par PL/SQL
 Opérateurs Arithmétiques: +, -, /, *, ** (exponentielle)
 Opérateur de Concaténation: ||
 Parenthèses (contrôle des priorités entre opérations): ()
 Opérateurs de Comparaison: =, !=, <, >, <=, >=, IS
NULL, LIKE, BETWEEN, IN
 Opérateurs Logiques: AND, OR, NOT
 Affectation

30 SAGAR Samya
 Affectation
 Plusieurs façons de donner une valeur à une variable
 Par l’opérateur ":="
 Par la directive INTO de la requête SELECT
SELECT … INTO …
Instruction SELECT expr1,expr2, … INTO var1,var2, …

 Met des valeurs de la base de données dans une ou plusieurs

variables var1,ar2,…
 Le SELECT ne doit retourner qu’une seule ligne
 Avec Oracle il n’est pas possible d’inclure un SELECT sans INTO
dans une procédure.
 Pour retourner plusieurs lignes (voir la suite du cours sur les
curseurs).
31 SAGAR Samya
Exemples d’affectation
Exemple
dateNaissance := ’10/10/2004’;
bonus := salaire * 0.10;
valide := TRUE;

select nome INTO nom

from emp
where matr = 509; Attention : dans ces 2
exemples le select ne doit
ramener qu'un tuple (une
DECLARE seule ligne).
salaire NUMBER;
BEGIN
select sal INTO salaire
from Employé where nom='Dupont';
END;
32 SAGAR Samya
Variables scalaires
Exemple
DECLARE
villeDepart CHAR(10) := ‘Paris’;
villeArrivee CHAR(10);
numVolAller CONSTANT CHAR := ‘AF8’;
numVolRetour CHAR(10);
BEGIN
SELECT Ville_arrivee INTO villeArrivee FROM vol
WHERE Numvol = numVolAller; -- vol aller
numVolRetour := ‘AF9’;

INSERT INTO vol VALUES (numVolRetour, NULL,

NULL, villeArrivee, villeDepart); -- vol retour
END;
/

33 SAGAR Samya
Déclaration de types dynamiques
Déclaration %TYPE
 Déclarer une variable de même type que :
 Une colonne d’une table existante
nomNouvelleVariable NomTable.NomColonne%TYPE [{:= | DEFAULT} expression];

 Une autre variable, déclarée précédemment

nomNouvelleVariable nomAutreVariable%TYPE [{:= | DEFAULT} expression];

 Intérêt :
De rendre effectifs des changements à la base de données
lors de la prochaine compilation sans changer le code.

34 SAGAR Samya
Déclaration de types dynamiques
Déclaration %TYPE : exemple
DECLARE
nomPilote pilote.Nom%TYPE; /* table pilote,
colonne nom */
nomCoPilote nomPilote%TYPE;
BEGIN
…
SELECT Nom INTO nomPilote FROM pilote
WHERE matricule = 1;

SELECT Nom INTO nomCoPilote FROM pilote

WHERE matricule = 2;
…
END;
/

35 SAGAR Samya
Déclaration de types dynamiques
Variables %ROWTYPE
 Déclarer une variable composite du même type
 que les tuples d’une table :
nomNouvelleVariable NomTable%ROWTYPE;
 Qu’un curseur ; (voir plus loin)
 Les composantes de la variables composite, identifiées par
nomNouvelleVariable.nomColonne,sont du même type que les
colonnes correspondantes de la table
 Les contraintes NOT NULL déclarées au niveau des colonnes de la table
ne sont pas transmises aux composantes correspondantes de la variable
 Attention, on peut affecter un seul tuple à une variable définie avec
%ROWTYPE

36 SAGAR Samya
Déclaration de types dynamiques
Variables %ROWTYPE : exemple
DECLARE
piloteRecord pilote%ROWTYPE;
agePilote NUMBER(2) NOT NULL := 35;
BEGIN
piloteRecord.Age := agePilote;
piloteRecord.Nom := ‘Pierre’;
piloteRecord.Ville := ‘Bordeaux’;
piloteRecord.Salaire := 45000;

INSERT INTO pilote VALUES piloteRecord;

END;
/

37 SAGAR Samya
Variables de substitution
 Passer comme paramètres à un bloc PL/SQL des variables
définies sous SQL*Plus :
SQL> ACCEPT s_matPilote PROMPT ‘Matricule : ’
SQL> ACCEPT s_nomPilote PROMPT ‘Nom pilote : ’
SQL> ACCEPT s_agePilote PROMPT ‘Age pilote : ’
DECLARE
v_salairePilote NUMBER(6,2) DEFAULT 32000;
BEGIN
INSERT INTO pilote VALUES (‘&s_matPilote’,‘&s_nomPilote’,
NULL, &s_agePilote, v_salairePilote);
END;
/

 Remarque pratique : pour éviter le conflit de nommage, préfixer les

variables PL/SQL, par exemple par v_ et celles de sql*plus par s_
56 SAGAR Samya
Variables hôtes, variables de session
 Variables hôtes :
 Définies en dehors de PL/SQL et appelées dans PL/SQL
 Dans le code PL/SQL, préfixer le nom de la variable de « : »
 Variables de session (globales) :
 Directive SQL*Plus VARIABLE avant le bloc PL/SQL concerné
 Dans le code PL/SQL, préfixer le nom de la variable de « : »

SQL> VARIABLE compteurGlobal NUMBER := 0;

BEGIN
:compteurGlobal := :compteurGlobal - 1;
END;
/
SQL> PRINT compteurGlobal

57 SAGAR Samya
Résolution des noms
 Règles de résolution des noms :
 Le nom d’une variable du bloc l’emporte sur le nom d’une
variable externe au bloc (et visible)
 Le nom d’une variable l’emporte sur le nom d’une table
 Le nom d’une colonne d’une table l’emporte sur le nom d’une
variable
Bloc interne
 Étiquettes de blocs :
<<blocExterne>>
DECLARE
dateUtilisee DATE;
BEGIN
DECLARE
dateUtilisee DATE;
BEGIN
dateUtilisee := blocExterne.dateUtilisee;
END;
END blocExterne;
58 SAGAR Samya
Entrées et sorties
 Paquetage DBMS_OUTPUT :
 Mise dans le tampon d’une valeur :
PUT(valeur IN {VARCHAR2 | DATE | NUMBER});

 Mise dans le tampon du caractère fin de ligne :

NEW_LINE(ligne OUT VARCHAR2, statut OUT INTEGER);

 Mise dans le tampon d’une valeur suivie de fin de ligne :

PUT_LINE(valeur IN {VARCHAR2 | DATE | NUMBER});

 Rendre les sorties possibles avec SQL*Plus :

SET SERVEROUT ON
(ou SET SERVEROUTPUT ON)

59 SAGAR Samya
Entrées et sorties
 Lecture d’une ligne :
GET_LINE(ligne OUT VARCHAR2(255),statut OUT
INTEGER);

 Lecture de plusieurs lignes :

GET_LINES(tableau OUT DBMS_OUTPUT.CHARARR,
nombreLignes IN OUT INTEGER);

 Exemple :
DECLARE
tableau DBMS_OUTPUT.CHARARR;
nombreLignes INTEGER := 2;
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Nombre de lignes : ’ ||nombreLignes);
DBMS_OUTPUT.GET_LINES(tableau, nombreLignes);
END;

60 SAGAR Samya
Entrées et sorties
 Autres API pour des E/S spécifiques :

 DBMS_PIPE : échanges avec les commandes du système

d’exploitation
 UTL_FILE : échanges avec des fichiers
 UTL_HTTP : échanges avec un serveur HTTP (Web)
 UTL_SMTP : échanges avec un serveur SMTP (courriel)
 HTP : affichage des résultats sur une page HTML

61 SAGAR Samya
 Structures de contrôle

65 SAGAR Samya
Structures conditionnelles
IF
 Syntaxe :
IF condition1 THEN instructions1;
[ELSIF condition2 THEN instructions3;]
[ELSE instructions2;]
END IF;

 Conditions : expressions dans lesquelles peuvent

intervenir noms de colonnes, variables PL/SQL, valeurs
 Opérateurs AND et OR :

66 SAGAR Samya
Structures conditionnelles
IF : Exemple
 Donner un bloc PL/SQL permettant selon l'âge d’un
pilote de lui fixer un salaire de 28004 dinars s’il est âgé de
45 ans et de 11758 dinars s’il es âgé de 24 ans. L'âge sera
saisi à travers une variable sql*plus.

67 SAGAR Samya
Structures conditionnelles
IF : Exemple

SQL> ACCEPT s_agePilote PROMPT ‘Age pilote : ’

DECLARE
salairePilote pilote.Salaire%TYPE;
BEGIN
IF &s_agePilote = 45 THEN
salairePilote = 28004;
ELSIF &s_agePilote = 24 THEN
salairePilote = 11758;
END IF;
DBMS_OUTPUT.PUT_LINE(‘Salaire de base : ’ || salairePilote);
END;
/

68 SAGAR Samya
Structures conditionnelles
Case
 Syntaxe avec expressions :
[<<etiquette>>]
CASE variable
WHEN expression1 THEN instructions1;
WHEN expression2 THEN instructions2; … Cas par
[ELSE instructionsj;] défaut
END CASE [etiquette];
 Syntaxe avec conditions (searched case) :
[<<etiquette>>]
CASE
WHEN condition1 THEN instructions1;
WHEN condition2 THEN instructions2; …
[ELSE instructionsj;]
END CASE [etiquette];
 Le premier cas valide est traité, les autres sont ignorés
 Aucun cas valide : exception CASE_NOT_FOUND levée !
69 SAGAR Samya
Structures conditionnelles
Case : Exemple
SQL> ACCEPT s_agePilote PROMPT ‘Age pilote : ’
DECLARE
salairePilote pilote.Salaire%TYPE;
BEGIN
CASE &s_agePilote
WHEN 45 THEN salairePilote = 28004;
WHEN 24 THEN salairePilote = 11758;
END CASE;
DBMS_OUTPUT.PUT_LINE(‘Salaire de base : ’ ||
salairePilote);

EXCEPTION
WHEN CASE_NOT_FOUND THEN
DBMS_OUTPUT.PUT_LINE(‘Évaluer expérience’);
END;

70 SAGAR Samya
Structures conditionnelles
Case retournant une valeur : Exemple
SQL> ACCEPT s_agePilote PROMPT ‘Age pilote : ’
DECLARE Case renvoie
salairePilote pilote.Salaire%TYPE; une valeur qui
BEGIN vaut résultat1
salairePilote := CASE &s_agePilote ou résultat2, ….
WHEN 45 THEN 28004; Ou le résultat
WHEN 24 THEN 11758; par défaut dans
END CASE; le cas de ELSE
DBMS_OUTPUT.PUT_LINE(‘Salaire de base : ’ ||
salairePilote);

EXCEPTION
WHEN CASE_NOT_FOUND THEN
DBMS_OUTPUT.PUT_LINE(‘Évaluer expérience’);
END;

71 SAGAR Samya
Structures répétitives
tant que (while)
 Syntaxe :

[<<etiquette>>]
WHILE condition LOOP
instructions;
END LOOP [etiquette];

 La condition est vérifiée au début de chaque itération ;

 tant que la condition est vérifiée, les instructions sont
exécutées

72 SAGAR Samya
Structures répétitives
tant que (while) : Exemple

DECLARE
valeurEntiere INTEGER := 1;
produitSerie INTEGER := 1;
BEGIN
WHILE (valeurEntiere <= 10) LOOP
produitSerie := produitSerie * valeurEntiere;
valeurEntiere := valeurEntiere + 1;
END LOOP;
END;

73 SAGAR Samya
Structures répétitives
Répéter
 Syntaxe :
[<<etiquette>>]
LOOP
instructions1;
EXIT [WHEN condition];
[instructions2;]
END LOOP [etiquette];

 La condition est vérifiée à chaque itération ; si elle est vraie, on

quitte la boucle
 Si la condition est absente, les instructions sont exécutées une
seule fois
 Obligation d’utiliser la commande EXIT pour éviter une
boucle infinie
74 SAGAR Samya
Structures répétitives
Répéter : Exemple

DECLARE
valeurEntiere INTEGER := 1;
produitSerie INTEGER := 1;
BEGIN
LOOP
produitSerie := produitSerie * valeurEntiere;
valeurEntiere := valeurEntiere + 1;
EXIT WHEN valeurEntiere >= 10;
END LOOP;
END;

75 SAGAR Samya
Structures répétitives
Répéter : Boucles imbriquées
DECLARE
…
BEGIN
…
<<boucleExterne>>
LOOP
…
LOOP
…
EXIT boucleExterne WHEN …; /*quitter boucle externe*/
…
EXIT WHEN …; -- quitter boucle interne
END LOOP;
…
END LOOP;
…
END;

76 SAGAR Samya
Structures répétitives
Pour (for)
 Syntaxe :
[<<etiquette>>]
FOR compteur IN [REVERSE] valInf..valSup LOOP
instructions;
END LOOP;

 Les instructions sont exécutées une fois pour chaque valeur

prévue du compteur
 Après chaque itération, le compteur est incrémenté (ou
décrémenté si REVERSE) ; la boucle est terminée quand le
compteur sort de l’intervalle spécifié

77 SAGAR Samya
Structures répétitives
Pour (for) : Exemple

DECLARE
valeurEntiere INTEGER := 1;
produitSerie INTEGER := 1;
BEGIN
FOR valeurEntiere IN 1..10 LOOP
produitSerie := produitSerie * valeurEntiere;
END LOOP;
END;

78 SAGAR Samya
Structures répétitives
Pour (for) : Exemple
Afficher le numéro des enregistrement de la table pilote et
afficher le nombre total des pilotes
DECLARE
Nbligne number(3);
compteur number(3);
BEGIN
select count(*) into Nbligne from pilote;
For compteur IN 1 .. Nbligne LOOP
dbms_output.put_line(‘la ligne : ‘|| compteur);
END LOOP;
dbms_output.put_line(‘nombre de pilotes: ‘|| Nbligne);

END;

79 SAGAR Samya
 Interaction avec la base

80 SAGAR Samya
Interrogation directe des données
 L’interrogation directe des données doit retourner 1
enregistrement (sinon TOO_MANY_ROWS ou
NO_DATA_FOUND)

SELECT listeColonnes INTO var1PLSQL [,

var2PLSQL …]
FROM nomTable [WHERE condition];

81 SAGAR Samya
Manipulation des données
 Insertions :
INSERT INTO nomTable (liste colonnes)
VALUES (liste expressions);
 Modifications :
UPDATE nomTable SET nomColonne =
expression [WHERE condition];
 Suppressions :
DELETE FROM nomTable [WHERE condition];

82 SAGAR Samya