D49990FR10 SG

THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY.
COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED
D52824
Edition 1.0
Janvier 2008
D49990FR10
®
PL/SQL
Manuel du stagiaire
Oracle Database 11g :
Les fondamentaux du langage
Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.
THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY. COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED
Auteur
Tulika Srivastava Avertissement
Cette documentation contient des informations qui sont la propriété d'Oracle

Révisions et Corporation et sont protégées par les lois relatives aux droits d'auteur et à la propriété
intellectuelle. Vous ne pouvez copier et imprimer ce document qu'à des fins d'utilisation
contributions techniques personnelle lors de la participation à une formation dispensée par Oracle. Le
Tom Best document ne peut être modifié ou altéré en aucune manière. A l'exception des cas où
l'utilisation faite du document s'inscrit dans le respect des lois relatives aux droits
Christoph Burandt d'auteur, vous ne pouvez pas utiliser, partager, télécharger, copier, imprimer, afficher,
exécuter, reproduire, publier, breveter, diffuser, transmettre ou distribuer ce document,
Yanti Chang
en partie ou en totalité, sans l'autorisation expresse d'Oracle.
Ashita Dhir
Les informations fournies dans ce document sont susceptibles de modification sans
Peter Driver préavis. Par ailleurs, Oracle Corporation ne garantit pas qu'elles soient exemptes
Gerlinde Frenzen d'erreurs et vous invite, le cas échéant, à lui en faire part par écrit à l'adresse suivante :
Oracle University, 500 Oracle Parkway, Redwood Shores, California 94065 USA.
Nancy Greenberg
Chaitanya Kortamaddi Restrictions applicables au gouvernement américain :
Restricted Rights Notice
Tim Leblanc

If this documentation is delivered to the United States Government or anyone using the
Wendy Lo documentation on behalf of the United States Government, the following notice is
Bryan Roberts applicable:
Lauran Serhal U.S. GOVERNMENT RIGHTS

Abhishek X Singh The U.S. Government’s rights to use, modify, reproduce, release, perform, display,
or disclose these training materials are restricted by the terms of the applicable Oracle
Puja Singh license agreement and/or the applicable U.S. Government contract.
Lex.Van.Der Werff
Marques
Rédacteurs Oracle est une marque déposée d'Oracle Corporation et/ou de ses filiales. Tout autre
nom de produit ou de société peut être une marque de son propriétaire.
Atanu Raychaudhuri
Richard Wallis
Concepteurs graphique
Satish Bettegowda
Rajiv Chandrabhanu
Editeurs
Sujatha Nagendra
Michael Sebastian
Giri Venugopal
Table des matières
Préface
I Introduction
Objectifs I-2
Objectifs du cours I-3
Contenu du cours I-4

Schéma Human Resources (HR) utilisé dans ce cours I-6
Environnements de développement PL/SQL I-7
Coder PL/SQL dans Oracle SQL Developer I-8
Exécuter du code PL/SQL dans SQL*Plus I-9
Générer du code PL/SQL dans Oracle JDeveloper I-10
Démarrer SQL Developer et créer une connexion de base de données I-11
Créer des objets de schéma I-12
Utiliser SQL Worksheet I-13
Exécuter des instructions SQL I-14
Synthèse I-15
1 Introduction au langage PL/SQL

Objectifs 1-2
A propos du langage PL/SQL 1-3
Environnement PL/SQL 1-5
Avantages liés à l'utilisation du langage PL/SQL 1-6
Structure d'un bloc PL/SQL 1-9
Types de bloc 1-11
Structures de programme 1-13
Créer un bloc anonyme 1-15
Exécuter un bloc anonyme 1-16
Tester la sortie d'un bloc PL/SQL 1-17
Synthèse 1-19
Présentation de l'exercice 1 1-20
2 Déclarer des variables PL/SQL

Objectifs 2-2
Utilisation des variables 2-3
Exigences pour les noms de variable 2-4
Traiter les variables en langage PL/SQL 2-5
Déclarer et initialiser des variables PL/SQL 2-6
Délimiteurs dans les littéraux de type chaîne 2-8
Types de variable 2-9
Règles de déclaration et d'initialisation des variables PL/SQL 2-11
Règles relatives à la déclaration de variables PL/SQL 2-12
Types de données scalaires 2-13
Types de données scalaires de base 2-14
Déclaration de variables scalaires 2-18

Attribut %TYPE 2-19
Déclarer des variables avec l'attribut %TYPE 2-21
Déclarer des variables booléennes 2-22
Variables attachées 2-23
Afficher des variables attachées 2-25
Variables de type LOB 2-27
Types de données composites 2-28
Synthèse 2-29
3 Ecrire des instructions exécutables

Objectifs 3-2
Unités lexicales d'un bloc PL/SQL 3-3
Syntaxe des blocs PL/SQL et règles à respecter 3-5
Inclure des commentaires dans le code 3-6
Fonctions SQL dans le code PL/SQL 3-7
Fonctions SQL dans le code PL/SQL : Exemples 3-8
Utiliser des séquences dans des expressions PL/SQL 3-9
Conversion de type de données 3-10
Blocs imbriqués 3-13
Portée et visibilité des variables 3-15
Qualifier un identificateur 3-17
Quiz : Déterminer la portée d'une variable 3-18
Opérateurs en langage PL/SQL 3-20
Opérateurs en langage PL/SQL : Exemples 3-21
Règles relatives à la programmation 3-22
Indenter le code 3-23
Synthèse 3-24
iv
4 Interagir avec le serveur de base de données Oracle
Objectifs 4-2
Instructions SQL en langage PL/SQL 4-3
Instructions SELECT en langage PL/SQL 4-4
Extraire des données en langage PL/SQL 4-8
Conventions d'appellation 4-10
Utiliser PL/SQL pour manipuler des données 4-12
Insérer des données 4-13
Mettre à jour des données 4-14
Supprimer des données 4-15
Fusionner des lignes 4-16
Curseur SQL 4-18
Attributs de curseur SQL pour les curseurs implicites 4-20
Synthèse 4-22

5 Ecrire des structures de contrôle

Objectifs 5-2
Contrôler le flux d'exécution 5-3
Instruction IF 5-4
Instructions IF simples 5-6
Instruction IF THEN ELSE 5-7
Clause IF ELSIF ELSE 5-8
Valeur NULL dans une instruction IF 5-9
Expressions CASE 5-10
Expressions CASE : Exemple 5-11
Expressions de recherche pour la clause CASE 5-12
Instruction CASE 5-13
Traiter les valeurs NULL 5-14
Tables logiques 5-15
Conditions booléennes 5-16
Contrôle d'itération : Instructions LOOP 5-17
Boucles de base 5-18
Boucles WHILE 5-20
Boucles FOR 5-22
Règles relatives aux boucles 5-26
Boucles imbriquées et étiquettes 5-27
Instruction PL/SQL CONTINUE 5-29
Instruction PL/SQL CONTINUE : Exemple 5-30
Instruction PL/SQL CONTINUE : Exemple 5-31
Synthèse 5-32
v
6 Utiliser des types de données composites
Objectifs 6-2
Types de données composites 6-3
Enregistrements PL/SQL 6-5
Créer un enregistrement PL/SQL 6-6
Structure d'un enregistrement PL/SQL 6-8
Attribut %ROWTYPE 6-9
Avantages liés à l'utilisation de l'attribut %ROWTYPE 6-11
Attribut %ROWTYPE : Exemple 6-12
Insérer un enregistrement à l'aide de %ROWTYPE 6-13
Mettre à jour une ligne d'une table
à l'aide d'un enregistrement 6-14
Tables INDEX BY ou tableaux associatifs 6-15
Créer une table INDEX BY 6-16

Structure des tables INDEX BY 6-18
Créer une table INDEX BY 6-19
Utiliser les méthodes des tables INDEX BY 6-20
Table d'enregistrements INDEX BY 6-21
Table d'enregistrements INDEX BY : Exemple 6-23
Tables imbriquées 6-24
VARRAY 6-26
Synthèse 6-27
7 Utiliser des curseurs explicites

Objectifs 7-2
Curseurs 7-3
Fonctionnalités des curseurs explicites 7-4
Contrôler les curseurs explicites 7-5
Déclarer un curseur 7-7
Ouvrir le curseur 7-9
Extraire des données du curseur 7-10
Fermer le curseur 7-13
Curseurs et enregistrements 7-14
Boucles FOR de curseur 7-15
Attributs d'un curseur explicite 7-17
Attribut %ISOPEN 7-18
%ROWCOUNT et %NOTFOUND : Exemple 7-19
Boucles FOR de curseur utilisant des sous-interrogations 7-20
Curseurs avec paramètres 7-21
Clause FOR UPDATE 7-23
Clause WHERE CURRENT OF 7-25
Curseurs contenant des sous-interrogations 7-26
vi
Synthèse 7-27
8 Traiter les exceptions

Objectifs 8-2
Exemple d'exception 8-3
Traiter les exceptions en langage PL/SQL 8-5
Traiter les exceptions 8-6
Types d'exception 8-7
Intercepter les exceptions 8-8
Règles d'interception des exceptions 8-10
Intercepter les erreurs prédéfinies du serveur Oracle 8-11
Intercepter les erreurs non prédéfinies du serveur Oracle 8-14

Erreur non prédéfinie 8-15
Fonctions d'interception des exceptions 8-16
Intercepter les exceptions définies par l'utilisateur 8-18
Propagation des exceptions d'un sous-bloc 8-20
Procédure RAISE_APPLICATION_ERROR 8-21
Synthèse 8-24
9 Créer des procedures et des fonctions stockées

Objectifs 9-2
Procédures et fonctions 9-3
Différences entre les blocs anonymes et les sous-programmes 9-4
Procédure : Syntaxe 9-5
Procédure : Exemple 9-6
Appeler la procédure 9-8
Fonction : Syntaxe 9-9
Fonction : Exemple 9-10
Appeler une fonction 9-11
Transmettre un paramètre à une fonction 9-12
Appeler une fonction avec un paramètre 9-13
Synthèse 9-14
vii
Annexe A - Solutions des exercices
Annexe B - Description et données des tables
Annexe C - Utiliser SQL Developer
Annexe D - Utiliser SQL*Plus
Annexe E - Utiliser JDeveloper
Annexe F - Curseurs REF
Exercices complémentaires
Solutions des exercices complémentaires
viii
Introduction

Objectifs
A la fin de ce chapitre, vous pourrez :

• détailler l'organisation du cours
• décrire le modèle de schéma HR
• énoncer les environnements de développement disponibles
• décrire les fonctionnalités de base de SQL Developer

But du chapitre
Ce chapitre constitue une présentation générale du cours et de son déroulement. Il présente le
schéma de base de données et les tables utilisés.
Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 2

Objectifs du cours
A la fin de ce cours, vous pourrez :

• identifier les extensions de programmation fournies par
PL/SQL à SQL
• écrire du code PL/SQL permettant l'interaction avec la base
de données
• concevoir des blocs PL/SQL anonymes qui s'exécutent de
manière efficace
• utiliser des structures de programmation PL/SQL et des

instructions de contrôle conditionnel
• traiter les erreurs d'exécution
• décrire les procédures et les fonctions stockées
Objectifs du cours
Ce cours présente les concepts de base du langage PL/SQL. Vous découvrirez la syntaxe,
les blocs et les structures de programmation du langage PL/SQL, ainsi que les avantages de
l'intégration du langage SQL à ces structures. Vous apprendrez à écrire des programmes
PL/SQL et à les exécuter efficacement. En outre, vous apprendrez à utiliser SQL Developer
en tant qu'environnement de développement de code PL/SQL. Enfin, vous apprendrez à
concevoir des programmes réutilisables, tels que des procédures et des fonctions.

Contenu du cours
Chapitres étudiés le premier jour :

I. Introduction
1. Introduction au langage PL/SQL
2. Déclarer des variables PL/SQL
3. Ecrire des instructions exécutables
4. Interagir avec le serveur de base de données Oracle
5. Ecrire des structures de contrôle


Contenu du cours
Chapitres étudiés le deuxième jour :

6. Utiliser des types de données composites
7. Utiliser des curseurs explicites
8. Traiter les exceptions
9. Créer des procédures et des fonctions stockées


Schéma Human Resources (HR)

utilisé dans ce cours
DEPARTMENTS LOCATIONS
department_id location_id
department_name street_address
manager_id postal_code
location_id city
state_province
country_id
JOB_HISTORY
employee_id
start_date EMPLOYEES
employee_id
end_date
first_name
job_id
last_name COUNTRIES
department_id country_id
email
phone_number country_name
hire_date region_id
job_id
salary

commission_pct
JOBS manager_id
job_id department_id
job_title REGIONS
min_salary region_id
max_salary region_name
Description du schéma Human Resources (HR)

Le schéma Human Resources (HR) fait partie des schémas Oracle Sample Schemas pouvant
être installés dans une base de données Oracle. Les sessions d'exercices du cours utilisent
les données de ce schéma.
Description des tables
• La table REGIONS contient des lignes représentant les régions (telles que Americas,
Asia, etc.).
• La table COUNTRIES contient des lignes représentant les pays, chacun étant associé à
une région.
• La table LOCATIONS contient les adresses des bureaux, des entrepôts et/ou des sites de
production spécifiques d'une entreprise dans un pays particulier.
• La table DEPARTMENTS contient les détails des départements dans lesquels les
employés travaillent. Chaque département peut comporter une relation qui représente le
manager du service dans la table EMPLOYEES.
• La table EMPLOYEES contient les détails concernant les employés qui travaillent pour un
département. Il se peut que certains employés ne soient affectés à aucun département.
• La table JOBS contient les types de poste pouvant être occupés par chaque employé.
• La table JOB_HISTORY contient l'historique des postes occupés par les employés. Si un
employé change de département en conservant le même poste ou change de poste dans
un département, une nouvelle ligne est insérée dans la table. Cette ligne contient les
informations relatives à l'ancien poste de l'employé.

Environnements de développement PL/SQL
Ce cours fournit les outils suivants pour le développement du

code PL/SQL :
• Oracle SQL Developer (utilisé dans ce cours)
• Oracle SQL*Plus
• Environnement IDE Oracle JDeveloper

Environnements de développement PL/SQL

De nombreux outils proposent un environnement pour le développement de code PL/SQL.
Oracle fournit plusieurs outils pouvant être utilisés pour écrire du code PL/SQL. Les outils de
développement utilisés dans le cadre de ce cours sont notamment :
• Oracle SQL Developer : Outil graphique.
• Oracle SQL*Plus : Fenêtre ou application de ligne de commande.
• Oracle JDeveloper : Environnement IDE (Integrated Development Environment) basé
sur des fenêtres.
Remarque : Les exemples de code et d'écrans intégrés dans le cours ont été générés à partir
de l'environnement SQL Developer.

Coder PL/SQL dans Oracle SQL Developer
• Oracle SQL Developer est un outil graphique gratuit qui

augmente la productivité et simplifie les tâches de
développement de base de données.
• Vous pouvez vous connecter à n'importe quel schéma de
base de données Oracle cible en utilisant l'authentification
de base de données Oracle standard.
• Dans ce cours, vous allez utiliser SQL Developer.

SQL Developer
Oracle SQL Developer : Présentation

Oracle SQL Developer est un outil graphique gratuit, conçu pour augmenter votre
productivité et simplifier les tâches quotidiennes de gestion de base de données. En quelques
clics, vous pouvez facilement créer et déboguer des procédures stockées, tester des
instructions SQL et afficher les plans de l'optimiseur.
Cet outil de développement simplifie les tâches suivantes :
• Consultation et gestion des objets de base de données
• Exécution d'instructions et de scripts SQL
• Modification et débogage d'instructions PL/SQL
• Création d'états
Vous pouvez vous connecter à n'importe quel schéma de base de données Oracle cible en
utilisant l'authentification de base de données Oracle standard. Une fois connecté, vous
effectuez les opérations de votre choix sur les objets de la base.

Exécuter du code PL/SQL dans SQL*Plus

Exécuter du code PL/SQL dans SQL*Plus

Oracle SQL*Plus est une application de ligne de commande qui vous permet d'exécuter des
instructions SQL et des blocs PL/SQL et de recevoir les résultats dans une application ou dans
une fenêtre de commande.
SQL*Plus est :
• livré avec la base de données,
• installé sur un client et sur le système du serveur de base de données,
• accessible à partir d'une icône ou de la ligne de commande.

Générer du code PL/SQL dans Oracle JDeveloper
Editer

Exécuter
Générer du code PL/SQL dans Oracle JDeveloper

Oracle JDeveloper permet aux développeurs de créer, d'éditer, de tester et de déboguer du
code PL/SQL dans une interface graphique sophistiquée. Oracle JDeveloper fait partie
d'Oracle Developer Suite, mais est également disponible en tant que produit individuel.
Lorsque vous créez du code PL/SQL dans JDeveloper, tenez compte des considérations
suivantes :
• Vous devez d'abord créer une connexion de base de données afin de permettre à
JDeveloper d'accéder à un propriétaire de schéma de base de données pour les
sous-programmes.
• Vous pouvez ensuite utiliser les menus contextuels JDeveloper sur la connexion de base
de données afin de créer une structure de sous-programme à l'aide de l'éditeur de code
JDeveloper intégré. L'éditeur de code JDeveloper fournit un excellent environnement
pour le développement de code PL/SQL, avec des fonctionnalités telles que les
suivantes :
- Couleurs différentes pour les composants syntaxiques du langage PL/SQL.
- Fonction Code Insight permettant de localiser rapidement des procédures et des
fonctions dans les packages fournis.
• Vous appelez un sous-programme à l'aide de la commande Run du menu contextuel
correspondant au sous-programme indiqué. La sortie apparaît dans la fenêtre JDeveloper
Log Message, comme indiqué dans la partie inférieure de la capture d'écran.
Remarque : JDeveloper fournit une syntaxe utilisant des codes de couleur dans l'éditeur de
code JDeveloper. Il reconnaît les structures et les instructions en langage PL/SQL.

Démarrer SQL Developer et

créer une connexion de base de données

Créer une connexion de base de données

Pour créer une connexion de base de données, procédez de la manière suivante :
1. Cliquez deux fois sur <votre_chemin>\sqldeveloper\sqldeveloper.exe.
2. Dans l'onglet Connections, cliquez avec le bouton droit de la souris sur Connections et
sélectionnez New Connection.
3. Entrez le nom de la connexion, le nom utilisateur, le mot de passe, le nom d'hôte et
l'identificateur système (SID) de la base à laquelle vous souhaitez vous connecter.
4. Cliquez sur Test pour vous assurer que la connexion est correctement définie.
5. Cliquez sur Connect.
Dans l'onglet qui apparaît au bas de la page, renseignez les champs suivants :
• Hostname : Système hôte de la base de données Oracle.
• Port : Port d'écoute (listener).
• SID : Nom de la base de données.
• Service Name : Nom de service réseau pour une connexion à une base de données
distante.
Si vous cochez la case Save Password, le mot de passe est enregistré dans un fichier XML. La
prochaine fois que vous utiliserez cette connexion SQL Developer, vous ne serez pas invité à
entrer le mot de passe.

Créer des objets de schéma
• Vous pouvez créer un objet de schéma dans SQL

Developer à l'aide de l'une des méthodes suivantes :
– Exécuter une instruction SQL dans SQL Worksheet
– Utiliser le menu contextuel
• Editez les objets à l'aide d'une boîte de dialogue d'édition
ou à partir de l'un des nombreux menus contextuels.
• Affichez les instructions de définition de données (LDD)
pour procéder à des ajustements tels que la création d'un
objet ou la modification d'un objet de schéma existant.


Utiliser SQL Worksheet
• Utilisez SQL Worksheet pour entrer et exécuter des

instructions SQL, PL/SQL et SQL*Plus.
• Vous pouvez indiquer toute action qui peut être traitée par
la connexion de base de données associée à la feuille de
calcul.


Lorsque vous vous connectez à une base de données, une fenêtre SQL Worksheet s'ouvre
automatiquement pour cette connexion. Vous pouvez utiliser cette fenêtre pour entrer et
exécuter des instructions SQL, PL/SQL et SQL*Plus. SQL Worksheet ne prend en charge que
certaines instructions SQL*Plus. Les instructions qui ne peuvent pas être traitées sont
ignorées et ne sont pas transmises à la base.
Dans une feuille de calcul, vous pouvez indiquer différentes actions de connexion pour la
manipulation et la définition d'une base de données, notamment :
• Créer une table
• Insérer des données
• Créer et modifier un déclencheur (trigger)
• Sélectionner des données dans une table
• Enregistrer des données dans un fichier
Pour afficher une feuille de calcul SQL Worksheet, vous avez le choix entre deux méthodes :
• Sélectionner Tools > SQL Worksheet
• Cliquer sur l'icône Open SQL Worksheet

Exécuter des instructions SQL
Utilisez la zone Enter SQL Statement pour entrer une ou

plusieurs instructions SQL.


Dans SQL Worksheet, vous pouvez utiliser la zone Enter SQL Statement pour entrer une ou
plusieurs instructions SQL. Si vous indiquez une seule instruction, le point-virgule final est
facultatif.
Lors de la saisie, les mots-clés SQL sont automatiquement mis en évidence. Pour exécuter
une instruction SQL, désignez-la avec le curseur et cliquez sur le bouton Execute Statement.
Vous pouvez également appuyer sur la touche [F9].
Pour exécuter plusieurs instructions SQL et afficher les résultats, cliquez sur le bouton Run
Script. Vous pouvez également appuyer sur la touche [F5].
Dans l'exemple de la diapositive ci-dessus, la première instruction SQL est terminée par un
point-virgule car elle est suivie par une autre. Le curseur désigne la première instruction.
La zone Results affiche donc le résultat de celle-ci lors de l'exécution.

Synthèse
Ce chapitre vous a permis d'apprendre à :

• détailler l'organisation du cours
• décrire le modèle de schéma HR
• énoncer les environnements de développement disponibles
• décrire les fonctionnalités de base de SQL Developer


Exercices du cours
Dans les exercices de ce cours, vous allez développer une application simple à l'aide de blocs
anonymes. Vous effectuerez les actions suivantes :
• Ecrire une section déclarative
• Déclarer des variables de type scalaire
• Déclarer des variables avec l'attribut %TYPE
• Ecrire une section exécutable
• Accepter la saisie de valeurs par l'utilisateur pour les variables
• Extraire des valeurs de la base de données et les stocker dans des variables à l'aide de la clause
INTO
• Ecrire un bloc imbriqué dans la section exécutable
• Utiliser des structures de contrôle dans la section exécutable afin d'exécuter une logique métier
• Utiliser une table INDEX BY pour stocker des valeurs et les afficher
• Traiter les exceptions


Introduction au langage PL/SQL

Objectifs

• expliquer la nécessité du langage PL/SQL
• présenter les avantages liés à l'utilisation du langage
PL/SQL
• identifier les différents types de bloc PL/SQL
• afficher la sortie d'un bloc PL/SQL

But du chapitre
Ce chapitre présente le langage PL/SQL et les structures de programmation PL/SQL. Vous en
saurez plus sur les avantages du langage PL/SQL.
Oracle Database 11g : Les fondamentaux du langage PL/SQL 1 - 2

A propos du langage PL/SQL
Le langage PL/SQL :
• signifie "Procedural Language extension to SQL"
(extension procédurale du langage SQL)
• est le langage standard d'accès aux données d'Oracle
Corporation pour les bases de données relationnelles
• intègre de manière transparente les structures procédurales
au langage SQL


Le langage SQL (Structured Query Language) est le principal langage d'accès aux données et
de modification des données dans les bases relationnelles. Les commandes SQL sont en
nombre restreint, de sorte que vous pouvez les apprendre et les utiliser facilement. Prenons
l'exemple suivant :
SELECT first_name, department_id, salary FROM employees;
L'instruction SQL ci-dessus est simple et directe. Cependant, si vous souhaitez modifier des
données extraites de manière conditionnelle, vous vous heurtez rapidement aux limitations du
langage SQL. Considérons un exemple légèrement différent. Pour chaque employé extrait,
vous voulez vérifier l'ID de département et le salaire. Vous voulez accorder des primes
différentes aux employés en fonction de leur salaire et des performances de leur département.
Vous savez que vous devez exécuter l'instruction SQL ci-dessus, collecter les données, puis
appliquer une logique aux données. Une solution consiste à écrire pour chaque département
une instruction SQL définissant la prime à accorder aux employés. Rappelez-vous que vous
devez également vérifier le salaire avant de fixer le montant de la prime. Le problème devient
alors plus complexe. Vous vous rendez compte que le problème serait beaucoup plus simple à
résoudre si vous disposiez d'instructions conditionnelles. Le langage PL/SQL est conçu pour
faire face à ces besoins. Il offre des extensions de programmation pour le langage SQL
existant.

Caractéristiques du langage PL/SQL :

• Il offre une structure de bloc pour les unités de code
exécutables. Cette structure bien définie facilite la
maintenance du code.
• Il fournit des structures procédurales :
– Variables, constantes et types de données
– Structures de contrôle, telles que les instructions
conditionnelles et les boucles
– Programmes réutilisables qui peuvent être exécutés

plusieurs fois
A propos du langage PL/SQL (suite)

Le langage PL/SQL définit une structure de bloc pour l'écriture de code. Cette structure
facilite la maintenance et le débogage du code. Il devient facile de comprendre le flux et
l'exécution du programme.
Le langage PL/SQL offre des fonctionnalités d'ingénierie logicielle modernes telles que
l'encapsulation de données, le traitement des exceptions, le masquage de données et
l'orientation objet. Il apporte en outre au serveur et aux outils Oracle les dernières évolutions
en matière de programmation. Il fournit toutes les structures procédurales disponibles dans
les différents langages de programmation de troisième génération (3GL).

Environnement PL/SQL
Moteur PL/SQL
Programme
instruction
Bloc d'exécution
procédurale
PL/SQL des instructions
procédurales
SQL

Programme d'exécution
des instructions SQL
Serveur de base de données Oracle
Environnement PL/SQL
La diapositive ci-dessus illustre l'environnement d'exécution PL/SQL du serveur de base de
données Oracle. Un bloc PL/SQL contient des instructions procédurales et des instructions
SQL. Lorsque vous soumettez un bloc au serveur, le moteur PL/SQL commence par l'analyser
(parse). Il identifie les instructions procédurales et les instructions SQL. Il transmet les
instructions procédurales au programme d'exécution des instructions procédurales et les
instructions SQL au programme d'exécution des instructions SQL.
Le schéma de la diapositive ci-dessus illustre le moteur PL/SQL dans le serveur de base de
données. Les outils de développement d'applications Oracle peuvent également contenir un
moteur PL/SQL. L'outil transmet les blocs au moteur PL/SQL local. Par conséquent, toutes
les instructions procédurales sont exécutées localement et seules les instructions SQL sont
exécutées dans la base de données. Le moteur utilisé dépend de l'emplacement à partir duquel
le bloc PL/SQL est appelé.

Avantages liés à l'utilisation du langage PL/SQL
• Intégration de structures procédurales au langage SQL

• Amélioration des performances
SQL 1
SQL 2
…

SQL
IF...THEN
SQL
ELSE
SQL
END IF;
SQL

Intégration de structures procédurales au langage SQL : Le principal avantage du langage
PL/SQL est l'intégration de structures procédurales au langage SQL. Ce dernier est un langage
non procédural. Lorsqu'une commande SQL est exécutée, elle indique quoi faire au serveur de
base de données. En revanche, elle ne peut pas indiquer comment le faire. Le langage PL/SQL
intègre des instructions de contrôle et des instructions conditionnelles au langage SQL ce qui
vous permet de mieux contrôler les instructions SQL et leur exécution. Nous avons vu
précédemment dans ce chapitre un exemple qui illustre la nécessité d'une telle intégration.
Amélioration des performances : Sans le langage PL/SQL, vous ne pourriez pas combiner
logiquement des instructions SQL dans une même unité. Si vous avez conçu une application
contenant des panneaux, il est possible que vous disposiez de plusieurs panneaux contenant
différents champs. Lorsqu'un panneau soumet des données, vous pouvez être amené à
exécuter un certain nombre d'instructions SQL. Ces instructions sont envoyées une par une à
la base de données. Il en résulte de nombreux allers-retours réseau et un appel de la base de
données pour chaque instruction SQL. Cela entraîne une augmentation du trafic réseau et une
dégradation des performances, en particulier dans un modèle client-serveur.
Le langage PL/SQL vous permet de combiner toutes ces instructions SQL dans un même
programme. L'application peut alors envoyer le bloc entier à la base au lieu d'envoyer les
instructions SQL une par une. Il en résulte une réduction significative du nombre d'appels de
la base de données. Comme le montre la diapositive ci-dessus, si une application a recours de
manière intensive à des instructions SQL, vous pouvez regrouper celles-ci dans des blocs
PL/SQL avant de les envoyer au serveur de base de données Oracle en vue de leur exécution.

• Développement de programme modulaire

• Intégration aux outils Oracle
• Portabilité
• Traitement des exceptions

Avantages liés à l'utilisation du langage PL/SQL (suite)

Développement de programme modulaire : L'unité de base de tous les programmes
PL/SQL est le bloc. Les blocs peuvent être séquentiels ou être imbriqués dans d'autres blocs.
Le développement modulaire de programme présente les avantages suivants :
• Vous pouvez regrouper dans des blocs les instructions liées logiquement.
• Vous pouvez imbriquer des blocs dans d'autres blocs afin de créer des programmes
puissants.
• Vous pouvez fractionner une application en modules plus petits. Lorsque vous concevez
une application complexe, le langage PL/SQL vous permet de la fractionner en modules
plus petits, plus faciles à gérer et logiquement liés.
• Vous pouvez facilement effectuer la maintenance et le débogage du code.
Dans PL/SQL, la modularisation est mise en oeuvre à l'aide de procédures, de fonctions et de
packages. Ces éléments sont traités dans le chapitre intitulé "Créer des procédures et des
fonctions stockées".
Intégration aux outils : Le moteur PL/SQL est intégré aux outils Oracle tels qu'Oracle
Forms, Oracle Reports, etc. Lorsque vous utilisez ces outils, le moteur PL/SQL disponible
localement assure le traitement des instructions procédurales. Seules les instructions SQL sont
transmises à la base de données.

Avantages liés à l'utilisation du langage PL/SQL (suite)

Portabilité : Les programmes PL/SQL peuvent s'exécuter partout où un serveur Oracle s'exécute,
quels que soient le système d'exploitation et la plate-forme. Il n'est pas nécessaire de les adapter à
chaque nouvel environnement. Par conséquent, il est possible d'écrire des packages de programmes
portables et de créer des bibliothèques réutilisables dans différents environnements.
Traitement des exceptions : Le langage PL/SQL vous permet de traiter efficacement les exceptions.
Vous pouvez définir des blocs distincts pour la gestion des exceptions. Vous en saurez plus sur le
traitement des exceptions dans le chapitre intitulé "Traiter les exceptions".
Le langage PL/SQL utilise les mêmes types de données que le langage SQL (avec certaines
extensions) ainsi que la même syntaxe d'expression.

Structure d'un bloc PL/SQL
• DECLARE (facultatif)
– Variables, curseurs, exceptions définies par l'utilisateur
• BEGIN (obligatoire)
– Instructions SQL
– Instructions PL/SQL
• EXCEPTION (facultatif)
– Actions à effectuer lorsque
des erreurs se produisent

• END; (obligatoire)
Structure d'un bloc PL/SQL

La diapositive ci-dessus illustre un bloc PL/SQL de base. Un bloc PL/SQL est constitué de
trois sections :
• Section déclarative (facultative) : Cette section commence par le mot-clé DECLARE et
se termine là où commence la section exécutable.
• Section exécutable (obligatoire) : Cette section commence par le mot-clé BEGIN et se
termine par END. Elle doit comporter au moins une instruction. Remarquez que
l'instruction END se termine par un point-virgule. La section exécutable d'un bloc
PL/SQL peut, à son tour, inclure un nombre quelconque de blocs PL/SQL.
• Section de traitement des exceptions (facultative) : Cette section est imbriquée dans la
section exécutable. Elle commence par le mot-clé EXCEPTION.

Structure d'un bloc PL/SQL (suite)

Dans un bloc PL/SQL, les mots-clés DECLARE, BEGIN et EXCEPTION ne se terminent pas par un
point-virgule. En revanche, le mot-clé END, les instructions SQL et les instructions PL/SQL doivent
être suivis par un point-virgule.
Section Description Inclusion

Déclarative Contient les déclarations de l'ensemble des variables, Facultative
(DECLARE) des constantes, des curseurs et des exceptions
définies par l'utilisateur qui sont référencés dans la
section exécutable et dans la section de traitement
des exceptions.
Exécutable Contient des instructions SQL permettant d'extraire Obligatoire
(BEGIN … des données de la base. Elle inclut aussi des
END) instructions PL/SQL permettant de manipuler les

données du bloc.
Traitement des Indique les actions à effectuer lorsque des erreurs et Facultative
exceptions des conditions anormales surviennent dans la section
(EXCEPTION) exécutable.

Types de bloc
Bloc anonyme Procédure Fonction
[DECLARE] PROCEDURE name FUNCTION name

IS RETURN datatype
IS
BEGIN BEGIN BEGIN
--statements --statements --statements
RETURN value;
[EXCEPTION] [EXCEPTION] [EXCEPTION]

END; END; END;
Types de bloc
Un programme PL/SQL comporte un ou plusieurs blocs. Ces blocs peuvent être entièrement
distincts ou être imbriqués. Il existe trois types de bloc qui constituent un programme
PL/SQL. Il s'agit des types suivants :
• Blocs anonymes
• Procédures
• Fonctions
Blocs anonymes : Les blocs anonymes sont des blocs non nommés. Ils sont déclarés en ligne
(inline) dans une application, à l'endroit où ils doivent être exécutés, et sont compilés chaque
fois que l'application est exécutée. Ces blocs ne sont pas stockés dans la base de données. Ils
sont transmis au moteur PL/SQL en vue de leur exécution. Les déclencheurs (triggers)
d'Oracle Developer sont constitués de tels blocs. Ces blocs anonymes sont pris en compte lors
de l'exécution parce qu'ils sont en ligne. Si vous souhaitez exécuter de nouveau le même bloc,
vous devez réécrire le bloc. Vous ne pouvez pas appeler le bloc que vous avez écrit
précédemment, car les blocs sont anonymes et n'existent plus après leur exécution.

Types de bloc (suite)

Sous-programmes : Les sous-programmes sont complémentaires par rapport aux blocs anonymes. Il
s'agit de blocs PL/SQL nommés stockés dans la base de données. Etant donné qu'ils sont nommés et
stockés, vous pouvez les appeler chaque fois que vous le souhaitez (en fonction de votre application).
Vous pouvez les déclarer en tant que procédures ou en tant que fonctions. Vous utilisez généralement
une procédure pour effectuer une action, tandis qu'une fonction sert à calculer et à renvoyer une
valeur.
Vous pouvez stocker les sous-programmes au niveau serveur ou application. Lorsque vous utilisez
les composants d'Oracle Developer (Forms, Reports), vous pouvez déclarer les procédures et les
fonctions en tant que parties de l'application (panneaux ou états) et les appeler à partir d'autres
procédures, fonctions et déclencheurs de la même application, chaque fois que cela s'avère
nécessaire.
Remarque : Une fonction est similaire à une procédure, à ceci près qu'elle doit renvoyer une valeur.

Structures de programme
Structures du serveur
Structures des outils de base de données
Blocs anonymes Blocs anonymes
Procédures ou Procédures ou
fonctions applicatives fonctions stockées

Packages applicatifs Packages stockés
Déclencheurs Déclencheurs de
applicatifs base de données
Types d'objet Types d'objet
Structures de programme
Le tableau suivant répertorie différentes structures de programme PL/SQL utilisant le bloc
PL/SQL de base. La disponibilité de ces structures dépend de l'environnement d'exécution.
Structure de Description Disponibilité

programme
Blocs anonymes Blocs PL/SQL anonymes imbriqués dans une Tous les environnements
application ou exécutés de manière interactive. PL/SQL
Procédures ou Blocs PL/SQL nommés, stockés dans une Outils Oracle Developer (par
fonctions application ou une bibliothèque partagée exemple, Oracle Forms
applicatives Oracle Forms Developer. Ils acceptent des Developer, Oracle Reports)
paramètres et peuvent être appelés à plusieurs
reprises par leur nom.
Procédures ou Blocs PL/SQL nommés, stockés sur le serveur Serveur Oracle ou outils Oracle
fonctions Oracle. Ils acceptent des paramètres et peuvent Developer
stockées être appelés à plusieurs reprises par leur nom.
Packages Modules PL/SQL nommés regroupant des Serveur Oracle et outils

(applicatifs ou procédures, des fonctions et les identificateurs d'Oracle Developer (par
stockés) associés exemple, Oracle Forms
Developer)

Structures de programme (suite)
Structure de Description Disponibilité

programme
Déclencheurs de Blocs PL/SQL associés à une table de base de Serveur Oracle ou n'importe
base de données données, qui sont exécutés automatiquement quel outil Oracle qui exécute
lorsqu'ils sont déclenchés par différents l'instruction LMD
événements.
Déclencheurs Blocs PL/SQL associés à une table de base de Outils Oracle Developer (par
applicatifs données ou à des événements système. Ils sont exemple, Oracle Forms
exécutés automatiquement lorsqu'ils sont Developer)
déclenchés par une instruction LMD ou par un
événement système.
Types d'objet Types de données composites définis par Serveur Oracle et outils Oracle

l'utilisateur, qui encapsulent une structure de Developer
données ainsi que les fonctions et les
procédures nécessaires à la manipulation de
ces données.

Créer un bloc anonyme
Entrez le bloc anonyme dans l'espace de travail SQL Developer :


Pour créer un bloc anonyme avec SQL Developer, saisissez-le dans l'espace de travail
(comme illustré dans la diapositive ci-dessus). Le bloc comporte une section déclarative et
une section exécutable. Pour le moment, ne tenez pas compte de la syntaxe des instructions du
bloc. Celle-ci sera abordée ultérieurement dans le cours. Le bloc anonyme obtient la valeur
first_name de l'employé pour lequel le paramètre employee_id a la valeur 100 et
stocke cette valeur dans une variable nommée v_fname.

Exécuter un bloc anonyme
Cliquez sur le bouton Run Script pour exécuter le bloc anonyme :
Run Script

Exécuter un bloc anonyme

Cliquez sur le bouton Run Script pour exécuter le bloc anonyme dans l'espace de travail.
Notez que le message "anonymous block completed" s'affiche dans la fenêtre Script Output
après l'exécution du bloc.

Tester la sortie d'un bloc PL/SQL
• Activez la sortie dans SQL Developer en cliquant sur le

bouton Enable DBMS Output, dans l'onglet DBMS Output :
Enable DBMS
Onglet DBMS
Output
Output
• Utilisez un package Oracle prédéfini et sa procédure :

– DBMS_OUTPUT.PUT_LINE
DBMS_OUTPUT.PUT_LINE(' The First Name of the

Employee is ' || f_name);
…

Dans l'exemple de la diapositive précédente, une valeur a été stockée dans la variable
f_name. En revanche, cette valeur n'a pas été affichée. Nous allons voir à présent comment
afficher cette valeur.
Le langage PL/SQL ne comporte pas de fonctionnalité d'entrée-sortie intégrée. Par
conséquent, vous devez utiliser des packages Oracle prédéfinis pour l'entrée et la sortie. Pour
générer la sortie, procédez comme suit :
• Activez la sortie dans SQL Developer en cliquant sur le bouton Enable DBMS Output,
dans l'onglet DBMS Output. La commande SET SERVEROUTPUT ON est alors exécutée
et affichée dans la fenêtre. Pour activer la sortie dans SQL*Plus, vous devez
explicitement exécuter la commande SET SERVEROUTPUT ON.
• Utilisez la procédure PUT_LINE du package DBMS_OUTPUT pour afficher la sortie.
Indiquez la valeur à afficher comme argument de cette procédure (comme illustré dans la
diapositive ci-dessus). La procédure affiche alors l'argument.


Tester la sortie d'un bloc PL/SQL (suite)

La diapositive ci-dessus illustre la sortie du bloc PL/SQL après l'inclusion du code nécessaire
pour la génération de la sortie.

Synthèse

• intégrer des instructions SQL aux structures de programme
PL/SQL
• décrire les avantages liés à l'utilisation du langage PL/SQL
• différencier les différents types de bloc PL/SQL
• afficher la sortie d'un bloc PL/SQL

Synthèse
Le langage PL/SQL comporte des fonctionnalités de programmation qui permettent d'étendre
le langage SQL. Ce dernier, qui est un langage non procédural, est rendu procédural avec les
structures de programmation PL/SQL. Les applications PL/SQL peuvent s'exécuter sur toute
plate-forme ou tout système d'exploitation sur lequel s'exécute un serveur Oracle. Dans ce
chapitre, vous avez appris à créer des blocs PL/SQL de base.

Présentation de l'exercice 1
Cet exercice porte sur les points suivants :

• Identifier les blocs PL/SQL qui s'exécutent avec succès
• Créer et exécuter un bloc PL/SQL simple

Cet exercice renforce les bases du langage PL/SQL apprises dans ce chapitre.
• Le point 1 vous permet d'identifier les blocs PL/SQL qui s'exécutent avec succès.
Répondez-y par écrit.
• Le point 2 vous fait créer et exécuter un bloc PL/SQL simple.

Exercice 1
Le dossier labs est votre répertoire de travail. Vous pouvez y enregistrer vos scripts. Demandez au
formateur de vous aider à localiser le dossier labs de ce cours. Les solutions de tous les exercices se
trouvent dans le dossier soln.
1. Parmi les blocs PL/SQL suivants, lesquels s'exécutent avec succès ?
a. BEGIN
END;
b. DECLARE
amount INTEGER(10);
END;
c. DECLARE

BEGIN
END;
d. DECLARE
amount INTEGER(10);
BEGIN
DBMS_OUTPUT.PUT_LINE(amount);
END;
2. Créez et exécutez un bloc anonyme simple qui affiche "Hello World". Exécutez ce script et
enregistrez-le sous le nom lab_01_02_soln.sql.



Déclarer des variables PL/SQL

Objectifs

• reconnaître les identificateurs valides et non valides
• répertorier les utilisations des variables
• déclarer et initialiser des variables
• répertorier et décrire les différents types de données
• identifier les avantages liés à l'utilisation de l'attribut %TYPE
• déclarer, utiliser et afficher des variables attachées

But du chapitre
Dans le chapitre précédent, vous avez étudié un bloc PL/SQL de base ainsi que ses sections.
Dans le présent chapitre, vous découvrirez les identificateurs valides et non valides. Vous
apprendrez à déclarer et à initialiser des variables dans la section déclarative d'un bloc
PL/SQL. Vous étudierez les différents types de données. Enfin, vous découvrirez l'attribut
%TYPE et ses avantages.

Utilisation des variables
Les variables peuvent être utilisées pour :

• le stockage temporaire de données
• la manipulation de valeurs stockées
• la réutilisation
SELECT
first_name,
department_id

Jennifer v_fname
INTO
v_fname,
v_deptno
FROM …
10 v_deptno
Utilisation des variables

Le langage PL/SQL vous permet de déclarer des variables, puis de les utiliser dans des
instructions SQL et des instructions procédurales.
Les variables sont principalement utilisées pour le stockage des données et la manipulation
des valeurs stockées. Examinez l'instruction PL/SQL de la diapositive ci-dessus. Elle extrait
les valeurs first_name et department_id de la table. Si vous devez manipuler la
valeur first_name ou department_id, vous devez stocker la valeur extraite.
Les variables sont utilisées pour le stockage temporaire de la valeur. Vous pouvez utiliser
la valeur stockée dans les variables pour le traitement et la manipulation des données.
Les variables permettent le stockage de n'importe quel objet PL/SQL, par exemple des
variables, des types, des curseurs et des sous-programmes.
La possibilité de réutilisation est un autre avantage de la déclaration des variables. Une fois
déclarées, les variables peuvent être utilisées de manière répétée dans une application, via
plusieurs références à ces variables dans diverses instructions.

Exigences pour les noms de variable
Un nom de variable :
• doit commencer par une lettre
• peut inclure des lettres ou des chiffres
• peut inclure des caractères spéciaux (tels que $, _ et #)
• ne doit pas contenir plus de 30 caractères
• ne doit pas inclure de mots réservés

Exigences pour les noms de variable

Les règles d'appellation d'une variable sont répertoriées dans la diapositive ci-dessus.

Traiter les variables en langage PL/SQL
Les variables :
• sont déclarées et initialisées dans la section déclarative
• sont utilisées et font l'objet de l'affectation de nouvelles
valeurs dans la section exécutable
• sont transmises en tant que paramètres aux
sous-programmes PL/SQL
• sont utilisées pour contenir la sortie d'un sous-programme
PL/SQL

Traiter les variables en langage PL/SQL

Vous pouvez utiliser les variables comme suit.
Déclarez et initialisez les variables dans la section déclarative : Vous pouvez déclarer des
variables dans la section déclarative de n'importe quel bloc, sous-programme ou package
PL/SQL. Les déclarations servent à allouer de l'espace de stockage pour une valeur, à définir
son type de données et à nommer l'emplacement de stockage afin de pouvoir y faire référence.
Les déclarations servent également à affecter une valeur initiale et à imposer la contrainte
NOT NULL à la variable. Les références en amont ne sont pas autorisées. Vous devez déclarer
une variable avant d'y faire référence dans d'autres instructions, y compris pour les
instructions déclaratives.
Utilisez les variables et affectez-leur de nouvelles valeurs dans la section exécutable :
Dans la section exécutable, la valeur existante d'une variable peut être remplacée par une
nouvelle valeur.
Transmettez les variables en tant que paramètres aux sous-programmes PL/SQL :
Les sous-programmes acceptent des paramètres. Vous pouvez transmettre les variables en tant
que paramètres aux sous-programmes.
Utilisez les variables pour contenir la sortie d'un sous-programme PL/SQL :
Les variables peuvent être utilisées pour contenir la valeur renvoyée par une fonction.

Déclarer et initialiser des variables PL/SQL
Syntaxe :
identifier [CONSTANT] datatype [NOT NULL]
[:= | DEFAULT expr];
Exemples :
DECLARE
v_hiredate DATE;
v_deptno NUMBER(2) NOT NULL := 10;
v_location VARCHAR2(13) := 'Atlanta';
c_comm CONSTANT NUMBER := 1400;


Vous devez déclarer tous les identificateurs PL/SQL dans la section déclarative avant de les
référencer dans le bloc PL/SQL. Vous avez la possibilité d'affecter une valeur initiale à une
variable (comme illustré dans la diapositive ci-dessus). Toutefois, vous n'êtes pas obligé
d'affecter une valeur à une variable pour pouvoir la déclarer. Si vous référencez d'autres
variables dans la déclaration, assurez-vous qu'elles sont déjà déclarées séparément dans une
instruction antérieure.
Dans la syntaxe :
identifier Nom de la variable.
CONSTANT Contrainte qui empêche toute modification de la valeur de la variable
(les constantes doivent être initialisées).
data type Type de données scalaire, composite, référencé ou LOB (ce cours ne
traite que des types scalaires, composites et LOB).
NOT NULL Contrainte qui impose à la variable de contenir une valeur (les variables
NOT NULL doivent être initialisées).
expr Toute expression PL/SQL pouvant représenter une expression littérale,
une autre variable ou une expression mettant en jeu des opérateurs et des
fonctions.
Remarque : Outre les variables, vous pouvez également déclarer des curseurs et des
exceptions dans la section déclarative. Vous apprendrez à déclarer les curseurs dans le
chapitre "Utiliser des curseurs explicites" et à traiter les exceptions dans le chapitre "Traiter
les exceptions".

DECLARE
v_myName VARCHAR2(20);
1 BEGIN
DBMS_OUTPUT.PUT_LINE('My name is: '|| v_myName);
v_myName := 'John';
END;
/
DECLARE
v_myName VARCHAR2(20):= 'John';

2 BEGIN
v_myName := 'Steven';
END;
/
Déclarer et initialiser des variables PL/SQL (suite)

Observez les deux blocs de code de la diapositive ci-dessus.
1. La variable v_myName est déclarée dans la section déclarative du bloc. Cette variable
est accessible via la section exécutable du même bloc. La valeur John est affectée à la
variable dans la section exécutable. Les littéraux de type chaîne doivent être placés entre
apostrophes. Si la chaîne comporte une apostrophe, comme dans "Today's Date",
indiquez "Today"s Date" (deux apostrophes entre "y" et "s"). ":=" est l'opérateur
d'affectation. La procédure PUT_LINE est appelée via la transmission de la variable
v_myName. La valeur de la variable est concaténée avec la chaîne "My name is: ".
La sortie de ce bloc anonyme est la suivante :
2. Dans ce bloc, la variable v_myName est déclarée et initialisée dans la section

déclarative. v_myName contient la valeur John après l'initialisation. Cette valeur est
manipulée dans la section exécutable du bloc. La sortie de ce bloc anonyme est la
suivante :

Délimiteurs dans les littéraux de type chaîne
DECLARE
v_event VARCHAR2(15);
BEGIN
v_event := q'!Father's day!';
DBMS_OUTPUT.PUT_LINE('3rd Sunday in June is :
'|| v_event );
v_event := q'[Mother's day]';
DBMS_OUTPUT.PUT_LINE('2nd Sunday in May is :
'|| v_event );

END;
/
Délimiteurs dans les littéraux de type chaîne

Si la chaîne contient une apostrophe, vous devez doubler celle-ci. Par exemple :
v_event VARCHAR2(15):='Father''s day';
La première apostrophe joue le rôle de caractère d'échappement. Cela a pour effet de
compliquer la chaîne, en particulier si vous utilisez des instructions SQL en tant que chaînes.
Vous pouvez désigner comme délimiteur n'importe quel caractère qui ne fait pas partie de la
chaîne. La diapositive ci-dessus illustre l'utilisation de la notation q' pour définir le
délimiteur. L'exemple utilise les délimiteurs ! et [. Examinons l'exemple suivant :
v_event := q'!Father's day!';
Vous pouvez le comparer au premier exemple de cette page. Vous commencez la chaîne avec
q' si vous souhaitez utiliser un délimiteur. Le caractère qui suit la notation est le délimiteur
utilisé. Entrez la chaîne après avoir défini le délimiteur, fermez ce dernier, puis terminez la
notation par une apostrophe. L'exemple qui suit illustre l'utilisation du caractère [ comme
délimiteur.
v_event := q'[Mother's day]';

Types de variable
• Variables PL/SQL :
– Scalaire
– Composite
– Référencée
– LOB
• Variables non PL/SQL : Variables attachées

Types de variable
Toutes les variables PL/SQL présentent un type de données qui définit un format de stockage,
des contraintes et une plage de valeurs valide. Le langage PL/SQL prend en charge cinq
catégories de types de données que vous pouvez utiliser pour déclarer des variables, des
constantes et des pointeurs : scalaire, composite, référencé, LOB (Large Object) et objet.
• Types de données scalaires : Les types de données scalaires contiennent une seule
valeur. La valeur dépend du type de données de la variable. Par exemple, la variable
v_myName utilisée dans l'exemple de la section "Déclarer et initialiser des variables
PL/SQL" (dans ce chapitre) est de type VARCHAR2. Par conséquent, v_myName peut
contenir une valeur de type chaîne. Le langage PL/SQL prend également en charge les
variables booléennes.
• Types de données composites : Les types de données composites contiennent des
éléments internes de type scalaire ou composite. RECORD et TABLE sont des exemples
de types de données composites.
• Types de données référencés : Les types de données référencés contiennent des valeurs,
appelées pointeurs, qui désignent un emplacement de stockage.
• Types de données LOB : Les types de données LOB contiennent des valeurs, appelées
pointeurs, qui indiquent l'emplacement d'objets volumineux (par exemple des images)
stockés à l'extérieur de la table.
Les variables non PL/SQL comprennent les variables du langage hôte déclarées dans des
précompilateurs, les champs d'écran des applications Forms et les variables hôte. Les
variables hôte seront décrites plus loin dans ce chapitre.
Pour plus d'informations sur les types de données LOB, consultez le manuel PL/SQL User's
Guide and Reference.
Types de variable
TRUE 25-JAN-01
Blanche Neige
Il y a bien longtemps,
dans un pays lointain,
vivait une princesse appelée
Blanche Neige. . .

256120.08 Atlanta
Types de variable (suite)

La diapositive illustre les types de données suivants :
• TRUE représente une valeur booléenne.
• 25-JAN-01 représente une variable de type DATE.
• L'image représente un objet BLOB.
• Le texte de la légende peut représenter un type de données VARCHAR2 ou CLOB.
• 256120.08 représente un type de données NUMBER avec sa précision et son échelle.
• Le film représente un BFILE.
• Le nom de ville, Atlanta, représente une variable de type VARCHAR2.

Règles de déclaration et d'initialisation

des variables PL/SQL
• Respectez les conventions d'appellation.
• Utilisez des identificateurs évocateurs pour les variables.
• Initialisez les variables désignées comme NOT NULL et
CONSTANT.
• Initialisez les variables avec l'opérateur d'affectation (:=)
ou le mot-clé DEFAULT :
v_myName VARCHAR2(20):='John';
v_myName VARCHAR2(20) DEFAULT 'John';

• Déclarez un identificateur par ligne pour améliorer la
lisibilité et faciliter la maintenance du code.
Règles de déclaration et d'initialisation des variables PL/SQL

Voici quelques règles à suivre lors de la déclaration de variables PL/SQL :
• Respectez les conventions d'appellation, par exemple name pour représenter une variable
et c_name pour représenter une constante. De même, pour nommer une variable, vous
pouvez utiliser v_fname.
• Utilisez des identificateurs évocateurs et appropriés pour les variables. Par exemple,
envisagez d'utiliser salary et sal_with_commission plutôt que salary1 et
salary2.
• Si vous utilisez la contrainte NOT NULL, vous devez affecter une valeur lorsque vous
déclarez la variable.
• Dans les déclarations de constante, le mot-clé CONSTANT doit précéder le type. La
déclaration qui suit nomme une constante de type NUMBER et affecte la valeur 50 000 à
cette constante. Une constante doit être initialisée dans sa déclaration. Sinon, vous
recevez une erreur de compilation. Dès lors qu'une constante a été initialisée, sa valeur ne
peut pas être modifiée.
sal CONSTANT NUMBER := 50000.00;

Règles relatives à la déclaration

de variables PL/SQL
• Evitez d'utiliser des noms de colonne comme
identificateurs.
DECLARE
employee_id NUMBER(6);
BEGIN
SELECT employee_id
INTO employee_id
FROM employees
WHERE last_name = 'Kochhar';
END;

/
• Utilisez la contrainte NOT NULL lorsque la variable doit

contenir une valeur.
Règles relatives à la déclaration de variables PL/SQL

• Initialisez la variable par une expression avec l'opérateur d'affectation (:=) ou avec le
mot réservé DEFAULT. Si vous n'affectez pas de valeur initiale, la nouvelle variable
contient NULL jusqu'à ce qu'une valeur lui soit affectée. Pour affecter ou réaffecter une
valeur à une variable, vous devez écrire une instruction d'affectation PL/SQL. En
programmation, il est conseillé d'initialiser toutes les variables.
• Deux objets ne peuvent porter le même nom que s'ils sont définis dans des blocs
différents. Lorsqu'ils cohabitent, vous pouvez les qualifier avec des étiquettes et les
utiliser.
• Evitez d'utiliser des noms de colonne comme identificateurs. Si des variables PL/SQL
figurent dans une instruction SQL avec le nom d'une colonne, le serveur Oracle considère
que c'est la colonne qui est référencée. L'exemple de code de la diapositive ci-dessus
fonctionne, mais un code qui utilise le même nom pour une table de base de données et
une variable n'est pas facile à lire ni à mettre à jour.
• Imposez la contrainte NOT NULL lorsque la variable doit contenir une valeur. Vous ne
pouvez pas affecter de valeur NULL à une variable avec la contrainte NOT NULL. La
contrainte NOT NULL doit être suivie d'une clause d'initialisation.
pincode VARCHAR2(15) NOT NULL := 'Oxford';

Types de données scalaires
• Ils contiennent une valeur unique.

• Ils n'ont pas de composant interne.
TRUE 25-JAN-01
L'âme du paresseux a
des désirs qu'il ne peut satisfaire ;
Mais l'âme des hommes

diligents sera rassasiée.
256120.08 Atlanta
Types de données scalaires

Le langage PL/SQL propose différents types de données prédéfinis. Par exemple, vous avez
le choix entre les types entier, virgule flottante, caractère, booléen, date, collection et LOB.
Ce chapitre décrit les types de base fréquemment utilisés dans les programmes PL/SQL.
Un type de données scalaire contient une seule valeur et ne possède pas de composants
internes. On distingue quatre catégories : numérique, caractère, date et booléen. Les types
caractère et numérique comportent des sous-types qui associent un type de base à une
contrainte. Par exemple, INTEGER et POSITIVE sont des sous-types du type de base
NUMBER.
Pour plus d'informations sur les types de données scalaires (et pour obtenir une liste
complète), consultez le manuel PL/SQL User's Guide and Reference.

Types de données scalaires de base
• CHAR [(maximum_length)]
• VARCHAR2 (maximum_length)
• NUMBER [(precision, scale)]
• BINARY_INTEGER
• PLS_INTEGER
• BOOLEAN
• BINARY_FLOAT
• BINARY_DOUBLE


Type de données Description
CHAR Type de base pour les chaînes de caractères de longueur fixe allant
[(maximum_length)] jusqu'à 32 767 octets. Si vous n'indiquez pas la longueur maximale,
la longueur par défaut est 1.
VARCHAR2 Type de base pour les chaînes de caractères de longueur variable
(maximum_length) allant jusqu'à 32 767 octets. Il n'existe pas de taille par défaut pour
les variables et les constantes VARCHAR2.
NUMBER Nombre dont la précision est p et l'échelle s. La précision peut être
[(precision, comprise entre 1 et 38. L'échelle peut être comprise entre -84 et 127.
scale)]
BINARY_INTEGER Type de base pour les entiers compris entre -2 147 483 647 et
2 147 483 647.

Types de données scalaires de base (suite)

PLS_INTEGER Type de base pour les entiers signés compris entre -2 147 483 647
et 2 147 483 647. Les valeurs PLS_INTEGER nécessitent un
espace de stockage moins important et sont plus rapides à traiter
que les valeurs NUMBER. Dans Oracle Database 10g, les types de
données PLS_INTEGER et BINARY_INTEGER sont identiques.
Les opérations arithmétiques sur les valeurs PLS_INTEGER et
BINARY_INTEGER sont plus rapides que sur les valeurs NUMBER.
BOOLEAN Type de base admettant l'une des trois valeurs possibles utilisées
dans les calculs logiques : TRUE, FALSE et NULL.
BINARY_FLOAT Représente un nombre en virgule flottante au format IEEE 754.

Nécessite 5 octets pour le stockage de la valeur.
BINARY_DOUBLE Représente un nombre en virgule flottante au format IEEE 754.

Nécessite 9 octets pour le stockage de la valeur.

• DATE
• TIMESTAMP
• TIMESTAMP WITH TIME ZONE
• TIMESTAMP WITH LOCAL TIME ZONE
• INTERVAL YEAR TO MONTH
• INTERVAL DAY TO SECOND


DATE Type de base pour les dates et les heures. Les valeurs DATE incluent l'heure de
la journée en secondes à partir de minuit. La plage des dates est comprise entre
4712 avant J.-C. et 9999 après J.-C.
TIMESTAMP Le type de données TIMESTAMP, qui étend le type DATE, stocke l'année, le
mois, le jour, l'heure, les minutes, les secondes et la partie décimale des secondes.
La syntaxe est TIMESTAMP[(precision)], où le paramètre facultatif
precision indique le nombre de chiffres de la partie décimale du champ des
secondes. Pour indiquer la précision, vous devez utiliser un entier compris entre 0
et 9. La valeur par défaut est 6.
TIMESTAMP WITH Le type de données TIMESTAMP WITH TIME ZONE, qui étend le type
TIME ZONE TIMESTAMP, inclut un décalage horaire. Le décalage horaire représente la
différence (en heures et en minutes) entre l'heure locale et l'heure UTC
(Coordinated Universal Time), anciennement heure GMT (Greenwich Mean
Time). La syntaxe est TIMESTAMP[(precision)] WITH TIME ZONE,
où le paramètre facultatif precision indique le nombre de chiffres de la partie
décimale du champ des secondes. Pour indiquer la précision, vous devez utiliser
un entier compris entre 0 et 9. La valeur par défaut est 6.


TIMESTAMP WITH Le type de données TIMESTAMP WITH LOCAL TIME ZONE, qui étend le
LOCAL TIME ZONE type TIMESTAMP, inclut un décalage horaire. Le décalage horaire représente
la différence (en heures et en minutes) entre l'heure locale et l'heure UTC
(Coordinated Universal Time), anciennement heure GMT (Greenwich Mean
Time). La syntaxe est TIMESTAMP[(precision)] WITH LOCAL
TIME ZONE, où le paramètre facultatif precision indique le nombre de
chiffres de la partie décimale du champ des secondes. Vous ne pouvez pas
utiliser de variable ni de constante symbolique pour définir la précision. Vous
devez utiliser un entier littéral compris entre 0 et 9. La valeur par défaut est 6.
Ce type de données diffère de TIMESTAMP WITH TIME ZONE, car
lorsque vous insérez une valeur dans une colonne de base de données, cette
valeur est normalisée en fonction du fuseau horaire de la base de données. En

outre, le décalage horaire n'est pas stocké dans la colonne. Lorsque vous
extrayez la valeur, le serveur Oracle la réadapte au fuseau horaire local de
votre session.
INTERVAL YEAR Le type de données INTERVAL YEAR TO MONTH permet de stocker et de
TO MONTH manipuler des intervalles d'années et de mois. La syntaxe est INTERVAL
YEAR[(precision)] TO MONTH, où precision indique le nombre
de chiffres du champ des années. Vous ne pouvez pas utiliser de variable ni
de constante symbolique pour définir la précision. Vous devez utiliser un
entier littéral compris entre 0 et 4. La valeur par défaut est 2.
INTERVAL DAY TO Le type de données INTERVAL DAY TO SECOND permet de stocker et de
SECOND manipuler des intervalles de jours, d'heures, de minutes et de secondes. La
syntaxe est INTERVAL DAY[(precision1)] TO
SECOND[(precision2)], où precision1 et precision2 indiquent
respectivement le nombre de chiffres du champ des jours et du champ des
secondes. Dans les deux cas, vous ne pouvez pas utiliser de variable ni de
constante symbolique pour définir la précision. Vous devez utiliser un entier
littéral compris entre 0 et 9. Les valeurs par défaut sont 2 et 6 respectivement.

Déclaration de variables scalaires
Exemples :
DECLARE
v_emp_job VARCHAR2(9);
v_count_loop BINARY_INTEGER := 0;
v_dept_total_sal NUMBER(9,2) := 0;
v_orderdate DATE := SYSDATE + 7;
c_tax_rate CONSTANT NUMBER(3,2) := 8.25;
v_valid BOOLEAN NOT NULL := TRUE;

...
Déclaration de variables scalaires

Les exemples de déclaration de variable présentés dans la diapositive ci-dessus ont la
signification suivante :
• v_emp_job : Variable destinée au stockage de l'intitulé du poste d'un employé.
• v_count_loop : Variable dont la valeur initiale est 0 et qui sert à compter les
itérations d'une boucle.
• v_dept_total_sal : Variable dont la valeur initiale est 0 et qui sert à cumuler
la masse salariale d'un département.
• v_orderdate : Variable dont la valeur initiale est une semaine après la date du jour.
Elle sert à stocker la date d'expédition d'une commande.
• c_tax_rate : Constante correspondant au taux de taxe, dont la valeur est 8.25
(ne change jamais dans le bloc PL/SQL).
• v_valid : Indicateur dont la valeur initiale est TRUE et qui définit si une donnée est
valide ou non.

Attribut %TYPE
• est utilisé pour déclarer une variable en fonction :

– d'une définition de colonne de base de données
– d'une autre variable déclarée
• est préfixé avec :
– la table et la colonne de base de données
– le nom de la variable déclarée

Attribut %TYPE
Les variables PL/SQL sont généralement déclarées pour contenir des données stockées dans
une base en vue de leur manipulation. Lors de la déclaration de variables PL/SQL devant
contenir des valeurs de colonne, vous devez vous assurer que le type et la précision de ces
variables sont corrects. Dans le cas contraire, une erreur PL/SQL survient au moment de
l'exécution. Si vous devez concevoir des sous-programmes volumineux, le processus peut être
long et sujet à erreur.
Plutôt que de coder en dur le type et la précision d'une variable, vous pouvez utiliser l'attribut
%TYPE pour déclarer une variable par rapport à une autre variable déclarée antérieurement ou
par rapport à une colonne de base de données. L'attribut %TYPE est le plus souvent utilisé
lorsque la valeur stockée dans la variable est issue d'une table de la base de données. Lorsque
vous utilisez l'attribut %TYPE pour déclarer une variable, vous devez préfixer celle-ci avec le
nom de la table et de la colonne de la base de données. Si vous référencez une variable
déclarée précédemment, faites précéder le nom de celle-ci du nom de la variable en cours de
déclaration.

Attribut %TYPE (suite)

Avantages de l'attribut %TYPE
• Vous pouvez éviter les erreurs provoquées par une non-correspondance de type de données ou
une précision incorrecte.
• Vous pouvez éviter le codage en dur du type de données d'une variable.
• Il n'est pas nécessaire de modifier la déclaration de la variable si la définition de la colonne
change. Si vous avez déjà déclaré des variables pour une table particulière sans utiliser l'attribut
%TYPE, le bloc PL/SQL peut générer des erreurs si la colonne pour laquelle la variable est
déclarée est modifiée. Lorsque vous utilisez l'attribut %TYPE, le compilateur PL/SQL détermine
le type de données et la taille de la variable lors de la compilation du bloc. Cela permet de
garantir qu'une telle variable est toujours compatible avec la colonne utilisée pour l'alimenter.

Déclarer des variables avec l'attribut %TYPE
Syntaxe
identifier table.column_name%TYPE;
Exemples
...
emp_lname employees.last_name%TYPE;
...
...

balance NUMBER(7,2);
min_balance balance%TYPE := 1000;
...
Déclarer des variables avec l'attribut %TYPE

Dans l'exemple de la diapositive ci-dessus, une variable est déclarée pour stocker le nom de
famille d'un employé. La variable emp_lname est définie de telle sorte que son type de
données soit le même que celui de la colonne last_name de la table employees.
L'attribut %TYPE représente le type de données d'une colonne de base de données.
Toujours dans cet exemple, des variables sont déclarées pour stocker le solde d'un compte
bancaire, ainsi que le solde minimal, qui est initialisé à 1 000. La variable min_balance est
définie de telle sorte que son type de données soit le même que celui de la variable
balance. L'attribut %TYPE représente le type de données d'une variable.
La contrainte de colonne NOT NULL ne s'applique pas aux variables déclarées avec %TYPE.
Par conséquent, si vous déclarez une variable à l'aide de l'attribut %TYPE se référant à une
colonne de base de données NOT NULL, vous pouvez affecter la valeur NULL à cette variable.

Déclarer des variables booléennes
• Seules les valeurs TRUE, FALSE et NULL peuvent être

affectées à une variable booléenne.
• Les expressions conditionnelles utilisent les opérateurs
logiques AND et OR, ainsi que l'opérateur unaire NOT, pour
vérifier les valeurs des variables.
• Les variables renvoient toujours TRUE, FALSE ou NULL.
• Des expressions de type arithmétique, caractère ou date
peuvent être utilisées pour renvoyer une valeur booléenne.

Déclarer des variables booléennes

En langage PL/SQL, vous pouvez comparer des variables aussi bien dans des instructions
SQL que dans des instructions procédurales. Ces comparaisons, appelées expressions
booléennes, sont représentées par des expressions simples ou complexes séparées par des
opérateurs relationnels. Dans une instruction SQL, vous pouvez utiliser des expressions
booléennes pour désigner les lignes d'une table concernées par l'instruction. Dans une
instruction procédurale, les expressions booléennes sont la base du contrôle conditionnel.
NULL représente une valeur manquante, inapplicable ou inconnue.
Exemples
emp_sal1 := 50000;
emp_sal2 := 60000;
L'expression suivante renvoie TRUE :
emp_sal1 < emp_sal2
Déclarez et initialisez une variable booléenne :
DECLARE
flag BOOLEAN := FALSE;
BEGIN
flag := TRUE;
END;
/

Variables attachées
Les variables attachées sont :

• créées dans l'environnement
• également appelées variables hôte
• créées avec le mot-clé VARIABLE
• utilisées dans les instructions SQL et les blocs PL/SQL
• accessibles même après l'exécution du bloc PL/SQL
• référencées avec un signe deux-points précédant la
variable

Variables attachées
Les variables attachées (bind variables) sont des variables que vous créez dans un
environnement hôte. Pour cette raison, elles sont parfois appelées variables hôte.
Utilisation des variables attachées
Les variables attachées sont créées dans l'environnement et non dans la section déclarative
d'un bloc PL/SQL. Les variables déclarées dans un bloc PL/SQL sont disponibles uniquement
lorsque vous exécutez le bloc. Une fois le bloc exécuté, la mémoire utilisée par la variable est
libérée. Cependant, les variables attachées restent accessibles après l'exécution du bloc. Par
conséquent, lorsqu'elles sont créées, les variables attachées peuvent être utilisées et
manipulées par plusieurs sous-programmes. Elles peuvent être utilisées dans les instructions
SQL et les blocs PL/SQL comme n'importe quelle autre variable. Ces variables peuvent être
transmises en tant que valeurs d'exécution à destination ou en provenance de sous-
programmes PL/SQL.
Créer des variables attachées
Pour créer une variable attachée dans SQL Developer, utilisez la commande VARIABLE.
Par exemple, vous pouvez déclarer des variables de type NUMBER et VARCHAR2 comme
suit :
VARIABLE return_code NUMBER
VARIABLE return_msg VARCHAR2(30)
SQL Developer peut référencer la variable attachée et afficher sa valeur via la commande
PRINT.

Variables attachées (suite)

Exemple
Vous pouvez référencer une variable attachée dans un programme PL/SQL en faisant précéder la
variable du signe deux-points :
VARIABLE b_result NUMBER
BEGIN
SELECT (SALARY*12) + NVL(COMMISSION_PCT,0) INTO :b_result
FROM employees WHERE employee_id = 144;
END;
/
PRINT b_result
b_result
----------

30000
Remarque : Lorsque vous créez une variable attachée de type NUMBER, vous ne pouvez pas
indiquer la précision et l'échelle. Vous pouvez en revanche indiquer la taille des chaînes de
caractères. Une variable du type Oracle NUMBER est stockée de la même façon quelle que soit la
dimension. Le serveur Oracle utilise le même nombre d'octets pour stocker les valeurs 7, 70 et
0,0734. Il n'est pas commode de calculer la taille de la représentation du nombre Oracle à partir du
format numérique. Le code alloue donc systématiquement le nombre d'octets requis. Avec les
chaînes de caractères, la taille doit être indiquée par l'utilisateur, afin que le nombre requis d'octets
puisse être alloué.

Afficher des variables attachées
Exemple :
VARIABLE b_emp_salary NUMBER
BEGIN
SELECT salary INTO :b_emp_salary
END;
/
PRINT b_emp_salary
SELECT first_name, last_name FROM employees
WHERE salary=:b_emp_salary;


Dans SQL*Plus, vous pouvez afficher la valeur d'une variable attachée à l'aide de la
commande PRINT.
Lorsque vous exécutez le bloc PL/SQL illustré dans la diapositive ci-dessus, vous obtenez la
sortie suivante lors du traitement de la commande PRINT :
b_emp_salary
------------------
7000
b_emp_salary est une variable attachée. Vous pouvez à présent utiliser cette variable dans
une instruction SQL ou un programme PL/SQL quelconque. Notez l'instruction SQL qui
utilise la variable attachée. La sortie de l'instruction SQL est la suivante :
FIRST_NAME LAST_NAME
------------------ ----------------------
Oliver Tuvault
Sarath Sewall
Kimberely Grant
Remarque : Utilisez la commande PRINT sans variable pour afficher toutes les variables
attachées.

Exemple :
VARIABLE b_emp_salary NUMBER

SET AUTOPRINT ON
DECLARE
v_empno NUMBER(6):=&empno;
BEGIN
SELECT salary INTO :b_emp_salary
FROM employees WHERE employee_id = v_empno;
END;

Sortie :
7000
Afficher des variables attachées (suite)

Utilisez la commande SET AUTOPRINT ON pour afficher automatiquement les variables
attachées utilisées dans un bloc PL/SQL qui s'exécute correctement.

Variables de type LOB
Livre
(CLOB)
Photo
(BLOB)
Film

(BFILE)
NCLOB
Variables de type LOB

Les objets LOB (Large Objects) sont conçus pour le stockage de grandes quantités de
données. Une colonne de base de données peut être de la catégorie LOB. Avec les types de la
catégorie LOB (BLOB, CLOB, etc.), vous pouvez stocker des blocs de données non structurées
(par exemple du texte, des images, des clips vidéo et des sons) dont la taille peut aller jusqu'à
128 téraoctets selon la taille de bloc de la base. Les types de données LOB permettent un
accès efficace, aléatoire et par morceaux aux données. Ils peuvent être utilisés comme
attributs d'un type Objet.
• Le type CLOB (Character Large Object) est utilisé pour le stockage de blocs volumineux
de données de type caractère dans la base.
• Le type BLOB (Binary Large Object) est utilisé pour le stockage d'objets binaires
volumineux structurés ou non structurés dans la base de données. Lorsque des données de
ce type sont insérées ou extraites dans la base, elles ne sont pas interprétées par la base.
Ce sont les applications externes qui les utilisent qui doivent les interpréter.
• Le type BFILE (Binary File) est utilisé pour le stockage de fichiers binaires volumineux.
Contrairement aux autres objets LOB, les objets BFILE ne sont pas stockés dans la base
de données. Ils sont stockés à l'extérieur de la base. Il peut s'agir de fichiers du système
d'exploitation. Seul un pointeur vers l'objet BFILE est stocké dans la base.
• Le type NCLOB (NLS Character Large Object) permet de stocker dans la base de grands
blocs de données Unicode NCHAR mono-octets ou multi-octets de longueur fixe.

Types de données composites
TRUE 23-DEC-98 ATLANTA
Structure d'une table PL/SQL Structure d'une table PL/SQL
1 SMITH 1 5000
2 JONES 2 2345

3 NANCY 3 12
4 TIM 4 3456
VARCHAR2 NUMBER
PLS_INTEGER PLS_INTEGER

Un type scalaire ne possède pas de composants internes. Un type composite comporte des
composants internes qui peuvent être manipulés de manière individuelle. Les types de
données composites (également appelés collections) correspondent aux types TABLE,
RECORD, NESTED TABLE et VARRAY.
Utilisez le type TABLE pour référencer et manipuler des collections de données en tant
qu'objet unique. Utilisez le type RECORD pour traiter des données liées mais dissemblables en
tant qu'unité logique.
Les types de données NESTED TABLE et VARRAY sont étudiés dans le cours Oracle
Database 11g : Objets procéduraux basés d'Oracle.

Synthèse

• reconnaître les identificateurs valides et non valides
• déclarer des variables dans la section déclarative d'un bloc
PL/SQL
• initialiser des variables et les utiliser dans la section
exécutable
• distinguer les types de données scalaires et composites
• utiliser l'attribut %TYPE

• utiliser des variables attachées
Synthèse
Un bloc PL/SQL anonyme représente l'unité de base, sans nom, d'un programme PL/SQL. Il
se compose d'un ensemble d'instructions SQL ou PL/SQL permettant d'exécuter une fonction
logique. La section déclarative constitue la première partie d'un bloc PL/SQL. Elle sert à
déclarer des objets tels que les variables, les constantes, les curseurs et les définitions des
situations d'erreur (exceptions).
Dans ce chapitre, vous avez appris à déclarer des variables dans la section déclarative.
Vous avez étudié quelques-unes des règles de déclaration des variables. Vous avez appris à
initialiser les variables lors de leur déclaration.
La section exécutable représente la partie obligatoire d'un bloc PL/SQL. Elle contient des
instructions SQL et PL/SQL permettant l'interrogation et à la manipulation de données.
Vous avez appris à initialiser des variables dans la section exécutable, ainsi qu'à les utiliser et
à manipuler leurs valeurs.


• Déterminer les identificateurs valides
• Déterminer les déclarations de variable valides
• Déclarer des variables dans un bloc anonyme
• Utiliser l'attribut %TYPE pour déclarer des variables
• Déclarer et afficher une variable attachée
• Exécuter un bloc PL/SQL

Les points 1, 2 et 3 sont à traiter par écrit.

Exercice 2
1. Déterminez les noms d'identificateur valides et non valides :
a. today
b. last_name
c. today’s_date
d. Number_of_days_in_February_this_year
e. Isleap$year
f. #number
g. NUMBER#
h. number1to7
2. Identifiez les déclarations et initialisations valides et non valides des variables :

a. number_of_copies PLS_INTEGER;
b. printer_name constant VARCHAR2(10);

c. deliver_to VARCHAR2(10):=Johnson;
d. by_when DATE:= CURRENT_DATE+1;
3. Examinez le bloc anonyme suivant et choisissez l'affirmation appropriée.

DECLARE
v_fname VARCHAR2(20);
v_lname VARCHAR2(15) DEFAULT 'fernandez';
BEGIN
DBMS_OUTPUT.PUT_LINE(v_fname ||' ' ||v_lname);
END;
/
a. Le bloc s'exécute avec succès et affiche "fernandez".
b. Le bloc renvoie une erreur, car la variable fname est utilisée sans initialisation.
c. Le bloc s'exécute avec succès et affiche "null fernandez".
d. Le bloc renvoie une erreur, car vous ne pouvez pas utiliser le mot-clé DEFAULT pour
initialiser une variable de type VARCHAR2.
e. Le bloc génère une erreur, car la variable v_fname n'est pas déclarée.
4. Créez un bloc anonyme. Dans SQL Developer, chargez le script lab_01_02_soln.sql que
vous avez créé à la question 2 de l'exercice 1.
a. Ajoutez une section déclarative à ce bloc PL/SQL. Dans la section déclarative, déclarez les
variables suivantes :
1. Variable v_today de type DATE. Initialisez today avec SYSDATE.
2. Variable v_tomorrow de type today. Utilisez l'attribut %TYPE pour déclarer cette
variable.
b. Dans la section exécutable, initialisez la variable tomorrow avec une expression qui
calcule la date du lendemain (ajoutez la valeur "un" à la valeur de today). Affichez la
valeur de today et de tomorrow après l'affichage de "Hello World".

Exercice 2 (suite)
c. Exécutez ce script et enregistrez-le sous le nom lab_02_04_soln.sql. Un exemple
de sortie est présenté ci-après.
5. Editez le script lab_02_04_soln.sql.

a. Ajoutez du code afin de créer deux variables attachées.
Créez les variables attachées b_basic_percent et b_pf_percent de type NUMBER.
b. Dans la section exécutable du bloc PL/SQL, affectez les valeurs 45 et 12 respectivement à
b_basic_percent et à b_pf_percent.

c. Terminez le bloc PL/SQL avec "/" et affichez la valeur des variables attachées à l'aide de
la commande PRINT.
d. Exécutez le script et enregistrez-le sous le nom lab_02_05_soln.sql. Un exemple de
sortie est présenté ci-après.


Ecrire des instructions exécutables

Objectifs

• identifier les unités lexicales d'un bloc PL/SQL
• utiliser des fonctions SQL intégrées dans du code PL/SQL
• décrire dans quels cas des conversions implicites ont lieu
et dans quels cas effectuer des conversions explicites
• écrire des blocs imbriqués et qualifier des variables avec
des étiquettes
• écrire du code lisible, grâce à une indentation appropriée

• utiliser des séquences dans des expressions PL/SQL
But du chapitre
Vous avez appris à déclarer des variables et à écrire des instructions exécutables dans un bloc
PL/SQL. Dans le présent chapitre, vous découvrirez comment des unités lexicales constituent
un bloc PL/SQL. Vous apprendrez à écrire des blocs imbriqués. Vous découvrirez également
la portée et la visibilité des variables dans les blocs imbriqués, ainsi que la qualification des
variables à l'aide d'étiquettes.

Unités lexicales d'un bloc PL/SQL
Les unités lexicales :

• sont les blocs constitutifs de n'importe quel bloc PL/SQL
• sont des séquences de caractères incluant des lettres,
des nombres, des tabulations, des espaces, des retours
chariot et des symboles
• peuvent être classées en différents groupes :
– Identificateurs : v_fname, c_percent
– Délimiteurs : ; , +, -

– Littéraux : John, 428, True
– Commentaires : --, /* */
Unités lexicales d'un bloc PL/SQL

Les unités lexicales incluent des lettres, des nombres, des caractères spéciaux, des tabulations,
des espaces, des retours chariot et des symboles.
• Identificateurs : Les identificateurs sont les noms attribués aux objets PL/SQL. Vous
avez appris à identifier les identificateurs valides et non valides. Rappelez-vous que les
mots-clés ne peuvent pas être utilisés comme identificateurs.
Identificateurs entre guillemets :
- Indiquer que les identificateurs distinguent les majuscules des minuscules.
- Inclure des caractères, tels que des espaces.
- Utiliser des mots réservés.
Exemples :
"begin date" DATE;
"end date" DATE;
"exception thrown" BOOLEAN DEFAULT TRUE;
De telles variables doivent être indiquées entre guillemets à chaque utilisation. Toutefois,
l'utilisation d'identificateurs entre guillemets n'est pas recommandée.
• Délimiteurs : Les délimiteurs sont des symboles qui présentent une signification
particulière. Nous avons vu précédemment que le point-virgule (;) est utilisé pour
terminer une instruction SQL ou PL/SQL. Par conséquent, il constitue un exemple de
délimiteur.
Pour plus d'informations, reportez-vous au manuel PL/SQL User's Guide and Reference.

Unités lexicales d'un bloc PL/SQL (suite)

• Délimiteurs (suite)
Les délimiteurs sont des symboles simples ou composés qui ont une signification précise en
langage PL/SQL.
Symboles simples
Symbole Signification
+ Opérateur d'addition
- Opérateur de
soustraction/négation
* Opérateur de multiplication
/ Opérateur de division
= Opérateur d'égalité
@ Indicateur d'accès distant

; Indicateur de fin d'instruction
Symboles composés
Symbole Signification
<> Opérateur de non-égalité
!= Opérateur de non-égalité
|| Opérateur de concaténation
-- Indicateur de commentaire
monoligne
/* Délimiteur de début de
commentaire
*/ Délimiteur de fin de commentaire
:= Opérateur d'affectation
Remarque : Les délimiteurs ne sont pas tous détaillés ci-dessus.
• Littéraux : Toute valeur affectée à une variable est un littéral. Un caractère, un nombre, une
valeur booléenne ou une date qui ne constitue pas un identificateur est un littéral. Les littéraux
sont classés comme suit :
- Littéraux de type caractère : Tous les littéraux de type chaîne présentent le type CHAR ou
VARCHAR2 et sont donc appelés littéraux de type caractère (par exemple John et 12C).
- Littéraux numériques : Les littéraux numériques représentent une valeur entière ou réelle
(par exemple, 428 et 1,276).
- Littéraux booléens : Les valeurs affectées aux variables booléennes sont des littéraux
booléens. TRUE, FALSE et NULL sont des littéraux ou des mots-clés booléens.
• Commentaires : Il est judicieux d'expliquer le rôle d'une section de code lors de la
programmation. Lorsque vous incluez des explications dans un bloc PL/SQL, le compilateur ne
peut pas interpréter ces instructions. Il faut pouvoir indiquer que ces instructions ne doivent pas
être compilées. Les commentaires sont principalement utilisés pour cela. Toute instruction
marquée comme commentaire n'est pas interprétée par le compilateur.
- Indiquez deux traits d'union (--) pour marquer une ligne unique en tant que commentaire.
- Utilisez les délimiteurs de début et de fin de commentaire (/* et */) pour mettre en
commentaire plusieurs lignes.
Syntaxe des blocs PL/SQL et règles à respecter

• Littéraux
– Les littéraux de type caractère et date doivent être placés entre
apostrophes.
– Les nombres peuvent être des valeurs simples ou utiliser une
notation scientifique.
name := 'Henderson';
• Les instructions peuvent s'étendre sur plusieurs lignes.
1
2

3
Syntaxe des blocs PL/SQL et règles à respecter

Un littéral est une valeur explicite de type numérique, chaîne, date ou booléen, qui n'est pas
représentée par un identificateur.
• Les littéraux de type caractère incluent tous les caractères imprimables du jeu de
caractères PL/SQL : lettres, nombres, espaces et symboles spéciaux.
• Les littéraux numériques peuvent être représentés par une valeur simple (par exemple,
–32,5) ou à l'aide d'une notation scientifique (par exemple, 2E5, c'est-à-dire
2 * 105 = 200 000).
Une instruction peut s'étendre sur plusieurs lignes (comme indiqué dans l'exemple 3 de la
diapositive).
Vous pouvez mettre en forme une instruction SQL non formatée (comme illustré dans
l'exemple 1 de la diapositive) à l'aide de l'option Format SQL du menu contextuel fourni dans
SQL Developer. A l'aide du bouton droit de la souris, cliquez sur la feuille de travail SQL
active et, dans le menu contextuel qui apparaît, sélectionnez Format SQL (comme illustré
dans l'exemple 2).

Inclure des commentaires dans le code
• Faites précéder les commentaires monolignes de deux traits

d'union (--).
• Placez les commentaires multilignes entre les symboles /* et */.
Exemple :
DECLARE
...
v_annual_sal NUMBER (9,2);
BEGIN
/* Compute the annual salary based on the
monthly salary input from the user */

v_annual_sal := monthly_sal * 12;
--The following line displays the annual salary
DBMS_OUTPUT.PUT_LINE(v_annual_sal);
END;
/
Inclure des commentaires dans le code

Incluez des commentaires dans le code pour expliquer chacune des phases du programme et
faciliter le débogage. Si le commentaire occupe une seule ligne, faites-le précéder de deux
traits d'union (--). S'il s'étend sur plusieurs lignes, placez-le entre les symboles /* et */.
Les commentaires sont purement informatifs et n'imposent pas de condition ni de
comportement à la logique ou aux données du programme. Des commentaires bien placés
améliorent considérablement la clarté du code et sa maintenance. Dans l'exemple de la
diapositive ci-dessus, le commentaire placé entre les symboles /* et */ explique le code qui
suit.

Fonctions SQL dans le code PL/SQL
• Disponibles dans les instructions procédurales :

– Fonctions monolignes
• Non disponibles dans les instructions procédurales :
– DECODE
– Fonctions de groupe

Fonctions SQL dans le code PL/SQL

Le langage SQL offre plusieurs fonctions prédéfinies pouvant être utilisées dans les
instructions SQL. La plupart de ces fonctions (telles que les fonctions monolignes numériques
et de type caractère, les fonctions de conversion de type de données et les fonctions de date et
d'horodatage) sont valides dans les expressions PL/SQL.
Les fonctions suivantes ne sont pas disponibles dans les instructions procédurales :
• DECODE
• Fonctions de groupe : AVG, MIN, MAX, COUNT, SUM, STDDEV et VARIANCE.
Les fonctions de groupe s'appliquent à des groupes de lignes dans une table. Par
conséquent, elles ne sont disponibles que dans les instructions SQL d'un bloc PL/SQL.
Les fonctions mentionnées ici ne représentent qu'une partie de toutes les fonctions
disponibles.

Fonctions SQL dans le code PL/SQL : Exemples
• Déterminer la longueur d'une chaîne :

v_desc_size INTEGER(5);
v_prod_description VARCHAR2(70):='You can use this
product with your radios for higher frequency';
-- get the length of the string in prod_description

v_desc_size:= LENGTH(prod_description);
• Déterminer le nombre de mois travaillés par un employé :

v_tenure:= MONTHS_BETWEEN (CURRENT_DATE, v_hiredate);

Fonctions SQL dans le code PL/SQL : Exemples

Vous pouvez utiliser des fonctions SQL pour manipuler des données. Ces fonctions se
répartissent dans les catégories suivantes :
• Fonctions numériques
• Fonctions de type caractère
• Fonctions de conversion
• Fonctions de date
• Fonctions diverses

Utiliser des séquences dans des expressions

PL/SQL
Depuis la version 11g :
DECLARE
v_new_id NUMBER;
BEGIN
v_new_id := my_seq.NEXTVAL;
END;
/
Avant la version 11g :

DECLARE

v_new_id NUMBER;
BEGIN
SELECT my_seq.NEXTVAL INTO v_new_id FROM Dual;
END;
/
Accéder à des valeurs de séquence

Dans Oracle Database 11g, vous pouvez utiliser les pseudo-colonnes NEXTVAL et CURRVAL
dans tout contexte PL/SQL où une expression de type NUMBER peut normalement apparaître.
Bien que l'ancienne méthode consistant à utiliser une instruction SELECT pour interroger une
séquence soit toujours valable, il est conseillé de ne plus l'appliquer.
Avant Oracle Database 11g, vous deviez écrire une instruction SQL pour utiliser une valeur
d'objet de séquence dans un sous-programme PL/SQL. Généralement, vous deviez écrire une
instruction SELECT faisant référence aux pseudo-colonnes NEXTVAL et CURRVAL afin
d'obtenir un numéro de séquence. Cette méthode compliquait l'utilisation des séquences.
Dans Oracle Database 11g, vous n'êtes plus obligé d'écrire une instruction SQL pour extraire
une valeur de séquence. Cette amélioration offre les avantages suivants :
• L'utilisation des séquences est améliorée.
• Le développeur a moins d'éléments à saisir.
• Le code obtenu est plus clair.

Conversion de type de données
• Conversion de données en types comparables

• Deux types de conversion sont disponibles :
– Conversion implicite
– Conversion explicite
• Fonctions :
– TO_CHAR
– TO_DATE
– TO_NUMBER
TO_TIMESTAMP

–

Dans n'importe quel langage de programmation, la conversion d'un type de données dans un
autre est une exigence courante. Le langage PL/SQL permet de traiter ces conversions avec
des types de données scalaires. Il existe deux types de conversion de type de données :
Conversion implicite : Si des types de données sont mélangés dans une instruction, le
langage PL/SQL essaie de les convertir de façon dynamique. Examinons l'exemple suivant :
DECLARE
v_salary NUMBER(6):=6000;
v_sal_hike VARCHAR2(5):='1000';
v_total_salary v_salary%TYPE;
BEGIN
v_total_salary:=v_salary + v_sal_hike;
END;
/
Dans cet exemple, la variable sal_hike est de type VARCHAR2. Lors du calcul du salaire
total, le compilateur PL/SQL commence par convertir sal_hike en NUMBER, puis il
exécute l'opération. Le résultat est de type NUMBER.
Les conversions implicites peuvent avoir lieu entre :
• des caractères et des nombres,
• des caractères et des dates.

Conversion de type de données (suite)

Conversion explicite : Pour convertir des valeurs d'un type de données dans un autre, utilisez des
fonctions intégrées. Par exemple, pour convertir une valeur de type CHAR en valeur de type DATE ou
NUMBER, utilisez respectivement TO_DATE ou TO_NUMBER.

1 date_of_joining DATE:= '02-Feb-2000';
2 date_of_joining DATE:= 'February 02,2000';
date_of_joining DATE:= TO_DATE('February

3

02,2000','Month DD, YYYY');
Conversion de type de données (suite)

Notez les trois exemples de conversions implicites et explicites du type de données DATE
dans la diapositive.
1. Etant donné que le littéral de type chaîne affecté à date_of_joining est au format
par défaut, cet exemple exécute une conversion implicite et affecte la date indiquée à
date_of_joining.
2. Le compilateur PL/SQL renvoie une erreur car la date affectée n'est pas au format par
défaut.
3. La fonction TO_DATE vous permet de convertir explicitement la date donnée dans un
format particulier et de l'affecter à la variable date_of_joining de type DATE.

Blocs imbriqués
Les blocs PL/SQL peuvent être imbriqués.

• Une section exécutable (BEGIN … END)
peut contenir des blocs imbriqués.
• Une section de traitement des
exceptions peut contenir des blocs
imbriqués.

Blocs imbriqués
En tant que compilateur procédural, PL/SQL peut imbriquer des instructions. Vous pouvez
imbriquer des blocs partout où une instruction exécutable est autorisée. Le bloc imbriqué
devient alors une instruction. Si la section exécutable comporte du code pour de nombreuses
fonctionnalités liées logiquement afin de prendre en charge plusieurs besoins métier, vous
pouvez la fractionner en blocs plus petits. La section de traitement des exceptions peut aussi
contenir des blocs imbriqués.

Blocs imbriqués
Exemple :
DECLARE
v_outer_variable VARCHAR2(20):='GLOBAL VARIABLE';
BEGIN
DECLARE
v_inner_variable VARCHAR2(20):='LOCAL VARIABLE';
BEGIN
DBMS_OUTPUT.PUT_LINE(v_inner_variable);
DBMS_OUTPUT.PUT_LINE(v_outer_variable);

END;
DBMS_OUTPUT.PUT_LINE(v_outer_variable);
END;
Blocs imbriqués (suite)

L'exemple de la diapositive ci-dessus comporte un bloc externe (parent) et un bloc imbriqué
(enfant). La variable v_outer_variable est déclarée dans le bloc externe et la variable
v_inner_variable est déclarée dans le bloc interne.
La variable v_outer_variable est locale par rapport au bloc externe, mais globale par
rapport au bloc interne. Lorsque vous accédez à cette variable dans le bloc interne, le
compilateur PL/SQL recherche d'abord une variable locale portant ce nom dans le bloc
interne. Le bloc interne ne comporte aucune variable portant ce nom. Le compilateur PL/SQL
recherche donc la variable dans le bloc externe. Par conséquent, la variable
v_outer_variable est considérée comme la variable globale pour tous les blocs
englobants. Vous pouvez accéder à cette variable dans le bloc interne, comme illustré dans la
diapositive ci-dessus. Les variables déclarées dans un bloc PL/SQL sont considérées comme
locales par rapport à ce bloc et globales par rapport à tous les sous-blocs.
La variable v_inner_variable est locale par rapport au bloc interne. Elle n'est pas
globale car le bloc interne ne comporte aucun bloc imbriqué. Cette variable est accessible
uniquement dans le bloc interne. Si le compilateur PL/SQL ne trouve pas la variable déclarée
localement, il la recherche vers le haut dans la section déclarative des blocs parent. En
revanche, il ne la recherche pas vers le bas dans les blocs enfant.

Portée et visibilité des variables
DECLARE
v_father_name VARCHAR2(20):='Patrick';
v_date_of_birth DATE:='20-Apr-1972';
BEGIN
DECLARE
v_child_name VARCHAR2(20):='Mike';
v_date_of_birth DATE:='12-Dec-2002';
BEGIN
1 DBMS_OUTPUT.PUT_LINE('Father''s Name: '||v_father_name);
DBMS_OUTPUT.PUT_LINE('Date of Birth: '||v_date_of_birth);

DBMS_OUTPUT.PUT_LINE('Child''s Name: '||v_child_name);
2 END;
END;
/
Portée et visibilité des variables

La sortie du bloc présenté dans la diapositive ci-dessus est la suivante :
anonymous block completed
Father's Name: Patrick
Date of Birth: 12-DEC-02
Child's Name: Mike
Date of Birth: 20-APR-72
Examinez la date de naissance affichée pour le père et le fils.
La portée d'une variable est la partie du programme dans laquelle la variable est déclarée et
accessible.
La visibilité d'une variable est la partie du programme dans laquelle la variable est accessible
sans utilisation d'un qualificateur.
Portée
• Les variables v_father_name et v_date_of_birth sont déclarées dans le bloc
externe. Ces variables ont comme portée le bloc dans lequel elles sont déclarées et
accessibles. Par conséquent, la portée de ces variables est limitée au bloc externe.

Portée et visibilité des variables (suite)

Portée (suite)
• Les variables v_child_name et v_date_of_birth sont déclarées dans le bloc interne ou
dans le bloc imbriqué. Ces variables sont accessibles uniquement dans le bloc imbriqué et ne
sont pas accessibles dans le bloc externe. Lorsqu'une variable est hors portée, le compilateur
PL/SQL libère la mémoire utilisée pour son stockage. Elle ne peut donc plus être référencée.
Visibilité
• La portée de la variable v_date_of_birth déclarée dans le bloc externe concerne également
le bloc interne. En revanche, cette variable n'est pas visible dans le bloc interne, car celui-ci
comporte une variable locale portant le même nom.
1. Examinez le code figurant dans la section exécutable du bloc PL/SQL. Vous pouvez
afficher le nom du père, le nom du fils et la date de naissance. Ici, seule la date de naissance
du fils peut être affichée, car la date de naissance du père n'est pas visible.
2. Ici, la date de naissance du père est visible et peut donc être affichée.

Dans un bloc, il n'est pas admis que plusieurs variables portent le même nom. Cependant, vous
pouvez déclarer des variables portant le même nom dans des blocs distincts (blocs imbriqués).
Les deux éléments représentés par les identificateurs sont distincts. Par conséquent, les modifications
apportées à l'un des éléments n'affectent pas l'autre.

Qualifier un identificateur
BEGIN <<outer>>
DECLARE
v_father_name VARCHAR2(20):='Patrick';
v_date_of_birth DATE:='20-Apr-1972';
BEGIN
DECLARE
v_child_name VARCHAR2(20):='Mike';
v_date_of_birth DATE:='12-Dec-2002';
BEGIN
DBMS_OUTPUT.PUT_LINE('Father''s Name: '||v_father_name);
DBMS_OUTPUT.PUT_LINE('Date of Birth: '
||outer.v_date_of_birth);

DBMS_OUTPUT.PUT_LINE('Child''s Name: '||v_child_name);
END;
END;
END outer;
Qualifier un identificateur
Un qualificateur est une étiquette affectée à un bloc. Vous pouvez utiliser ce qualificateur
pour accéder aux variables qui figurent dans la portée mais ne sont pas visibles. Examinez le
code : vous pouvez à présent afficher la date de naissance du père et celle de l'enfant dans le
bloc interne. Le bloc externe est nommé outer. Vous pouvez utiliser cette étiquette pour
accéder à la variable v_date_of_birth déclarée dans le bloc externe.
L'étiquetage n'est pas limité au bloc externe. Vous pouvez étiqueter n'importe quel bloc.
La sortie du code de la diapositive ci-dessus est le suivant :

Quiz : Déterminer la portée d'une variable
BEGIN <<outer>>
DECLARE
v_sal NUMBER(7,2) := 60000;
v_comm NUMBER(7,2) := v_sal * 0.20;
v_message VARCHAR2(255) := ' eligible for commission';
BEGIN
DECLARE
v_sal NUMBER(7,2) := 50000;
v_comm NUMBER(7,2) := 0;
v_total_comp NUMBER(7,2) := v_sal + v_comm;
BEGIN

v_message := 'CLERK not'||v_message;
1 outer.v_comm := v_sal * 0.30;
END;
v_message := 'SALESMAN'||v_message;
2 END;
END outer;
/
Quiz : Déterminer la portée d'une variable

Considérez le bloc PL/SQL de la diapositive ci-dessus. Déterminez chacune des valeurs
suivantes d'après les règles relatives à la portée :
1. Valeur de MESSAGE à la position 1
2. Valeur de TOTAL_COMP à la position 2
3. Valeur de COMM à la position 1
4. Valeur de outer.COMM à la position 1
5. Valeur de COMM à la position 2
6. Valeur de MESSAGE à la position 2

Réponses : Déterminer la portée d'une variable

1. Valeur de MESSAGE à la position 1 : eligible for commission
2. Valeur de TOTAL_COMP à la position 2 : Error. Ici, TOTAL_COMP n'est pas visible car cette
variable est définie dans le bloc interne.
3. Valeur de COMM à la position 1 : 0
4. Valeur de outer.COMM à la position 1 : 15000
5. Valeur de COMM à la position 2 : 12000
6. Valeur de MESSAGE à la position 2 : eligible for commission

Opérateurs en langage PL/SQL
}
• Opérateur logique
• Opérateur arithmétique
• Opérateur de concaténation
Identiques en
• Parenthèses permettant de
contrôler l'ordre des opérations langage SQL
• Opérateur exponentiel (**)

Opérateurs en langage PL/SQL

Les opérations d'une expression sont effectuées dans un ordre particulier, en fonction de leur
priorité. Le tableau suivant indique l'ordre par défaut des opérations selon un niveau de
priorité décroissant :
Opérateur Opération
** Mise en exposant
+, - Identité, négation
*, / Multiplication, division
+, -, || Addition, soustraction, concaténation
=, <, >, <=, >=, <>, !=, ~=, ^=, Comparaison
IS NULL, LIKE, BETWEEN, IN
NOT Négation logique
AND Conjonction
OR Inclusion

Opérateurs en langage PL/SQL : Exemples
• Incrémenter le compteur pour une boucle :

loop_count := loop_count + 1;
• Définir la valeur d'un indicateur booléen :

good_sal := sal BETWEEN 50000 AND 150000;
• Vérifier qu'un numéro d'employé contient une valeur :

valid := (empno IS NOT NULL);
Opérateurs en langage PL/SQL (suite)

Lorsque vous utilisez des valeurs NULL, vous pouvez éviter certaines erreurs fréquentes en
gardant à l'esprit les règles suivantes :
• Les comparaisons mettant en jeu des valeurs NULL renvoient toujours une valeur NULL.
• L'application de l'opérateur logique NOT à une valeur NULL renvoie une valeur NULL.
• Dans les instructions de contrôle conditionnelles, si la condition renvoie une valeur
NULL, la séquence d'instructions associée n'est pas exécutée.

Règles relatives à la programmation
Facilitez la maintenance du code :

• en ajoutant des commentaires
• en développant une convention d'utilisation des majuscules
et des minuscules
• en développant des conventions d'appellation pour les
identificateurs et les autres objets
• en utilisant des indentations pour améliorer la clarté

Règles relatives à la programmation

Lorsque vous développez un bloc PL/SQL, observez les règles de programmation présentées
dans la diapositive ci-dessus, afin de rendre le code plus clair et de simplifier sa maintenance.
Conventions d'utilisation des majuscules et des minuscules
Le tableau suivant fournit des indications générales sur l'utilisation des majuscules et des
minuscules dans le code, afin de faciliter la distinction entre les mots-clés et les noms d'objet.
Catégorie Convention Exemples

d'utilisation des
majuscules et des
minuscules
Instructions SQL Majuscules SELECT, INSERT
Mots-clés PL/SQL Majuscules DECLARE, BEGIN, IF
Types de données Majuscules VARCHAR2, BOOLEAN
Identificateurs et paramètres Minuscules v_sal, emp_cursor, g_sal,

p_empno
Tables et colonnes de base de Minuscules employees, employee_id,
données department_id

Indenter le code
Pour plus de clarté, indentez chaque niveau du code.

DECLARE
deptno NUMBER(4);
BEGIN
location_id NUMBER(4);
IF x=0 THEN
BEGIN
y:=1;
SELECT department_id,
END IF;
location_id
END;
INTO deptno,
/
location_id

FROM departments
WHERE department_name
= 'Sales';
...
END;
/
Indenter le code
Pour plus de clarté et de lisibilité, indentez chaque niveau du code. Pour mettre la structure en
évidence, vous pouvez couper les lignes en utilisant des retours chariot et indenter les lignes
avec des espaces et des tabulations. Comparez la lisibilité des instructions IF suivantes :
IF x>y THEN max:=x;ELSE max:=y;END IF;
IF x > y THEN
max := x;
ELSE
max := y;
END IF;

Synthèse

• identifier les unités lexicales d'un bloc PL/SQL
• utiliser des fonctions SQL intégrées dans du code PL/SQL
• écrire des blocs imbriqués afin de fractionner des
fonctionnalités liées logiquement
• déterminer dans quels cas effectuer des conversions
explicites
• qualifier des variables dans les blocs imbriqués

• utiliser des séquences dans des expressions PL/SQL
Synthèse
Le langage PL/SQL étant une extension du langage SQL, les règles syntaxiques générales qui
régissent le code SQL s'appliquent également à PL/SQL.
Un bloc peut comporter un nombre illimité de blocs imbriqués dans sa section exécutable. Les
blocs définis à l'intérieur d'un bloc sont appelés sous-blocs. Vous ne pouvez imbriquer des
blocs que dans la section exécutable d'un bloc. Etant donné que la section de traitement des
exceptions se trouve dans la section exécutable, cette section peut également comporter des
blocs imbriqués. Assurez-vous que la portée et la visibilité des variables sont correctes lors de
l'utilisation de blocs imbriqués. Evitez d'utiliser les mêmes identificateurs dans les blocs
parent et enfant.
La plupart des fonctions disponibles en langage SQL le sont également dans les expressions
PL/SQL. Les fonctions de conversion convertissent une valeur d'un type de données dans un
autre. Les opérateurs de comparaison permettent de comparer des expressions entre elles. Le
résultat est toujours TRUE, FALSE ou NULL. Généralement, les opérateurs de comparaison
sont utilisés dans les instructions de contrôle conditionnelles, ainsi que dans la clause WHERE
des instructions SQL de manipulation de données. Les opérateurs relationnels permettent de
comparer des expressions complexes.


• Revoir les règles de portée et d'imbrication
• Développer et tester des blocs PL/SQL

Les points 1 et 2 sont à traiter par écrit.

Exercice 3
Bloc PL/SQL
DECLARE
v_weight NUMBER(3) := 600;
v_message VARCHAR2(255) := 'Product 10012';
BEGIN
DECLARE
v_new_locn VARCHAR2(50) := 'Europe';
BEGIN
v_weight := v_weight + 1;
v_new_locn := 'Western ' || v_new_locn;
1

END;
v_message := v_message || ' is in stock';
2
END;
/
1. Observez le bloc PL/SQL qui précède et déterminez le type de données et la valeur de chacune
des variables suivantes d'après les règles relatives à la portée.
a. La valeur de v_weight à la position 1 est :
b. La valeur de v_new_locn à la position 1 est :
c. La valeur de v_weight à la position 2 est :
d. La valeur de v_message à la position 2 est :
e. La valeur de v_new_locn à la position 2 est :

Exercice 3 (suite)
Exemple relatif à la portée
DECLARE
v_customer VARCHAR2(50) := 'Womansport';
v_credit_rating VARCHAR2(50) := 'EXCELLENT';
BEGIN
DECLARE
v_customer NUMBER(7) := 201;
v_name VARCHAR2(25) := 'Unisports';
BEGIN
v_credit_rating :='GOOD';
…
END;
…
END;

/
2. Dans le bloc PL/SQL qui précède, déterminez les valeurs et les types de données pour chacun
des cas suivants.
a. La valeur de v_customer dans le bloc imbriqué est :
b. La valeur de name dans le bloc imbriqué est :
c. La valeur de v_credit_rating dans le bloc imbriqué est :
d. La valeur de v_customer dans le bloc principal est :
e. La valeur de name dans le bloc principal est :
f. La valeur de v_credit_rating dans le bloc principal est :

Exercice 3 (suite)
3. Editez lab_02_05_soln.sql.
a. Mettez en commentaire les lignes de création des variables attachées (bind variables), en
utilisant la syntaxe de commentaire monoligne.
b. Dans la section exécutable, mettez en commentaire les lignes qui affectent des valeurs aux
variables attachées, en utilisant la syntaxe de commentaire multiligne.
c. Déclarez les variables v_basic_percent et v_pf_percent et initialisez-les à 45 et
12, respectivement. Déclarez également deux autres variables : v_fname de type
VARCHAR2 et de taille 15, et v_emp_sal de type NUMBER et de taille 10.
d. Incluez l'instruction SQL suivante dans la section exécutable :
SELECT first_name, salary
INTO v_fname, v_emp_sal FROM employees
WHERE employee_id=110;
e. Modifiez la ligne qui affiche "Hello World" afin d'afficher "Hello" et le prénom. Si vous le

souhaitez, vous pouvez mettre en commentaire les lignes qui affichent les dates et afficher
les variables attachées.
f. Calculez la contribution de l'employé au fonds de prévoyance (PF).
La contribution PF est de 12 % du salaire de base, ce dernier représentant 45 % du salaire.
Utilisez les variables attachées pour le calcul. Essayez d'utiliser une seule expression pour
calculer la contribution PF. Affichez le salaire de l'employé et sa contribution PF.
g. Exécutez votre script et enregistrez-le sous le nom lab_03_03_soln.sql. Un exemple
de sortie est affiché ci-après.


Interagir avec le serveur
de base de données Oracle

Objectifs

• déterminer les instructions SQL pouvant être incluses
directement dans un bloc exécutable PL/SQL
• manipuler des données à l'aide d'instructions LMD dans
du code PL/SQL
• utiliser des instructions de gestion des transactions dans
le code PL/SQL
• utiliser la clause INTO pour le stockage des valeurs

renvoyées par une instruction SQL
• distinguer les curseurs implicites des curseurs explicites
• utiliser des attributs de curseur SQL
But du chapitre
Dans ce chapitre, vous apprendrez à intégrer des instructions SQL standard SELECT,
INSERT, UPDATE, DELETE et MERGE dans des blocs PL/SQL. Vous apprendrez à inclure
des instructions LDD (Langage de définition de données) et des instructions de gestion des
transactions dans du code PL/SQL. Vous comprendrez la nécessité des curseurs et vous
pourrez distinguer les deux types de curseur. Enfin, vous étudierez les divers attributs de
curseur SQL pouvant être utilisés avec les curseurs implicites.

Instructions SQL en langage PL/SQL
• Extrayez une ligne de la base de données à l'aide de la

commande SELECT.
• Modifiez des lignes de la base de données en utilisant des
commandes LMD.
• Contrôlez une transaction avec la commande COMMIT,
ROLLBACK ou SAVEPOINT.

Instructions SQL en langage PL/SQL

Dans un bloc PL/SQL, vous utilisez des instructions SQL pour extraire et modifier des
données de la table de base de données. Le langage PL/SQL prend en charge les instructions
LMD ainsi que les commandes de gestion des transactions. Vous pouvez utiliser des
instructions LMD pour modifier les données contenues dans une table de base de données.
Cependant, gardez à l'esprit les remarques suivantes lorsque vous utilisez des instructions
LMD et des commandes de gestion des transactions dans des blocs PL/SQL :
• Le mot-clé END indique la fin d'un bloc PL/SQL, et non la fin d'une transaction. De
même qu'un bloc peut s'étendre sur plusieurs transactions, une transaction peut s'étendre
sur plusieurs blocs.
• Le langage PL/SQL ne prend pas directement en charge les instructions LDD (Langage
de définition de données), telles que CREATE TABLE, ALTER TABLE ou DROP TABLE.
PL/SQL prend en charge l'affectation de valeur (bind) précoce qui ne peut pas avoir lieu
si les applications doivent créer des objets de base de données lors de l'exécution via la
transmission de valeurs. Les instructions LDD ne peuvent pas être exécutées directement.
Ces instructions sont des instructions SQL dynamiques. Les instructions SQL
dynamiques sont créées sous forme de chaînes de caractères lors de l'exécution et
peuvent contenir des marques de réservation pour les paramètres. Vous pouvez donc les
utiliser pour exécuter des instructions LDD dans le code PL/SQL. Les détails de
l'utilisation d'instructions SQL dynamiques sont étudiés dans le cours Oracle Database
11g : Objets procéduraux basés d'Oracle.
• Le langage PL/SQL ne prend pas directement en charge les instructions LCD (Langage
de contrôle de données), telles que GRANT ou REVOKE. Vous pouvez utiliser des
instructions SQL dynamiques pour les exécuter.
Instructions SELECT en langage PL/SQL
Extrayez les données de la base à l'aide d'une instruction

SELECT.
Syntaxe :
SELECT select_list
INTO {variable_name[, variable_name]...
| record_name}
FROM table
[WHERE condition];


Utilisez l'instruction SELECT pour extraire des données de la base.
select_list Liste comprenant au moins une colonne. Peut inclure des expressions
SQL, des fonctions de ligne ou des fonctions de groupe.
variable_name Variable scalaire contenant la valeur extraite.
record_name Enregistrement PL/SQL contenant les valeurs extraites.
table Nom de la table de base de données.
condition Comprend des noms de colonne, des expressions, des constantes et des
opérateurs de comparaison, ainsi que des variables et des constantes
PL/SQL.
Règles relatives à l'extraction de données en langage PL/SQL

• Terminez chaque instruction SQL par un point-virgule (;).
• Chaque valeur extraite doit être stockée dans une variable à l'aide de la clause INTO.
• La clause WHERE est facultative et permet d'indiquer des variables d'entrée, des
constantes, des littéraux et des expressions PL/SQL. Cependant, lorsque vous utilisez
la clause INTO, vous devez extraire une seule ligne. L'utilisation de la clause WHERE est
alors obligatoire.

Instructions SELECT en langage PL/SQL (suite)
• Définissez autant de variables dans la clause INTO que de colonnes de base de données dans la
clause SELECT. Assurez-vous qu'elles correspondent de manière appropriée et que les types de
données sont compatibles.
• Utilisez les fonctions de groupe, telles que SUM, dans une instruction SQL. En effet, les
fonctions de groupe s'appliquent à des ensembles de lignes dans une table.

• La clause INTO est obligatoire.

• Les interrogations doivent renvoyer une seule ligne.
Exemple :
DECLARE
BEGIN
SELECT first_name INTO v_fname
FROM employees WHERE employee_id=200;

DBMS_OUTPUT.PUT_LINE(' First Name is : '||v_fname);
END;
/

Clause INTO
La clause INTO est obligatoire et apparaît entre les clauses SELECT et FROM. Elle permet
d'indiquer les noms des variables contenant les valeurs renvoyées par le compilateur SQL à
partir de la clause SELECT. Vous devez indiquer une variable pour chaque élément
sélectionné. En outre, l'ordre des variables doit correspondre à celui des éléments
sélectionnés.
Utilisez la clause INTO pour remplir les variables PL/SQL ou les variables hôte.
Les interrogations doivent renvoyer une seule ligne
Les instructions SELECT d'un bloc PL/SQL sont conformes à la norme ANSI du code SQL
intégré, selon laquelle les interrogations doivent renvoyer une seule ligne. Une interrogation
qui renvoie plusieurs lignes, ou qui n'en renvoie aucune, génère une erreur.
Le compilateur PL/SQL gère ces erreurs en générant des exceptions standard, que vous
pouvez traiter dans la section de traitement des exceptions du bloc, avec les exceptions
NO_DATA_FOUND et TOO_MANY_ROWS. Incluez une condition WHERE dans l'instruction
SQL, de sorte que l'instruction renvoie une seule ligne. Vous en apprendrez davantage sur le
traitement des exceptions plus loin dans ce cours.

Comment extraire plusieurs lignes d'une table et opérer sur les données
Une instruction SELECT avec la clause INTO peut extraire une seule ligne à la fois. Si vous
souhaitez extraire plusieurs lignes et opérer sur les données, vous pouvez utiliser des curseurs
explicites. Les curseurs seront présentés ultérieurement dans ce chapitre. Les curseurs explicites
seront détaillés dans le chapitre "Utiliser des curseurs explicites".

Extraire des données en langage PL/SQL
Extrayez hire_date et salary pour l'employé désigné.
Exemple :
DECLARE
v_emp_hiredate employees.hire_date%TYPE;
v_emp_salary employees.salary%TYPE;
BEGIN
SELECT hire_date, salary
INTO v_emp_hiredate, v_emp_salary

FROM employees
WHERE employee_id = 100;
END;
/

Dans l'exemple de la diapositive ci-dessus, les variables emp_hiredate et emp_salary
sont déclarées dans la section déclarative du bloc PL/SQL. Dans la section exécutable, les
valeurs des colonnes hire_date et salary de l'employé pour lequel employee_id est
égal à 100 sont extraites de la table employees. Ces valeurs sont ensuite stockées
respectivement dans les variables emp_hiredate et emp_salary. Notez la façon dont la
clause INTO et l'instruction SELECT permettent d'extraire les valeurs des colonnes de base
de données et de les stocker dans les variables PL/SQL.
Remarque : L'instruction SELECT extrait hire_date, puis salary. Les variables de la
clause INTO doivent donc se présenter dans le même ordre. Par exemple, si vous permutez
emp_hiredate et emp_salary dans l'instruction ci-dessus, celle-ci génère une erreur.

Renvoyez la somme des salaires de tous les employés du

département désigné.
Exemple :
DECLARE
v_sum_sal NUMBER(10,2);
v_deptno NUMBER NOT NULL := 60;
BEGIN
SELECT SUM(salary) -- group function

INTO v_sum_sal FROM employees
WHERE department_id = v_deptno;
DBMS_OUTPUT.PUT_LINE ('The sum of salary is ' || v_sum_sal);
END;
Extraire des données en langage PL/SQL (suite)

Dans l'exemple de la diapositive ci-dessus, les variables sum_sal et deptno sont déclarées
dans la section déclarative du bloc PL/SQL. Dans la section exécutable, le salaire total des
employés du département pour lequel department_id est égal à 60 est calculé à l'aide de
la fonction d'agrégation SQL SUM. Le salaire total calculé est affecté à la variable sum_sal.
Remarque : Les fonctions de groupe ne peuvent pas être utilisées dans la syntaxe PL/SQL.
Elles sont utilisées dans les instructions SQL d'un bloc PL/SQL, comme illustré dans
l'exemple de la diapositive ci-dessus. Vous ne pouvez pas les utiliser de la façon suivante :
sum_sal := SUM(employees.salary);
La sortie du bloc PL/SQL présenté dans la diapositive est la suivante :

Conventions d'appellation
DECLARE
hire_date employees.hire_date%TYPE;
sysdate hire_date%TYPE;
employee_id employees.employee_id%TYPE := 176;
BEGIN
SELECT hire_date, sysdate
INTO hire_date, sysdate
FROM employees
WHERE employee_id = employee_id;
END;
/

Dans les instructions SQL présentant un risque d'ambiguïté, les noms des colonnes de base de
données ont priorité sur les noms des variables locales.
L'exemple de la diapositive extrait de la table employees la date d'embauche et la date du
jour pour l'employé dont la valeur employee_id est égale à 176. Cet exemple déclenche
une exception d'exécution non gérée, car la clause WHERE contient des noms de variable
PL/SQL identiques aux noms des colonnes de base de données de la table employees.
L'instruction DELETE suivante supprime de la table employees tous les employés dont le
nom de famille n'est pas NULL (au lieu de supprimer uniquement ceux dont le nom est
"King"). En effet, le serveur Oracle suppose que les deux occurrences de last_name dans
la clause WHERE font référence à la colonne de base de données :
DECLARE
last_name VARCHAR2(25) := 'King';
BEGIN
DELETE FROM employees WHERE last_name = last_name;
. . .

• Utilisez une convention d'appellation pour éviter toute

ambiguïté dans la clause WHERE.
• Evitez d'utiliser des noms de colonne de base de données
comme identificateurs.
• Des erreurs de syntaxe peuvent survenir, car le compilateur
PL/SQL recherche en premier lieu une colonne de table
dans la base de données.
• Les noms des variables locales et les paramètres formels
ont priorité sur les noms des tables de la base de données.

• Les noms des colonnes des tables de la base de données
ont priorité sur les noms des variables locales.
Conventions d'appellation (suite)

Evitez toute ambiguïté dans la clause WHERE en optant pour une convention d'appellation qui
distingue les noms de colonne de base de données des noms de variable PL/SQL.
• Les colonnes de base de données et les identificateurs doivent porter des noms différents.
• Des erreurs de syntaxe peuvent survenir, car le compilateur PL/SQL recherche en
premier lieu une colonne de table dans la base de données.
Remarque : Il ne peut pas y avoir d'ambiguïté dans la clause SELECT, car tout identificateur
contenu dans cette clause doit correspondre à un nom de colonne de base de données. De
même, il ne peut pas y avoir d'ambiguïté dans la clause INTO, car ses identificateurs doivent
correspondre à des variables PL/SQL. La seule possibilité de confusion provient de la clause
WHERE.

Utiliser PL/SQL pour manipuler des données
Modifiez des tables de base de données en utilisant des

instructions LMD :
• INSERT
• UPDATE
DELETE
• DELETE
• MERGE

INSERT
MERGE
UPDATE
Utiliser PL/SQL pour manipuler des données

Pour manipuler les données d'une base, servez-vous des commandes LMD. Vous pouvez
exécuter sans limite les instructions LMD INSERT, UPDATE, DELETE et MERGE dans du
code PL/SQL. Pour libérer les verrous sur ligne (et les verrous sur table), ajoutez les
instructions COMMIT ou ROLLBACK au code PL/SQL.
• L'instruction INSERT ajoute de nouvelles lignes à la table.
• L'instruction UPDATE modifie des lignes existantes de la table.
• L'instruction DELETE supprime des lignes de la table.
• L'instruction MERGE sélectionne des lignes d'une table, pour les mettre à jour ou les
insérer dans une autre table. La mise à jour ou l'insertion de ces lignes dans la table cible
dépend d'une condition établie dans la clause ON.
Remarque : L'instruction MERGE est une instruction déterministe. En d'autres termes, vous
ne pouvez pas effectuer plusieurs mises à jour d'une ligne de la table cible à partir de la même
instruction MERGE. Vous devez disposer des privilèges objet INSERT et UPDATE dans la
table cible, ainsi que du privilège SELECT dans la table source.

Insérer des données
Ajoutez les informations relatives à un nouvel employé à la

table EMPLOYEES.
Exemple :
BEGIN
INSERT INTO employees
(employee_id, first_name, last_name, email,
hire_date, job_id, salary)
VALUES(employees_seq.NEXTVAL, 'Ruth', 'Cores',

'RCORES',CURRENT_DATE, 'AD_ASST', 4000);
END;
/
Insérer des données

Dans l'exemple de la diapositive ci-dessus, l'instruction INSERT utilisée dans un bloc
PL/SQL permet d'insérer un enregistrement dans la table employees. En utilisant la
commande INSERT dans un bloc PL/SQL, vous pouvez effectuer les opérations suivantes :
• Utiliser des fonctions SQL, par exemple USER et CURRENT_DATE.
• Générer des valeurs de clé primaire à partir de séquences gérées par la base de données.
• Dériver des valeurs dans le bloc PL/SQL.
Remarque : Les données de la table employees doivent rester inchangées. Même si la
table employees n'est pas en lecture seule, l'insertion, la mise à jour et la suppression ne
sont pas autorisées sur cette table afin de garantir la cohérence de la sortie.

Mettre à jour des données
Augmentez le salaire de tous les employés chargés du contrôle

des stocks.
Exemple :
DECLARE
sal_increase employees.salary%TYPE := 800;
BEGIN
UPDATE employees
SET salary = salary + sal_increase
WHERE job_id = 'ST_CLERK';

END;
/
Mettre à jour des données

Il peut y avoir une ambiguïté dans la clause SET de l'instruction UPDATE. En effet,
l'identificateur situé à gauche de l'opérateur d'affectation est toujours une colonne de base de
données, mais l'identificateur situé à droite peut correspondre à une colonne de base de
données ou à une variable PL/SQL. Souvenez-vous que si des noms de colonne et des noms
d'identificateur sont identiques dans la clause WHERE, le serveur Oracle recherche d'abord ces
noms dans la base de données.
Rappelons que la clause WHERE sert à déterminer les lignes qui seront affectées. Si aucune
ligne n'est modifiée, aucune erreur ne se produit (contrairement à ce qui se passe pour
l'instruction SELECT dans PL/SQL).
Remarque : Les affectations de variables PL/SQL utilisent toujours :=, et les affectations de
colonnes SQL utilisent toujours =.

Supprimer des données
Supprimez de la table employees les lignes appartenant au

département 10.
Exemple :
DECLARE
deptno employees.department_id%TYPE := 10;
BEGIN
DELETE FROM employees
WHERE department_id = deptno;
END;

/
Supprimer des données

L'instruction DELETE supprime les lignes indésirables d'une table. Si la clause WHERE n'est
pas utilisée, toutes les lignes d'une table peuvent être supprimées s'il n'y a pas de contrainte
d'intégrité.

Fusionner des lignes
Insérez ou mettez à jour des lignes dans la table copy_emp

afin qu'elles correspondent à celles de la table employees.
BEGIN
MERGE INTO copy_emp c
USING employees e
ON (e.employee_id = c.empno)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,
c.last_name = e.last_name,
c.email = e.email,

. . .
WHEN NOT MATCHED THEN
INSERT VALUES(e.employee_id, e.first_name, e.last_name,
. . .,e.department_id);
END;
/
Fusionner des lignes

L'instruction MERGE permet d'insérer ou de mettre à jour des lignes dans une table, en
utilisant les données d'une autre table. Chaque ligne est insérée ou mise à jour dans la table
cible, en fonction d'une condition d'équijointure.
L'exemple présenté compare la colonne employee_id de la table copy_emp à la colonne
employee_id de la table employees. Si une correspondance est trouvée, la ligne de la
table COPY_EMP est mise à jour par rapport à celle de la table employees. Si la ligne est
introuvable, elle est insérée dans la table copy_emp.
L'exemple complet relatif à l'utilisation de l'instruction MERGE dans un bloc PL/SQL est
présenté sur la page suivante.

Fusionner des lignes (suite)

BEGIN
MERGE INTO copy_emp c
USING employees e
ON (e.employee_id = c.empno)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,
c.last_name = e.last_name,
c.email = e.email,
c.phone_number = e.phone_number,
c.hire_date = e.hire_date,

c.job_id = e.job_id,
c.salary = e.salary,
c.commission_pct = e.commission_pct,
c.manager_id = e.manager_id,
c.department_id = e.department_id
WHEN NOT MATCHED THEN
INSERT VALUES(e.employee_id, e.first_name, e.last_name,
e.email, e.phone_number, e.hire_date, e.job_id,
e.salary, e.commission_pct, e.manager_id,
e.department_id);
END;
/

Curseur SQL
• Un curseur est un pointeur vers la zone de mémoire privée

allouée par le serveur Oracle.
• Un curseur est utilisé pour gérer le jeu de résultats d'une
instruction SELECT.
• Il existe deux types de curseur :
– Implicite : créé et géré en interne par le serveur Oracle afin
de traiter les instructions SQL
– Explicite : déclaré explicitement par le programmeur

Curseur SQL
Nous avons vu que vous pouvez inclure des instructions SQL qui renvoient une ligne unique
dans un bloc PL/SQL. Les données extraites par l'instruction SQL doivent être stockées dans
des variables à l'aide de la clause INTO.
Où le serveur Oracle traite-t-il les instructions SQL ?
Le serveur Oracle alloue une zone de mémoire privée appelée zone de contexte pour le
traitement des instructions SQL. L'instruction SQL est analysée (parse) et traitée dans cette
zone. Les informations requises pour le traitement et les informations extraites après le
traitement sont toutes stockées dans cette zone. Vous ne pouvez pas contrôler cette zone car
elle est gérée en interne par le serveur Oracle.
Un curseur est un pointeur vers la zone de contexte. Cependant, ce curseur est un curseur
implicite, géré automatiquement par le serveur Oracle. Lorsque le bloc exécutable traite une
instruction SQL, le compilateur PL/SQL crée un curseur implicite.
Types de curseur
Il existe deux types de curseur :
• Implicite : Un curseur implicite est créé et géré par le serveur Oracle. Vous n'y avez pas
accès. Le serveur Oracle crée un tel curseur lorsqu'il doit exécuter une instruction SQL.

Curseur SQL (suite)

Types de curseur (suite)
• Explicite : En tant que programmeur, vous pouvez extraire plusieurs lignes d'une table de base
de données, utiliser un pointeur vers chaque ligne extraite, ou encore opérer sur une ligne à la
fois. Dans ce cas, vous pouvez déclarer un curseur explicitement, en fonction de vos besoins
métier. Un curseur de ce type, déclaré par les programmeurs, est appelé curseur explicite. Vous
déclarez ce curseur dans la section déclarative d'un bloc PL/SQL.

Attributs de curseur SQL

pour les curseurs implicites
Grâce aux attributs de curseur SQL, vous pouvez tester le

résultat de l'exécution des instructions SQL.
SQL%FOUND Attribut booléen qui prend la valeur TRUE si la
dernière instruction SQL a renvoyé au moins une
ligne
SQL%NOTFOUND Attribut booléen qui prend la valeur TRUE si la
dernière instruction SQL n'a renvoyé aucune
ligne
SQL%ROWCOUNT Valeur entière qui représente le nombre de

lignes affectées par la dernière instruction SQL
Attributs de curseur SQL pour les curseurs implicites

Les attributs de curseur SQL vous permettent d'évaluer le déroulement de la dernière
utilisation d'un curseur implicite. Utilisez ces attributs dans les instructions PL/SQL, mais pas
dans les instructions SQL.
Vous pouvez tester les attributs SQL%ROWCOUNT, SQL%FOUND et SQL%NOTFOUND dans la
section exécutable d'un bloc afin de collecter des informations après l'exécution de la
commande LMD appropriée. Le compilateur PL/SQL ne renvoie pas d'erreur si une
instruction LMD n'affecte aucune ligne dans la table sous-jacente. En revanche, si une
instruction SELECT n'extrait aucune ligne, une exception est renvoyée.
Notez que les attributs comportent le préfixe SQL. Ces attributs de curseur sont utilisés avec
les curseurs implicites créés automatiquement par le compilateur PL/SQL et dont vous ne
connaissez pas les noms. Vous utilisez donc SQL à la place du nom du curseur.
L'attribut SQL%NOTFOUND est le contraire de SQL%FOUND. Il peut être utilisé comme
condition de fin dans une boucle. Il est utile dans les instructions UPDATE et DELETE
lorsqu'aucune ligne n'est modifiée, car aucune exception n'est renvoyée dans ce cas.
Vous en apprendrez davantage sur les attributs de curseur explicite plus loin dans ce cours.

Attributs de curseur SQL

pour les curseurs implicites
Supprimez de la table employees les lignes correspondant

à l'ID d'employé indiqué. Affichez le nombre de lignes
supprimées.
Exemple :
DECLARE
v_rows_deleted VARCHAR2(30)
v_empno employees.employee_id%TYPE := 176;
BEGIN

WHERE employee_id = v_empno;
v_rows_deleted := (SQL%ROWCOUNT ||
' row deleted.');
DBMS_OUTPUT.PUT_LINE (v_rows_deleted);
END;
Attributs de curseur SQL pour les curseurs implicites (suite)

L'exemple de la diapositive ci-dessus supprime de la table employees la ligne pour laquelle
employee_id a la valeur 176. Avec l'attribut SQL%ROWCOUNT, vous pouvez afficher le
nombre de lignes supprimées.

Synthèse

• intégrer des instructions LMD, des instructions de gestion
des transactions et des instructions LDD dans du code
PL/SQL
• utiliser la clause INTO, obligatoire pour toutes les
instructions SELECT en langage PL/SQL
• utiliser des attributs de curseur SQL pour déterminer le

résultat des instructions SQL
Synthèse
Les commandes LMD et les instructions de gestion des transactions peuvent être utilisées sans
restriction dans les programmes PL/SQL. En revanche, les commandes LDD ne peuvent pas
être utilisées directement.
Une instruction SELECT incluse dans un bloc PL/SQL ne peut renvoyer qu'une seule ligne.
L'utilisation de la clause INTO est obligatoire pour le stockage des valeurs extraites par
l'instruction SELECT.
Un curseur est un pointeur vers la zone de mémoire. Il existe deux types de curseur.
Les curseurs implicites sont créés et gérés en interne par le serveur Oracle pour l'exécution
des instructions SQL. Vous pouvez utiliser les attributs de curseur SQL avec ces curseurs afin
de déterminer le résultat de l'instruction SQL. Les curseurs explicites sont déclarés par les
programmeurs.


• Insérer des données dans une table
• Mettre à jour des données dans une table
• Supprimer un enregistrement d'une table


Exercice 4
1. Créez un bloc PL/SQL qui sélectionne l'ID de département le plus grand dans la table
departments et qui le stocke dans la variable v_max_deptno. Affichez l'ID de
département le plus élevé.
a. Déclarez une variable v_max_deptno de type NUMBER dans la section déclarative.
b. Commencez la section exécutable par le mot-clé BEGIN et incluez une instruction
SELECT afin d'extraire la valeur department_id maximale de la table
departments.
c. Affichez v_max_deptno et terminez le bloc exécutable.
d. Exécutez votre script et enregistrez-le sous le nom lab_04_01_soln.sql.
Un exemple de sortie est affiché ci-après.

2. Modifiez le bloc PL/SQL créé au cours de l'exercice 1 afin d'insérer un nouveau département
dans la table departments.
a. Chargez le script lab_04_01_soln.sql. Déclarez deux variables :
v_dept_name de type departments.department_name
v_dept_id de type NUMBER
Affectez la valeur "Education" à v_dept_name dans la section déclarative.
b. Vous avez déjà extrait l'ID de département maximal actuel à partir de la table
departments. Ajoutez 10 à ce numéro et affectez le résultat à v_dept_id.
c. Incluez une instruction INSERT pour insérer des données dans les colonnes
department_name, department_id et location_id de la table
departments.
Utilisez les valeurs de v_dept_name et v_dept_id pour department_name et
department_id et utilisez la valeur NULL pour location_id.
d. Utilisez l'attribut SQL SQL%ROWCOUNT pour afficher le nombre de lignes affectées.
e. Exécutez une instruction SELECT afin de déterminer si le nouveau département a été
inséré. Vous pouvez terminer le bloc PL/SQL par "/" et inclure l'instruction SELECT dans
le script.
f. Exécutez votre script et enregistrez-le sous le nom lab_04_02_soln.sql.

Exercice 4 (suite)
3. Dans le point 2, vous avez affecté la valeur NULL à location_id. Créez un bloc PL/SQL
qui met à jour location_id avec la valeur 3000 pour le nouveau département. Utilisez la
variable attachée dept_id pour mettre à jour la ligne.
Remarque : Ignorez l'étape (a) si vous n'avez pas démarré une nouvelle session pour cet
exercice.
a. Si vous avez démarré une nouvelle session, supprimez le département que vous avez ajouté
à la table departments et exécutez le script lab_04_02_soln.sql.
b. Commencez le bloc exécutable par le mot-clé BEGIN. Incluez l'instruction UPDATE afin
d'affecter la valeur 3000 à location_id pour le nouveau département (dept_id =
280).
c. Terminez le bloc exécutable par le mot-clé END. Terminez le bloc PL/SQL par "/" et
incluez une instruction SELECT afin d'afficher le département que vous avez mis à jour.

d. Enfin, incluez une instruction DELETE pour supprimer le département que vous avez
ajouté.
e. Exécutez votre script et enregistrez-le sous le nom lab_04_03_soln.sql.

DEPARTMENT_ID DEPARTMENT_NAME MANAGER_ID LOCATION_ID
------------- --------------- ----------- --------------
280 Education 3000
1 rows selected
1 rows deleted



Ecrire des structures de contrôle

Objectifs

• identifier les types de structure de contrôle et leurs
utilisations
• écrire une instruction IF
• utiliser des instructions CASE et des expressions CASE
• écrire et identifier différents types d'instruction de boucle
• appliquer les règles d'utilisation des structures de contrôle
conditionnel

But du chapitre
Vous avez appris à écrire des blocs PL/SQL contenant des sections déclaratives et
exécutables. Vous avez également appris à inclure des expressions et des instructions SQL
dans le bloc exécutable.
Dans le présent chapitre, vous apprendrez à utiliser les structures de contrôle telles que
les instructions IF, les expressions CASE et les structures LOOP dans un bloc PL/SQL.

Contrôler le flux d'exécution
for
loop

while
Contrôler le flux d'exécution

Vous pouvez modifier le flux logique des instructions dans un bloc PL/SQL grâce à un certain
nombre de structures de contrôle. Ce chapitre traite de quatre types de structure de contrôle
PL/SQL : les structures conditionnelles avec l'instruction IF, les expressions CASE, les
structures de contrôle LOOP et l'instruction CONTINUE.

Instruction IF
Syntaxe :
IF condition THEN
statements;
[ELSIF condition THEN
statements;]
[ELSE
statements;]
END IF;

Instruction IF
La structure de l'instruction IF en langage PL/SQL est semblable à celle des instructions IF
utilisées dans les autres langages procéduraux. Elle permet au langage PL/SQL d'exécuter des
actions dépendant de conditions spécifiques.
Dans la syntaxe :
condition Variable ou expression booléenne (renvoie TRUE, FALSE ou
NULL)
THEN Introduit une clause qui associe l'expression booléenne à la
séquence d'instructions qui suit.
statements Une ou plusieurs instructions PL/SQL ou SQL. Ces dernières
peuvent inclure d'autres instructions IF comprenant elles-mêmes
plusieurs instructions IF, ELSE et ELSIF imbriquées. Les
instructions de la clause THEN ne sont exécutées que si la
condition de la clause IF associée prend la valeur TRUE.

Instruction IF (suite)
Dans la syntaxe :
ELSIF Est un mot-clé qui introduit une expression booléenne (si la première
condition donne FALSE ou NULL, le mot-clé ELSIF introduit des
conditions supplémentaires).
ELSE Introduit la clause par défaut, qui est exécutée si et seulement si aucun
des prédicats précédents (introduits par IF et ELSIF) n'a la valeur
TRUE. Les tests sont exécutés dans l'ordre. Ainsi, un prédicat pouvant
être vrai n'est pas pris en compte si un prédicat antérieur est vrai.
END IF Marque la fin d'une instruction IF.
Remarque : Les clauses ELSIF et ELSE sont facultatives dans une instruction IF. Vous pouvez

inclure un nombre quelconque de mots-clés ELSIF dans l'instruction IF, mais un seul mot-clé
ELSE. END IF marque la fin d'une instruction IF et doit se terminer par un point-virgule.

Instructions IF simples
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11
THEN
DBMS_OUTPUT.PUT_LINE(' I am a child ');
END IF;
END;
/

Sortie :
Instructions IF simples
La diapositive ci-dessus illustre un exemple d'instruction IF simple avec la clause THEN.
La variable v_myage est initialisée avec la valeur 31. La condition de l'instruction IF
renvoie FALSE, car v_myage n'est pas inférieur à 11. Par conséquent, le contrôle n'atteint
jamais la clause THEN. Nous allons ajouter du code à cet exemple afin d'étudier l'utilisation
des clauses ELSE et ELSIF.
Une instruction IF peut comporter plusieurs expressions conditionnelles liées à l'aide
d'opérateurs logiques tels que AND, OR et NOT. Voici un exemple :
IF (myfirstname='Christopher' AND v_myage <11)
…
La condition utilise l'opérateur AND et prend donc la valeur TRUE uniquement si les deux
conditions ont la valeur TRUE. Le nombre des expressions conditionnelles n'est pas limité.
Toutefois, celles-ci doivent être liées à l'aide d'opérateurs logiques appropriés.

Instruction IF THEN ELSE
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11
THEN
ELSE
DBMS_OUTPUT.PUT_LINE(' I am not a child ');
END IF;
END;
/

Sortie :
Instruction IF THEN ELSE

Une clause ELSE a été ajoutée au code de la diapositive précédente. La condition n'a pas
changé et prend donc toujours la valeur FALSE. Rappelez-vous que les instructions de la
clause THEN ne sont exécutées que si la condition renvoie TRUE. Dans l'exemple, la
condition renvoie FALSE et le contrôle passe à l'instruction ELSE. La sortie du bloc est
présentée dans la diapositive.

Clause IF ELSIF ELSE
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11 THEN
ELSIF v_myage < 20 THEN
DBMS_OUTPUT.PUT_LINE(' I am young ');
DBMS_OUTPUT.PUT_LINE(' I am in my twenties');
DBMS_OUTPUT.PUT_LINE(' I am in my thirties');
ELSE
DBMS_OUTPUT.PUT_LINE(' I am always young ');
END IF;

END;
/
Sortie :
Clause IF ELSIF ELSE

La clause IF contient à présent plusieurs clauses ELSIF et une clause ELSE. Remarquez que
les clauses ELSIF peuvent utiliser des conditions, contrairement à la clause ELSE. La
condition de ELSIF doit être suivie de la clause THEN, laquelle est exécutée si la condition
de la clause ELSIF renvoie TRUE.
En présence de plusieurs clauses ELSIF, si la première condition est FALSE ou NULL, le
contrôle passe à la clause ELSIF suivante. Les conditions sont évaluées une par une, à partir
du haut.
Si toutes les conditions renvoient FALSE ou NULL, les instructions de la clause ELSE sont
exécutées. La clause ELSE finale est facultative.

Valeur NULL dans une instruction IF
DECLARE
v_myage number;
BEGIN
IF v_myage < 11 THEN
ELSE
DBMS_OUTPUT.PUT_LINE(' I am not a child ');
END IF;
END;

/
Valeur NULL dans une instruction IF

Dans l'exemple de la diapositive ci-dessus, la variable v_myage est déclarée, mais pas
initialisée. La condition de l'instruction IF renvoie NULL, et non TRUE ou FALSE. Dans ce
cas, le contrôle passe à l'instruction ELSE.
Règles
• Vous pouvez exécuter des actions qui dépendent de conditions vérifiées.
• Lors de l'écriture du code, respectez l'orthographe des mots-clés :
– ELSIF s'écrit en un seul mot.
– END IF s'écrit en deux mots.
• Si la condition booléenne de contrôle renvoie TRUE, la séquence d'instructions associée
est exécutée. Si elle renvoie FALSE ou NULL, la séquence d'instructions associée est
ignorée. Vous pouvez utiliser autant de clauses ELSIF que vous le souhaitez.
• L'indentation des instructions conditionnelles permet de faire apparaître clairement la
structure du raisonnement.

Expressions CASE
• Une expression CASE sélectionne un résultat et le renvoie.

• Pour sélectionner le résultat, l'expression CASE utilise des
expressions. La valeur renvoyée par ces expressions est
utilisée pour sélectionner une ou plusieurs alternatives.
CASE selector
WHEN expression1 THEN result1
WHEN expression2 THEN result2
...
WHEN expressionN THEN resultN

[ELSE resultN+1]
END;
/
Expressions CASE
Une expression CASE renvoie un résultat basé sur une ou plusieurs alternatives. Pour cela,
elle utilise un sélecteur, c'est-à-dire une expression admettant plusieurs valeurs qui permettent
de choisir entre différentes alternatives. Le sélecteur est suivi d'une ou plusieurs clauses
WHEN, qui sont vérifiées de façon séquentielle. La valeur du sélecteur détermine le résultat
renvoyé. Si cette valeur est égale à celle d'une expression comportant une clause WHEN, cette
dernière est exécutée et le résultat est renvoyé.
Le langage PL/SQL fournit également une expression de recherche pour la clause CASE, qui
se présente sous la forme suivante :
CASE
WHEN search_condition1 THEN result1
WHEN search_condition2 THEN result2
...
WHEN search_conditionN THEN resultN
[ELSE resultN+1]
END;
Une expression de recherche pour la clause CASE n'a pas de sélecteur. En outre, ses clauses
WHEN contiennent des conditions de recherche renvoyant une valeur booléenne plutôt que des
expressions pouvant renvoyer une valeur de n'importe quel type.

Expressions CASE : Exemple
SET VERIFY OFF

DECLARE
v_grade CHAR(1) := UPPER('&grade');
appraisal VARCHAR2(20);
BEGIN
appraisal := CASE v_grade
WHEN 'A' THEN 'Excellent'
WHEN 'B' THEN 'Very Good'
WHEN 'C' THEN 'Good'
ELSE 'No such grade'
END;

DBMS_OUTPUT.PUT_LINE ('Grade: '|| v_grade || '
Appraisal ' || appraisal);
END;
/
Expressions CASE : Exemple

Dans l'exemple de la diapositive ci-dessus, l'expression CASE utilise la valeur de la variable
v_grade en tant qu'expression. Cette valeur est saisie par l'utilisateur via une variable de
substitution. En fonction de la valeur entrée par l'utilisateur, l'expression CASE renvoie la
valeur de la variable appraisal selon la valeur de v_grade. Le résultat de l'exemple
ci-dessus est le suivant lorsque vous entrez a ou A pour v_grade :

Expressions de recherche pour la clause CASE
DECLARE
v_grade CHAR(1) := UPPER('&grade');
appraisal VARCHAR2(20);
BEGIN
appraisal := CASE
WHEN v_grade = 'A' THEN 'Excellent'
WHEN v_grade IN ('B','C') THEN 'Good'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE ('Grade: '|| v_grade || '

Appraisal ' || appraisal);
END;
/
Expressions de recherche pour la clause CASE

L'exemple précédent comprenait une expression de test unique qui était la variable v_grade.
La clause WHEN comparait une valeur à cette expression de test.
Les instructions de recherche d'une clause CASE ne comportent pas d'expression de test. En
revanche, la clause WHEN contient une expression qui renvoie une valeur booléenne. Le même
exemple est réécrit dans la diapositive ci-dessus afin d'illustrer les instructions de recherche
pour la clause CASE.

Instruction CASE
DECLARE
v_deptid NUMBER;
v_deptname VARCHAR2(20);
v_emps NUMBER;
v_mngid NUMBER:= 108;
BEGIN
CASE v_mngid
WHEN 108 THEN
SELECT department_id, department_name
INTO v_deptid, v_deptname FROM departments
WHERE manager_id=108;
SELECT count(*) INTO v_emps FROM employees
WHERE department_id=v_deptid;
WHEN 200 THEN

...
END CASE;
DBMS_OUTPUT.PUT_LINE ('You are working in the '|| deptname||
' department. There are '||v_emps ||' employees in this
department');
END;
/
Instruction CASE
Rappelez-vous l'utilisation de l'instruction IF. Vous pouvez inclure n instructions PL/SQL
dans la clause THEN et dans la clause ELSE. De la même façon, vous pouvez inclure des
instructions dans une instruction CASE. Une instruction CASE est plus facile à lire que
plusieurs instructions IF et ELSIF.
En quoi une expression CASE diffère-t-elle d'une instruction CASE ?
Une expression CASE évalue une condition et renvoie une valeur, alors qu'une instruction
CASE évalue une condition et effectue une action. Une instruction CASE peut être un bloc
PL/SQL complet.
• Les instructions CASE se terminent par END CASE ;
• Les expressions CASE se terminent par END ;

Traiter les valeurs NULL
Lorsque vous utilisez des valeurs NULL, vous pouvez éviter

certaines erreurs fréquentes en gardant à l'esprit les règles
suivantes :
• Les comparaisons simples impliquant des valeurs NULL
renvoient toujours une valeur NULL.
• L'application de l'opérateur logique NOT à une valeur NULL
renvoie une valeur NULL.
• Si la condition renvoie une valeur NULL dans les instructions
de contrôle conditionnelles, la séquence d'instructions

associée n'est pas exécutée.
Traiter les valeurs NULL

Examinons l'exemple suivant :
x := 5;
y := NULL;
...
IF x != y THEN -- yields NULL, not TRUE
-- sequence_of_statements that are not executed
END IF;
Vous pouvez vous attendre à l'exécution de la séquence d'instructions, car x et y semblent
différents. Cependant, les valeurs NULL sont indéterminées. Il n'est donc pas possible de
savoir si x est ou non égal à y. Par conséquent, la condition IF renvoie une valeur NULL
et la séquence d'instructions est ignorée.
a := NULL;
b := NULL;
...
IF a = b THEN -- yields NULL, not TRUE
-- sequence_of_statements that are not executed
END IF;
Dans le deuxième exemple, vous pourriez escompter l'exécution de la séquence d'instructions,
car a et b semblent posséder la même valeur. Mais là encore, vous ignorez si c'est vraiment le
cas. La condition IF renvoie donc une valeur NULL et la séquence d'instructions est ignorée.

Tables logiques
Créez une condition booléenne simple avec un opérateur de

comparaison.
AND TRUE FALSE NULL OR TRUE FALSE NULL NOT
TRUE TRUE FALSE NULL TRUE TRUE TRUE TRUE TRUE FALSE
FALSE FALSE FALSE FALSE FALSE TRUE FALSE NULL FALSE TRUE

NULL NULL FALSE NULL NULL TRUE NULL NULL NULL NULL
Tables logiques
Vous pouvez créer une condition booléenne simple en combinant des expressions de type
numérique, caractère et date à des opérateurs de comparaison.
Vous pouvez créer une condition booléenne complexe en combinant des conditions
booléennes simples avec les opérateurs logiques AND, OR et NOT. Les opérateurs logiques
sont utilisés pour vérifier les valeurs des variables booléennes et pour renvoyer TRUE, FALSE
ou NULL. Dans les tables logiques de la diapositive ci-dessus :
• FALSE est prioritaire dans une condition AND, tandis que TRUE est prioritaire dans une
condition OR.
• AND renvoie TRUE uniquement si ses deux opérandes sont TRUE.
• OR renvoie FALSE uniquement si ses deux opérandes sont FALSE.
• NULL et TRUE renvoient toujours NULL, car on ignore si la valeur du deuxième
opérande est TRUE.
Remarque : La négation de NULL (NOT NULL) renvoie une valeur NULL, car les valeurs
NULL sont indéterminées.

Conditions booléennes
Quelle est la valeur de flag dans chaque cas ?
flag := reorder_flag AND available_flag;
REORDER_FLAG AVAILABLE_FLAG FLAG
TRUE TRUE ? (1)
TRUE FALSE ? (2)
NULL TRUE ? (3)

NULL FALSE ? (4)
Conditions booléennes
Vous pouvez utiliser la table logique AND pour évaluer les différents résultats possibles de
la condition booléenne de la diapositive.
Réponses
1. TRUE
2. FALSE
3. NULL
4. FALSE

Contrôle d'itération : Instructions LOOP
• Les boucles permettent d'exécuter plusieurs fois une

instruction (ou une séquence d'instructions).
• Il existe trois types de boucle :
– Boucle de base
– Boucle FOR
– Boucle WHILE

Contrôle d'itération : Instructions LOOP

Le langage PL/SQL offre plusieurs solutions pour programmer des boucles en vue de répéter
plusieurs fois une instruction ou une séquence d'instructions. Les boucles sont essentiellement
utilisées pour exécuter des instructions de manière répétée, jusqu'à ce qu'une condition de
sortie soit vérifiée. La présence d'une condition de sortie est obligatoire dans une boucle.
Sinon, la boucle est infinie.
Les structures en boucle sont le deuxième type de structure de contrôle. Le langage PL/SQL
fournit les types de boucle suivants :
• Boucles de base, qui permettent de répéter des actions sans conditions globales.
• Boucles FOR, qui permettent d'effectuer un contrôle d'itération des actions, à l'aide d'un
compteur.
• Boucles WHILE, qui permettent d'effectuer un contrôle d'itération des actions, à l'aide
d'une condition.
Remarque : Une instruction EXIT peut être utilisée pour mettre fin à des boucles. Une
boucle de base doit comporter une instruction EXIT. La boucle FOR de curseur (qui est un
autre type de FOR Loop) est étudiée dans le chapitre intitulé "Utiliser des curseurs
explicites".

Boucles de base
Syntaxe :
LOOP
statement1;
. . .
EXIT [WHEN condition];
END LOOP;

Boucles de base
La forme de boucle la plus simple est la boucle LOOP de base, qui contient une séquence
d'instructions entre les mots-clés LOOP et END LOOP. Dès que l'exécution du code atteint
le mot-clé END LOOP, le programme reprend le contrôle à partir de l'instruction LOOP
correspondante. Une boucle de base exécute au moins une fois les instructions qui lui sont
associées, même si la condition EXIT est remplie avant l'entrée dans la boucle. En l'absence
d'instruction EXIT, la boucle est infinie.
Instruction EXIT
Vous pouvez mettre fin à une boucle en utilisant l'instruction EXIT. L'exécution reprend alors
à l'instruction qui suit END LOOP. Vous pouvez utiliser EXIT en tant qu'action dans une
instruction IF ou en tant qu'instruction autonome dans la boucle. L'instruction EXIT doit être
placée à l'intérieur de la boucle. Dans ce dernier cas, vous pouvez ajouter une clause WHEN
pour permettre une sortie conditionnelle de la boucle. Lorsque l'instruction EXIT est
rencontrée, la condition de la clause WHEN est évaluée. Si la condition renvoie TRUE, la
boucle se termine et l'exécution du programme reprend à la première instruction qui suit END
LOOP. Une boucle de base peut contenir plusieurs instructions EXIT, mais il est recommandé
d'utiliser un seul point EXIT.

Boucles de base
Exemple :
DECLARE
v_countryid locations.country_id%TYPE := 'CA';
v_loc_id locations.location_id%TYPE;
v_counter NUMBER(2) := 1;
v_new_city locations.city%TYPE := 'Montreal';
BEGIN
SELECT MAX(location_id) INTO v_loc_id FROM locations
WHERE country_id = v_countryid;
LOOP

INSERT INTO locations(location_id, city, country_id)
VALUES((v_loc_id + v_counter), v_new_city, v_countryid);
v_counter := v_counter + 1;
EXIT WHEN v_counter > 3;
END LOOP;
END;
/
Boucles de base (suite)

L'exemple de boucle de base présenté dans la diapositive ci-dessus est défini comme suit :
Insérer trois nouveaux ID d'emplacement pour le code de pays CA et la ville de
Montréal.
Remarque : Une boucle de base autorise l'exécution de son instruction jusqu'à ce que la
condition EXIT WHEN soit remplie. Si la condition est placée dans la boucle, afin qu'elle ne
soit évaluée qu'après les instructions de boucle, la boucle s'exécute au moins une fois. En
revanche, si la condition de sortie est placée au début de la boucle (avant toute autre
instruction exécutable) et qu'elle est remplie, la boucle prend fin avant que les instructions ne
soient exécutées.

Boucles WHILE
Syntaxe :
WHILE condition LOOP
statement1;
statement2;
. . .
END LOOP;
Utilisez la boucle WHILE pour répéter des instructions tant

qu'une condition renvoie TRUE.

Boucles WHILE
Vous pouvez utiliser une boucle WHILE pour répéter une séquence d'instructions jusqu'à ce
que la condition de contrôle ne soit plus TRUE. La condition est évaluée au début de chaque
itération. La boucle se termine lorsque la condition renvoie FALSE ou NULL. Si la condition
est FALSE ou NULL dès le début de la boucle, aucune itération n'est effectuée. Il est donc
possible qu'aucune instruction de la boucle ne soit exécutée.
Dans la syntaxe :
condition Variable ou expression booléenne (TRUE, FALSE ou NULL).
statement Une ou plusieurs instructions PL/SQL ou SQL.
Si les variables impliquées dans les conditions ne changent pas au cours de la boucle, la
condition est toujours vérifiée (TRUE) et la boucle ne s'arrête jamais.
Remarque : Si la condition renvoie la valeur NULL, la boucle est ignorée et l'exécution du
programme reprend à l'instruction qui suit la fin de la boucle.

Boucles WHILE
Exemple
DECLARE
v_counter NUMBER := 1;
BEGIN
SELECT MAX(location_id) INTO v_loc_id FROM locations
WHILE v_counter <= 3 LOOP

VALUES((v_loc_id + v_counter), v_new_city, v_countryid);
v_counter := v_counter + 1;
END LOOP;
END;
/
Boucles WHILE (suite)

Dans l'exemple de la diapositive, trois nouveaux ID d'emplacement sont ajoutés pour le code
de pays CA et la ville Montreal.
Un compteur (v_counter) est incrémenté à chaque itération de la boucle WHILE. Si le
nombre d'itérations est inférieur ou égal à 3, le code situé dans la boucle est exécuté et une
ligne est ajoutée à la table locations. Dès que le compteur v_counter dépasse le
nombre de nouveaux emplacements pour cette ville et ce pays, la condition régissant la boucle
n'est plus vérifiée (FALSE) et celle-ci se termine.

Boucles FOR
• Utilisez une boucle FOR pour simplifier le contrôle du

nombre d'itérations.
• Ne déclarez pas le compteur (sa déclaration est implicite).
FOR counter IN [REVERSE]
lower_bound..upper_bound LOOP
statement1;
statement2;
. . .
END LOOP;

Boucles FOR
Les boucles FOR ont la même structure globale que les boucles de base. En outre, elles
possèdent une instruction de contrôle précédant le mot-clé LOOP, qui détermine le nombre
d'itérations à effectuer par le compilateur PL/SQL.
Dans la syntaxe :
counter Entier déclaré implicitement, dont la valeur décroît ou augmente
automatiquement de 1 à chaque itération de la boucle jusqu'à ce que
la limite supérieure ou inférieure soit atteinte (elle décroît si le mot-clé
REVERSE est utilisé).
REVERSE Le compteur est décrémenté lors de chaque itération, de la limite
supérieure à la limite inférieure.
Remarque : La limite inférieure est toujours référencée en premier.
lower_bound Indique la limite inférieure de la plage des valeurs du compteur.
upper_bound Indique la limite supérieure de la plage des valeurs du compteur.
Ne déclarez pas le compteur. Il est déclaré implicitement en tant qu'entier.

Boucles FOR (suite)
Remarque : La séquence d'instructions est exécutée à chaque fois que le compteur est incrémenté,
en fonction des limites inférieure et supérieure de celui-ci. Ces limites peuvent être des littéraux, des
variables ou des expressions. Cependant, elles doivent correspondre à des entiers. Les limites sont
arrondies à des entiers, ce qui signifie que 11/3 et 8/5 sont des limites supérieure et inférieure valides.
Les limites sont incluses dans la plage des valeurs de la boucle. Si la limite inférieure prend une
valeur entière supérieure à la limite supérieure, la séquence d'instructions n'est pas exécutée.
Par exemple, l'instruction suivante ne s'exécute qu'une seule fois :
FOR i IN 3..3
LOOP
statement1;
END LOOP;

Boucles FOR
Exemple :
DECLARE
BEGIN
SELECT MAX(location_id) INTO v_loc_id
FROM locations
FOR i IN 1..3 LOOP

VALUES((v_loc_id + i), v_new_city, v_countryid );
END LOOP;
END;
/
Boucles FOR (suite)

Nous avons vu comment insérer trois nouveaux emplacements pour le code de pays CA et la
ville Montreal à l'aide de la boucle de base et de la boucle WHILE. La diapositive ci-dessus
montre comment obtenir le même résultat avec la boucle FOR.

Boucles FOR
Règles
• Ne référencez le compteur qu'à l'intérieur de la boucle.
Il n'est pas défini en dehors.
• Ne référencez pas le compteur en tant que cible d'une
affectation.
• Aucune limite de boucle ne doit être NULL.

Boucles FOR (suite)

La diapositive présente les règles à respecter lors de l'écriture d'une boucle FOR.
Remarque : Les limites supérieure et inférieure d'une instruction LOOP ne doivent pas
nécessairement être des littéraux numériques. Elles peuvent être des expressions qui seront
converties en valeurs numériques.
Exemple :
DECLARE
v_lower NUMBER := 1;
v_upper NUMBER := 100;
BEGIN
FOR i IN v_lower..v_upper LOOP
...
END LOOP;
END;
/

Règles relatives aux boucles
• Utilisez une boucle de base si les instructions doivent

s'exécuter au moins une fois.
• Utilisez une boucle WHILE si la condition doit être évaluée
au début de chaque itération.
• Utilisez une boucle FOR si le nombre d'itérations est connu.

Règles relatives aux boucles

Une boucle de base exécute au moins une fois les instructions qui lui sont associées, même si
la condition de sortie est remplie avant l'entrée dans la boucle. En l'absence d'instruction
EXIT, la boucle est infinie.
Vous pouvez utiliser une boucle WHILE pour répéter une séquence d'instructions jusqu'à ce
que la condition de contrôle ne renvoie plus TRUE. La condition est évaluée au début de
chaque itération. La boucle se termine lorsque la condition n'est plus remplie (FALSE).
Si la condition renvoie FALSE dès le début de la boucle, aucune itération n'est effectuée.
Les boucles FOR comportent une instruction de contrôle avant le mot-clé LOOP, qui
détermine le nombre d'itérations effectuées par le compilateur PL/SQL. Utilisez une boucle
FOR si le nombre d'itérations est prédéfini.

Boucles imbriquées et étiquettes
• Vous pouvez imbriquer des boucles à plusieurs niveaux.

• Utilisez des étiquettes pour différencier les blocs des
boucles.
• Quittez la boucle externe en utilisant l'instruction EXIT qui
référence l'étiquette.


Les boucles FOR, WHILE et les boucles de base peuvent être imbriquées les unes dans les
autres. La fin d'une boucle imbriquée ne signifie pas la fin de celle qui l'englobe, sauf si une
exception est déclenchée. Cependant, l'instruction EXIT permet de quitter la boucle externe
en faisant référence à son étiquette.
Les noms des étiquettes suivent les mêmes règles que les autres identificateurs. L'étiquette est
placée avant l'instruction, soit sur la même ligne, soit sur une ligne distincte. Les espaces sont
ignorés lors de l'analyse (parse) par le compilateur PL/SQL, sauf à l'intérieur de littéraux.
Nommez les boucles de base en plaçant les étiquettes entre leurs délimiteurs (<<étiquette>>)
et avant le mot-clé LOOP. Dans les boucles FOR et WHILE, placez l'étiquette avant FOR ou
WHILE.
L'étiquette d'une boucle peut (éventuellement) être insérée après le mot-clé END LOOP pour
plus de clarté.

...
BEGIN
<<Outer_loop>>
LOOP
v_counter := v_counter+1;
EXIT WHEN v_counter>10;
<<Inner_loop>>
LOOP
...
EXIT Outer_loop WHEN total_done = 'YES';
-- Leave both loops
EXIT WHEN inner_done = 'YES';

-- Leave inner loop only
...
END LOOP Inner_loop;
...
END LOOP Outer_loop;
END;
/
Boucles imbriquées et étiquettes (suite)

L'exemple de la diapositive ci-dessus comporte deux boucles. La boucle externe est identifiée
par l'étiquette <<Outer_Loop>>, tandis que la boucle interne est identifiée par l'étiquette
<<Inner_Loop>>.
Les identificateurs sont placés avant le mot-clé LOOP entre les délimiteurs d'étiquette
(<<étiquette>>). La boucle interne est imbriquée dans la boucle externe. Les noms des
étiquettes sont inclus après les instructions END LOOP pour plus de clarté.

Instruction PL/SQL CONTINUE
• Définition
– Ajoute la fonctionnalité consistant à commencer l'itération de
boucle suivante
– Permet aux programmeurs de transférer le contrôle à
l'itération suivante d'une boucle
– Utilise une structure et une sémantique parallèles à celles de
l'instruction EXIT
• Avantages
– Facilite le processus de programmation

– Peut entraîner une légère amélioration des performances par
rapport aux solutions de contournement précédentes simulant
l'instruction CONTINUE
Instruction PL/SQL CONTINUE

L'instruction CONTINUE, dans une boucle, permet de transférer le contrôle à une nouvelle
itération ou de quitter la boucle. Cette fonctionnalité est disponible dans de nombreux
langages de programmation. Dans Oracle Database 11g, elle est fournie par PL/SQL. Avant
cette version, vous pouviez la simuler en codant une solution de contournement à l'aide de
variables booléennes et d'instructions conditionnelles. Dans certains cas, les solutions de
contournement sont moins efficaces.
L'instruction CONTINUE simplifie le contrôle des itérations de boucle. Elle peut être plus
performante que les solutions de contournement précédentes.
L'instruction CONTINUE est généralement utilisée pour filtrer des données dans le corps
d'une boucle avant le début du traitement principal.

Instruction PL/SQL CONTINUE : Exemple

DECLARE
Total is: 1
v_total SIMPLE_INTEGER := 0;
Out of Loop Total is: 2
BEGIN
Total is: 4
FOR i IN 1..10 LOOP
1 v_total := v_total + i; Total is: 9
dbms_output.put_line
('Total is: '|| v_total);
Total is: 16
CONTINUE WHEN i > 5;
v_total := v_total + i;
Total is: 25
2 dbms_output.put_line Out of Loop Total is: 30
('Out of Loop Total is:
Total is: 36
'|| v_total);
Total is: 43
END LOOP;
Total is: 51
END;

Total is: 60
/
Total is: 70

La première affectation TOTAL est exécutée pour chacune des 10 itérations de la boucle.
La seconde affectation TOTAL est exécutée pour les cinq premières itérations de la boucle.
L'instruction CONTINUE transfère le contrôle à une nouvelle itération. Ainsi, pour les cinq
dernières itérations de la boucle, la seconde affectation TOTAL n'est pas exécutée.
Le résultat final de la variable TOTAL est 70.

DECLARE anonymous block completed

v_total NUMBER := 0; Total is: 1
BEGIN Total is: 6
<<BeforeTopLoop>> Total is: 10
FOR i IN 1..10 LOOP Total is: 13
v_total := v_total + 1; Total is: 15
dbms_output.put_line Total is: 16
('Total is: ' || v_total); Total is: 17
FOR j IN 1..10 LOOP Total is: 18
CONTINUE BeforeTopLoop WHEN i + j > 5; Total is: 19
v_total := v_total + 1; Total is: 20
END LOOP;
END LOOP;
END two_loop;

Instruction PL/SQL CONTINUE : Exemple (suite)

Vous pouvez utiliser l'instruction CONTINUE pour passer à l'itération suivante d'une boucle
externe. Attribuez à cette boucle un libellé afin d'identifier l'emplacement cible de
l'instruction CONTINUE.
L'instruction CONTINUE de la première boucle interne termine cette boucle dès que la
condition WHEN est remplie (tout comme le mot-clé EXIT). Le contrôle est alors transféré à
l'itération suivante de la dernière boucle externe, appelée BeforeTopLoop dans l'exemple.
Lorsque les deux boucles sont terminées, la valeur de la variable TOTAL est 20.
Vous pouvez également utiliser l'instruction CONTINUE dans un bloc interne de code qui ne
contient pas de boucle à condition que ce bloc soit imbriqué dans une boucle externe
appropriée.
Restrictions
• L'instruction CONTINUE ne peut jamais apparaître hors d'une boucle (cela génère une
erreur de compilation).
• Vous ne pouvez pas utiliser l'instruction CONTINUE pour passer outre une limite de
procédure, de fonction ou de méthode (cela génère une erreur de compilation).

Synthèse
Dans ce chapitre, vous avez appris à modifier le flux logique

des instructions en utilisant les structures de contrôle
suivantes :
• Instructions conditionnelles (IF)
• Expressions CASE et instructions CASE
• Boucles :
– Boucle de base
– Boucle FOR
– Boucle WHILE

• Instruction EXIT
• Instruction CONTINUE
Synthèse
Un langage n'est considéré comme un langage de programmation que s'il offre des structures
de contrôle pour l'implémentation de la logique métier. Ces structures de contrôle sont
également utilisées pour contrôler le flux du programme. Le langage PL/SQL est un langage
de programmation qui complète le langage SQL avec des structures de programmation.
Une structure de contrôle conditionnel permet de vérifier la validité d'une condition et exécute
une action en conséquence. La structure IF permet une exécution conditionnelle des
instructions.
Une structure de contrôle d'itération exécute une séquence d'instructions de façon répétitive,
tant que la condition indiquée est vérifiée (TRUE). Vous pouvez utiliser les différentes
structures de boucle pour exécuter des opérations itératives.


• Exécuter des actions conditionnelles en utilisant des
instructions IF
• Exécuter des instructions itératives en utilisant des
structures LOOP

Dans cet exercice, vous allez créer des blocs PL/SQL comportant des boucles et des structures
de contrôle conditionnelles. Vous pourrez ainsi vous exercer à écrire des instructions IF et
des structures LOOP.

Exercice 5
1. Exécutez la commande du fichier lab_05_01.sql pour créer la table messages. Ecrivez
un bloc PL/SQL permettant d'insérer des nombres dans la table messages.
a. Insérez les nombres 1 à 10, en excluant 6 et 8.
b. Effectuez une validation (commit) avant la fin du bloc.
c. Exécutez une instruction SELECT pour vérifier le fonctionnement du bloc PL/SQL.
Vous devez obtenir le résultat suivant :

2. Exécutez le script lab_05_02.sql. Ce script crée une table emp qui est une réplique de la
table employees. Il modifie la table emp afin d'ajouter une nouvelle colonne, stars, de type
VARCHAR2 et de taille 50. Créez un bloc PL/SQL qui insère un astérisque dans la colonne
stars pour chaque tranche de 1 000 $ du salaire de l'employé. Enregistrez le script sous le
nom lab_05_02_soln.sql.
a. Dans la section déclarative du bloc, déclarez la variable v_empno de type
emp.employee_id et initialisez-la avec la valeur 176. Déclarez la variable
v_asterisk de type emp.stars et initialisez-la à NULL. Créez la variable sal de
type emp.salary.
b. Dans la section exécutable, écrivez la logique permettant d'ajouter un astérisque (*) à la
chaîne pour chaque tranche de 1 000 $ du salaire. Par exemple, si l'employé gagne 8 000 $,
la chaîne doit contenir huit astérisques. Si l'employé gagne 12 500 $, la chaîne doit
contenir treize astérisques.
c. Mettez à jour la colonne stars de l'employé avec la chaîne d'astérisques correspondante.
Effectuez une validation (commit) avant la fin du bloc.

Exercice 5 (suite)
d. Affichez la ligne de la table emp afin de vérifier que le bloc PL/SQL s'est exécuté
correctement.
e. Exécutez le script et enregistrez-le sous le nom lab_05_02_soln.sql. La sortie
devrait se présenter comme suit :



Utiliser des types de données composites

Objectifs

• créer des enregistrements PL/SQL définis par l'utilisateur
• créer des enregistrements avec l'attribut %ROWTYPE
• créer une table INDEX BY
• créer une table d'enregistrements INDEX BY
• décrire les différences entre les enregistrements, les tables
et les tables d'enregistrements

But du chapitre
Nous avons déjà présenté les types de données composites. Dans ce chapitre, vous en saurez
plus sur les types de données composites et leurs utilisations.

• Ils peuvent contenir plusieurs valeurs (contrairement

aux types scalaires).
• Ils sont de deux types :
– Enregistrements PL/SQL
– Ensembles PL/SQL
— Tables INDEX BY ou tableaux associatifs
— Table imbriquée
— VARRAY


Nous avons vu que les variables de type scalaire ne peuvent contenir qu’une seule valeur,
tandis que les variables de type composite peuvent contenir plusieurs valeurs de type scalaire
ou de type composite. Il existe deux catégories de types de données composites :
• Enregistrements PL/SQL : Ces enregistrements sont utilisés pour traiter des données
liées mais différentes en tant qu'unité logique. Un enregistrement PL/SQL peut
comporter des variables de différents types. Vous pouvez par exemple définir un
enregistrement devant contenir les détails relatifs aux employés. Cela implique le
stockage d'un numéro d'employé en tant que type NUMBER, d'un prénom et d'un nom en
tant que type VARCHAR2, etc. En créant un enregistrement pour le stockage des détails
relatifs aux employés, vous définissez une unité collective logique. Cela facilite l'accès
aux données et leur manipulation.
• Ensembles PL/SQL : Les ensembles sont utilisés pour traiter les données comme une
unité unique. Les ensembles sont de trois types :
- Tables INDEX BY ou tableaux associatifs
- Tables imbriquées
- VARRAY
Pourquoi utiliser des types de données composites ?
Toutes les données liées se présentent sous la forme d'une unité unique. Vous pouvez
facilement accéder aux données et les modifier. La gestion, la mise en correspondance et le
transport des données sont simplifiés. Cette fonctionnalité peut être comparée au fait d'utiliser
une sacoche unique pour tous les composants de votre ordinateur portable plutôt qu'une
sacoche distincte pour chaque composant.

• Utilisez des enregistrements PL/SQL lorsque vous

souhaitez stocker des valeurs de différents types de
données, mais une seule occurrence à la fois.
• Utilisez des ensembles PL/SQL lorsque vous souhaitez
stocker des valeurs de même type de données.

Types de données composites (suite)

Si les enregistrements PL/SQL et les ensembles PL/SQL sont des types composites, comment
choisir lequel utiliser ?
Utilisez des enregistrements PL/SQL lorsque vous souhaitez stocker des valeurs de différents
types de données mais qui sont liées logiquement. Si vous créez un enregistrement destiné au
stockage des détails relatifs aux employés, indiquez que toutes les valeurs stockées sont liées,
car elles concernent un employé particulier.
Utilisez des ensembles PL/SQL lorsque vous souhaitez stocker des valeurs de même type de
données. Notez que ce type de données peut également être un type composite (par exemple,
des enregistrements). Vous pouvez définir un ensemble contenant les prénoms de tous les
employés. L'ensemble peut contenir n prénoms, mais le prénom 1 n'est pas lié au prénom 2.
La seule relation entre ces prénoms est qu'il s'agit de prénoms d'employés. Les ensembles sont
semblables aux tableaux dans les langages de programmation tels que C, C++ et Java.

Enregistrements PL/SQL
• Ils doivent contenir un ou plusieurs composants (appelés

des champs) de type scalaire, RECORD ou table INDEX BY.
• Ils sont semblables aux structures de la plupart des
langages de troisième génération (tels que C et C++).
• Ils sont définis par l'utilisateur et peuvent être un
sous-ensemble d'une ligne de table.
• Ils traitent un ensemble de champs comme une unité
logique.

• Ils permettent d'extraire une ligne de données à partir
d'une table pour la traiter.
Enregistrements PL/SQL
Un enregistrement est un groupe de données associées et stockées dans des champs. Chacun
d'eux possède un nom et un type de données qui lui sont propres.
• Chaque enregistrement ainsi défini peut contenir autant de champs que nécessaire.
• Il est possible de définir un enregistrement comme NOT NULL et de lui affecter des
valeurs initiales.
• Les champs qui ne contiennent pas de valeur initiale sont initialisés avec la valeur NULL.
• Le mot-clé DEFAULT peut être utilisé dans la définition des champs.
• Vous pouvez définir des types RECORD et déclarer des enregistrements définis par
l'utilisateur dans la section déclarative des blocs, des sous-programmes ou des packages.
• Vous pouvez déclarer et référencer des enregistrements imbriqués. Un enregistrement
peut être un composant d'un autre enregistrement.

Créer un enregistrement PL/SQL
Syntaxe :
1 TYPE type_name IS RECORD

(field_declaration[, field_declaration]…);
2 identifier type_name;
field_declaration:

field_name {field_type | variable%TYPE
| table.column%TYPE | table%ROWTYPE}
[[NOT NULL] {:= | DEFAULT} expr]

Les enregistrements PL/SQL sont des types composites définis par l'utilisateur. Pour les
utiliser :
1. Définissez l'enregistrement dans la section déclarative d'un bloc PL/SQL. La syntaxe
à utiliser est présentée dans la diapositive ci-dessus.
2. Déclarez (et éventuellement initialisez) les composants internes de ce type
d'enregistrement.
Dans la syntaxe :
type_name Nom du type RECORD (cet identificateur est utilisé pour déclarer des
enregistrements).
field_name Nom d'un champ de l'enregistrement.
field_type Type de données du champ. (Représente n'importe quel type de données
PL/SQL, à l'exception de REF CURSOR. Vous pouvez utiliser les
attributs %TYPE et %ROWTYPE.)
expr Valeur de field_type ou valeur initiale.
La contrainte NOT NULL empêche l'affectation de valeurs NULL à ces champs.
Veillez à initialiser les champs NOT NULL.
Le type REF CURSOR sera étudié dans l'annexe intitulée "Curseurs REF".

Déclarez des variables pour le stockage du nom, du poste et

du salaire d'un nouvel employé.
Exemple :
DECLARE
type t_rec is record
(v_sal number(8),
v_minsal number(8) default 1000,
v_hire_date employees.hire_date%type,
v_rec1 employees%rowtype);
v_myrec t_rec;
BEGIN

v_myrec.v_sal := v_myrec.v_minsal + 500;
v_myrec.v_hire_date := sysdate;
SELECT * INTO v_myrec.v_rec1
DBMS_OUTPUT.PUT_LINE(v_myrec.v_rec1.last_name ||' '||
to_char(v_myrec.v_hire_date) ||' '|| to_char(v_myrec.v_sal));
END;
Créer un enregistrement PL/SQL (suite)

Les déclarations de champ utilisées lors de la définition d'un enregistrement sont semblables
aux déclarations de variables. Chaque champ possède un nom unique et un type de donnée
spécifique. Il n'existe pas de types de données prédéfinis pour les enregistrements PL/SQL,
comme c'est le cas pour les variables scalaires. C'est pourquoi vous devez créer un type
d'enregistrement avant de déclarer un identificateur utilisant ce type.
L'exemple de la diapositive ci-dessus présente la définition du type d'enregistrement t_rec.
A l'étape suivante, l'enregistrement v_myrec de type t_rec est déclaré.
Remarque : Vous pouvez ajouter la contrainte NOT NULL à une déclaration de champ pour
empêcher l'affectation de valeurs NULL au champ. N'oubliez pas d'initialiser les champs
déclarés comme NOT NULL.

Structure d'un enregistrement PL/SQL
Champ1 Champ2 Champ3

(type de données) (type de données) (type de données)
Exemple :
Champ1 Champ2 Champ3

(type de données) (type de données) (type de données)
employee_id number(6) last_name varchar2(25) job_id varchar2(10)
100 King AD_PRES
Structure d'un enregistrement PL/SQL

Les champs d'un enregistrement sont accessibles par l'intermédiaire du nom de
l'enregistrement. Pour référencer ou initialiser un champ individuel, utilisez la notation à
points :
record_name.field_name
Par exemple, procédez comme suit pour référencer le champ job_id dans l'enregistrement
emp_record :
emp_record.job_id
Vous pouvez alors affecter une valeur au champ de l'enregistrement :
emp_record.job_id := 'ST_CLERK';
Dans un bloc ou un sous-programme, les enregistrements définis par l'utilisateur sont
instanciés lorsque vous accédez à ce bloc ou sous-programme. Ils cessent d'exister lorsque
vous quittez ce dernier.

Attribut %ROWTYPE
• Déclarez une variable correspondant à l'ensemble des

colonnes d'une table ou d'une vue de base de données.
• Faites précéder %ROWTYPE du nom de la table ou de la vue
de base de données.
• Les noms et types de données des champs de
l'enregistrement sont issus des colonnes de la table ou de
la vue.
Syntaxe :

DECLARE
identifier reference%ROWTYPE;
Attribut %ROWTYPE
Nous avons vu que %TYPE est utilisé pour déclarer une variable d'un type de colonne.
La variable présente le même type de données et la même taille que la colonne de la table.
L'avantage de l'attribut %TYPE est que vous n'avez pas à modifier la variable si la colonne est
modifiée. En outre, si la variable est utilisée dans des calculs, vous n'avez pas à vous
préoccuper de sa précision.
L'attribut %ROWTYPE est utilisé pour déclarer un enregistrement pouvant contenir une ligne
entière d'une table ou d'une vue. Les champs de l'enregistrement tirent leurs noms et leurs
types de données des colonnes de la table ou de la vue. L'enregistrement peut également
contenir une ligne complète de données extraite à partir d'un curseur ou d'une variable de
curseur.
La diapositive ci-dessus présente la syntaxe de déclaration d'un enregistrement. Dans la
syntaxe :
identifier Nom choisi pour l'enregistrement.
reference Nom de la table, de la vue, du curseur ou de la variable de curseur
servant de base à l'enregistrement (la table ou la vue doit exister
pour que cette référence soit valide).
Dans l'exemple suivant, un enregistrement est déclaré via l'attribut %ROWTYPE, qui permet
de définir le type de données :
DECLARE
emp_record employees%ROWTYPE;
...

Attribut %ROWTYPE (suite)
La structure de l'enregistrement emp_record comporte les champs suivants (chacun représentant

une colonne de la table employees) :
Remarque : Il ne s'agit pas de code mais simplement de la structure de la variable composite.
(employee_id NUMBER(6),
first_name VARCHAR2(20),
last_name VARCHAR2(20),
email VARCHAR2(20),
phone_number VARCHAR2(20),
hire_date DATE,
salary NUMBER(8,2),
commission_pct NUMBER(2,2),
manager_id NUMBER(6),
department_id NUMBER(4))

Pour référencer un champ individuel, utilisez la notation à points :
record_name.field_name
Par exemple, procédez comme suit pour référencer le champ commission_pct dans
l'enregistrement emp_record :
emp_record.commission_pct
Vous pouvez alors affecter une valeur au champ de l'enregistrement :
emp_record.commission_pct:= .35;
Affecter des valeurs aux enregistrements
Vous pouvez affecter une liste de valeurs communes à un enregistrement en utilisant l'instruction
SELECT ou FETCH. Assurez-vous que les noms des colonnes apparaissent dans le même ordre que
les champs dans l'enregistrement. Vous pouvez également affecter un enregistrement à un autre
enregistrement si leur type de données est identique. Un enregistrement de type
employees%ROWTYPE et un type d'enregistrement défini par l'utilisateur ayant des champs
analogues à ceux de la table employees ont le même type de données. Par conséquent, si un
enregistrement défini par l'utilisateur contient des champs similaires aux champs d'un enregistrement
%ROWTYPE, vous pouvez affecter cet enregistrement défini par l'utilisateur à l'enregistrement
%ROWTYPE.

Avantages liés à l'utilisation de l'attribut

%ROWTYPE
• Il n'est pas nécessaire de connaître le nombre et les types
de données des colonnes sous-jacentes ; en outre, ces
derniers peuvent changer lors de l'exécution.
• L'attribut %ROWTYPE permet d'extraire une ligne avec
l'instruction SELECT *.

Avantages liés à l'utilisation de l'attribut %ROWTYPE

Les avantages liés à l'utilisation de l'attribut %ROWTYPE sont présentés dans la diapositive.
Utilisez l'attribut %ROWTYPE lorsque vous n'êtes pas sûr de la structure de la table de base
de données sous-jacente.
Le principal avantage de l'utilisation de %ROWTYPE est que cela permet de simplifier la
maintenance. Par ailleurs, les types de données des variables déclarées avec cet attribut sont
modifiés dynamiquement en cas de modification de la table sous-jacente. Si une instruction
LDD modifie les colonnes d'une table, le programme PL/SQL est invalidé. Lorsque le
programme est recompilé, il reflète automatiquement le nouveau format de table.
L'attribut %ROWTYPE est particulièrement utile lorsque vous souhaitez extraire une ligne
entière d'une table. Si vous n'utilisez pas cet attribut, vous devez déclarer une variable pour
chaque colonne extraite avec l'instruction SELECT.

Attribut %ROWTYPE : Exemple
DECLARE
v_employee_number number:= 124;
v_emp_rec employees%ROWTYPE;
BEGIN
SELECT * INTO v_emp_rec FROM employees
WHERE employee_id = v_employee_number;
INSERT INTO retired_emps(empno, ename, job, mgr,
hiredate, leavedate, sal, comm, deptno)
VALUES (v_emp_rec.employee_id, v_emp_rec.last_name,
v_emp_rec.job_id, v_emp_rec.manager_id,

v_emp_rec.hire_date, SYSDATE,
v_emp_rec.salary, v_emp_rec.commission_pct,
v_emp_rec.department_id);
END;
/
Attribut %ROWTYPE : Exemple

Un exemple d'attribut %ROWTYPE est illustré dans la diapositive ci-dessus. Lorsqu'un
employé part en retraite, les informations le concernant sont ajoutées à une table qui contient
les informations relatives aux employés retraités. L'utilisateur indique le numéro de l'employé.
L'enregistrement correspondant est extrait de la table employees et placé dans la variable
emp_rec, déclarée avec l'attribut %ROWTYPE.
L'instruction CREATE permettant de créer la table retired_emps est la suivante :
CREATE TABLE retired_emps
(EMPNO NUMBER(4), ENAME VARCHAR2(10),
JOB VARCHAR2(9),MGR NUMBER(4),
HIREDATE DATE, LEAVEDATE DATE,
SAL NUMBER(7,2), COMM NUMBER(7,2),
DEPTNO NUMBER(2))
L'enregistrement inséré dans la table retired_emps est présenté ci-après :

Insérer un enregistrement
à l'aide de %ROWTYPE
...
DECLARE
v_emp_rec retired_emps%ROWTYPE;
BEGIN
SELECT employee_id, last_name, job_id, manager_id,
hire_date, hire_date, salary, commission_pct,
department_id INTO v_emp_rec FROM employees

WHERE employee_id = v_employee_number;
INSERT INTO retired_emps VALUES v_emp_rec;
END;
/
SELECT * FROM retired_emps;
Insérer un enregistrement à l'aide de %ROWTYPE

Comparez l'instruction INSERT de la diapositive précédente avec celle de la diapositive
ci-dessus. L'enregistrement emp_rec est de type retired_emps. Le nombre de champs
de l'enregistrement doit être égal au nombre de champs de la clause INTO. Vous pouvez
utiliser cet enregistrement pour insérer des valeurs dans une table. Le code devient ainsi plus
lisible.
Observez l'instruction SELECT de la diapositive. Vous sélectionnez deux fois hire_date
et vous insérez la valeur hire_date dans le champ leavedate de la table
retired_emps. Aucun employé ne prend sa retraite à la date d'embauche. L'enregistrement
inséré est illustré ci-après. (Vous verrez comment effectuer une mise à jour dans la diapositive
suivante.)

Mettre à jour une ligne d'une table

à l'aide d'un enregistrement
SET VERIFY OFF

DECLARE
v_emp_rec retired_emps%ROWTYPE;
BEGIN
SELECT * INTO v_emp_rec FROM retired_emps;
v_emp_rec.leavedate:=CURRENT_DATE;
UPDATE retired_emps SET ROW = v_emp_rec WHERE

empno=v_employee_number;
END;
/
SELECT * FROM retired_emps;
Mettre à jour une ligne d'une table à l'aide d'un enregistrement

Vous avez appris à insérer une ligne à l'aide d'un enregistrement. La diapositive ci-dessus
montre comment mettre à jour une ligne à l'aide d'un enregistrement. Le mot-clé ROW est
utilisé pour représenter la ligne entière. Le code de la diapositive ci-dessus met à jour la
valeur leavedate de l'employé. L'enregistrement est mis à jour.

Tables INDEX BY ou tableaux associatifs
• Structures PL/SQL avec deux colonnes :

– Clé primaire de type entier ou chaîne
– Colonne de type scalaire ou RECORD
• Pas de contrainte de taille. La taille dépend des valeurs
pouvant être contenues dans le type de données de clé.

Tables INDEX BY ou tableaux associatifs

Les tables INDEX BY sont des types composites (ensembles) et sont définies par l'utilisateur.
Elles permettent le stockage de données avec une valeur de clé primaire comme index, les
valeurs de clé n'étant pas nécessairement séquentielles. Les tables INDEX BY sont des
ensembles de paires clé-valeur.
Les tables INDEX BY comportent seulement deux colonnes :
• Une colonne de type entier ou chaîne, qui joue le rôle de clé primaire. La clé peut être
numérique, de type BINARY_INTEGER ou PLS_INTEGER. Les types
BINARY_INTEGER et PLS_INTEGER nécessitent moins d'espace de stockage que le
type NUMBER. Ils sont utilisés pour représenter des entiers mathématiques dans un format
compact et pour implémenter des opérations arithmétiques à l'aide de la librairie
arithmétique. Sur ces types de données, les opérations arithmétiques sont plus rapides
qu'avec le type NUMBER. La clé peut également être de type VARCHAR2 ou de l'un de
ses sous-types. Les exemples de ce cours utilisent le type de données PLS_INTEGER
pour la colonne de clé.
• Une colonne de type scalaire ou RECORD contenant les valeurs. Si la colonne est de type
scalaire, elle ne peut contenir qu'une seule valeur. Si la colonne est de type RECORD,
elle peut contenir plusieurs valeurs.
Les tables INDEX BY ne sont soumises à aucune contrainte en termes de taille. Cependant,
la clé de la colonne PLS_INTEGER est limitée à la valeur maximale pouvant être contenue
dans un type PLS_INTEGER. Notez que les clés peuvent être positives ou négatives. Les clés
des tables INDEX BY ne sont pas nécessairement ordonnées.

Créer une table INDEX BY
Syntaxe :
TYPE type_name IS TABLE OF
{column_type | variable%TYPE
| table.column%TYPE} [NOT NULL]
| table%ROWTYPE
[INDEX BY PLS_INTEGER | BINARY_INTEGER
| VARCHAR2(<size>)];
identifier type_name;
Déclarez une table INDEX BY pour le stockage du nom des
employés :

...
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
INDEX BY PLS_INTEGER;
...
ename_table ename_table_type;

La création d'une table INDEX BY s'effectue en deux étapes :
1. Déclarez un type de données TABLE.
2. Déclarez une variable utilisant ce type de données.
Dans la syntaxe :
type_name Nom du type TABLE (type qui sera utilisé dans les déclarations
suivantes des identificateurs de table PL/SQL).
column_type Type de données scalaire ou composite quelconque, tel que

VARCHAR2, DATE, NUMBER ou %TYPE (vous pouvez utiliser l'attribut
%TYPE pour indiquer le type de données de la colonne).
identifier Identificateur représentant une table PL/SQL dans son ensemble.

Créer une table INDEX BY (suite)
La contrainte NOT NULL permet d'empêcher l'affectation de valeurs NULL à une table PL/SQL.
N'initialisez pas la table INDEX BY.
Les tables INDEX BY peuvent présenter n'importe quel type scalaire.
Les tables INDEX BY ne sont pas remplies automatiquement lors de leur création. Vous devez les
alimenter au moyen de programmes PL/SQL avant de les utiliser.

Structure des tables INDEX BY
Clé unique Valeur

... ...
1 Jones
5 Smith
3 Maduro
... ...

PLS_INTEGER Scalaire
Structure des tables INDEX BY

Tout comme une table de base de données, une table INDEX BY ne présente pas de contrainte
de taille. Cela signifie que le nombre de ses lignes peut augmenter de façon dynamique.
Les tables INDEX BY peuvent comporter une colonne dotée d'un identificateur unique (aucun
de ces deux éléments ne peut avoir de nom). La colonne peut présenter n'importe quel type de
données scalaire ou RECORD. La clé primaire peut être un nombre ou une chaîne. Vous ne
pouvez pas initialiser une table INDEX BY dans sa déclaration. Une table INDEX BY n'est pas
renseignée lors de sa déclaration. Elle ne contient ni clé, ni valeur.
Une instruction exécutable explicite est requise pour alimenter la table INDEX BY.

DECLARE
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
TYPE hiredate_table_type IS TABLE OF DATE
ename_table ename_table_type;
hiredate_table hiredate_table_type;
BEGIN
ename_table(1) := 'CAMERON';
hiredate_table(8) := SYSDATE + 7;

IF ename_table.EXISTS(1) THEN
INSERT INTO ...
...
END;
/

L'exemple de la diapositive ci-dessus crée deux tables INDEX BY.
Pour accéder à un élément d'une telle table, vous utilisez la clé de celle-ci.
Syntaxe :
INDEX_BY_table_name(index)
Ici, index est de type PLS_INTEGER.
L'exemple ci-après montre comment référencer la troisième ligne d'une table INDEX BY
nommée ename_table :
ename_table(3)
Le type PLS_INTEGER admet des valeurs comprises entre –2 147 483 647 et 2 147 483 647.
La clé primaire peut donc avoir une valeur négative. L'indexation ne doit pas nécessairement
commencer à 1.
Remarque : La méthode exists(i) renvoie TRUE si une ligne comportant l'index i est
renvoyée. Utilisez la méthode exists pour éviter le déclenchement d'une erreur en cas de
référence à un élément de table inexistant.

Utiliser les méthodes des tables INDEX BY
Les méthodes suivantes facilitent l'utilisation des tables

INDEX BY :
• EXISTS • PRIOR
• COUNT • NEXT
• FIRST • DELETE
• LAST

Utiliser les méthodes des tables INDEX BY

Une méthode de table INDEX BY est une procédure ou une fonction intégrée qui opère sur
une table PL/SQL. Pour appeler une telle méthode, utilisez la notation à points.
Syntaxe : table_name.method_name[ (parameters) ]
Méthode Description
EXISTS(n) Renvoie TRUE si le nième élément d'une table PL/SQL existe.
COUNT Renvoie le nombre d'éléments contenus dans une table PL/SQL.
FIRST • Renvoie le premier (le plus petit) numéro d'index d'une table PL/SQL.
• Renvoie NULL si la table PL/SQL est vide.
LAST • Renvoie le dernier (le plus grand) numéro d'index d'une table PL/SQL.
• Renvoie NULL si la table PL/SQL est vide.
PRIOR(n) Renvoie le numéro d'index qui précède l'index n dans une table PL/SQL.
NEXT(n) Renvoie le numéro d'index qui suit l'index n dans une table PL/SQL.
DELETE • DELETE supprime tous les éléments d'une table PL/SQL.
• DELETE(n) supprime le nième élément d'une table PL/SQL.
• DELETE(m, n) supprime tous les éléments d'une table PL/SQL situés
dans la plage comprise entre m et n.

Table d'enregistrements INDEX BY
Définissez une variable de table INDEX BY contenant une ligne

entière d'une table.
Exemple :
DECLARE
TYPE dept_table_type IS TABLE OF
departments%ROWTYPE
INDEX BY VARCHAR2(20);
dept_table dept_table_type;
-- Each element of dept_table is a record

Table d'enregistrements INDEX BY

A un instant donné quelconque, une table INDEX BY déclarée avec un type scalaire permet
le stockage des détails d'une seule colonne d'une table de base de données. Cependant, il est
souvent nécessaire de stocker toutes les colonnes extraites par une interrogation. La table
d'enregistrements INDEX BY offre la solution appropriée. Etant donné qu'une seule définition
de table est nécessaire pour le stockage des informations relatives à l'ensemble des champs
d'une table de base de données, la table des enregistrements augmente considérablement les
fonctionnalités des tables INDEX BY.
Référencer une table d'enregistrements
Dans l'exemple de la diapositive ci-dessus, vous pouvez référencer les champs de
l'enregistrement dept_table, car chaque élément de la table est un enregistrement.
Syntaxe :
table(index).field
Exemple :
dept_table(IT).location_id := 1400;
location_id représente un champ de dept_table.

Table d'enregistrements INDEX BY (suite)
Référencer une table d'enregistrements (suite)

Vous pouvez utiliser l'attribut %ROWTYPE pour déclarer un enregistrement représentant une ligne
dans une table de base de données. Les différences entre l'attribut %ROWTYPE et l'enregistrement
PL/SQL de type composite sont les suivantes :
• Les types d'enregistrement PL/SQL peuvent être définis par l'utilisateur, tandis que %ROWTYPE
définit implicitement l'enregistrement.
• Les enregistrements PL/SQL vous permettent de définir les champs et leur type de données lors
de l'étape de déclaration. Lorsque vous utilisez %ROWTYPE, vous ne pouvez pas indiquer les
champs. L'attribut %ROWTYPE représente une ligne d'une table avec tous les champs basés sur
la définition de cette table.
• Les enregistrements définis par l'utilisateur sont statiques. Les enregistrements %ROWTYPE sont
dynamiques car ils sont basés sur une structure de table. Toute modification éventuelle de la
structure de la table est répercutée sur la structure de l'enregistrement.

Table d'enregistrements INDEX BY : Exemple
DECLARE
TYPE emp_table_type IS TABLE OF
employees%ROWTYPE INDEX BY PLS_INTEGER;
my_emp_table emp_table_type;
max_count NUMBER(3):= 104;
BEGIN
FOR i IN 100..max_count
LOOP
SELECT * INTO my_emp_table(i) FROM employees
WHERE employee_id = i;
END LOOP;
FOR i IN my_emp_table.FIRST..my_emp_table.LAST

LOOP
DBMS_OUTPUT.PUT_LINE(my_emp_table(i).last_name);
END LOOP;
END;
/
Table d'enregistrements INDEX BY : Exemple

L'exemple de la diapositive ci-dessus déclare une table d'enregistrements INDEX BY nommée
emp_table_type pour permettre le stockage temporaire des données relatives aux
employés dont le numéro est compris entre 100 et 104. Les informations de la table
EMPLOYEES sont extraites à l'aide d'une boucle et placées dans la table INDEX BY.
Une autre boucle permet d'afficher les noms figurant dans la table INDEX BY. Observez
l'utilisation des méthodes first et last dans cet exemple.
Remarque : La diapositive présente l'utilisation d'une table d'enregistrements INDEX BY.
Toutefois, vous pouvez effectuer les mêmes opérations plus efficacement à l'aide de curseurs.
Les curseurs seront étudiés ultérieurement dans le chapitre "Utiliser des curseurs explicites".

Tables imbriquées
1 Bombay
2 Sydney
3 Oxford
4 London
.. ....
2 Go

Tables imbriquées
Les tables imbriquées ont des fonctionnalités similaires à celles des tables INDEX BY, mais
elles présentent quelques différences dans leur implémentation. Le type de données table
imbriquée est valide dans une table au niveau schéma, contrairement au type table
INDEX BY. La clé ne peut pas avoir une valeur négative (contrairement à celle d'une table
INDEX BY). Bien que la première colonne soit indiquée comme colonne de clé, il n'y a pas de
clé dans une table imbriquée. Il existe une colonne comprenant des nombres ordonnés,
considérée comme la colonne de clé. Les éléments peuvent être supprimés n'importe où dans
une table imbriquée, ce qui donne une table dispersée avec des clés non séquentielles. Les
lignes d'une table imbriquée ne sont définies dans aucun ordre particulier. Lorsque vous
extrayez des valeurs d'une table imbriquée, des indices consécutifs sont affectés aux lignes, en
commençant à 1. Les tables imbriquées peuvent être stockées dans la base de données
(contrairement aux tables INDEX BY).
Syntaxe
TYPE type_name IS TABLE OF
{column_type | variable%TYPE
| table.column%TYPE} [NOT NULL]
| table.%ROWTYPE
Depuis Oracle Database 10g, les tables imbriquées peuvent faire l'objet d'une comparaison
d'égalité. Vous pouvez vérifier si un élément existe dans une table imbriquée et également si
une table imbriquée est un sous-ensemble d'une autre.

Tables imbriquées (suite)

Exemple :
TYPE location_type IS TABLE OF locations.city%TYPE;
offices location_type;
Lorsque vous n'initialisez pas une table imbriquée, elle est automatiquement initialisée avec la valeur
NULL. Vous pouvez initialiser la table imbriquée offices en utilisant un constructeur :
offices := location_type('Bombay', 'Tokyo','Singapore',
'Oxford');
Exemple complet :
DECLARE
TYPE location_type IS TABLE OF locations.city%TYPE;
table_count NUMBER;
BEGIN

offices := location_type('Bombay', 'Tokyo','Singapore',
'Oxford');
FOR i in 1.. offices.count() LOOP
DBMS_OUTPUT.PUT_LINE(offices(i));
END LOOP;
END;
/

VARRAY
1 Bombay
2 Sydney
3 Oxford
4 London
.. ....
10 Tokyo

VARRAY
Un tableau de taille variable (VARRAY) est semblable à une table PL/SQL, à ceci près que sa
taille est soumise à une contrainte. Un VARRAY est valide dans une table de niveau schéma.
Les éléments de type VARRAY sont appelés des VARRAY. Les VARRAY présentent une limite
supérieure fixe. Vous devez indiquer cette limite lorsque vous les déclarez, comme pour les
tableaux en langage C. La taille maximale d'un VARRAY est de 2 Go, comme pour les tables
imbriquées. La distinction entre une table imbriquée et un VARRAY réside dans le mode de
stockage physique. Les éléments d'un VARRAY sont stockés de manière contiguë dans la
mémoire, et non dans la base de données. Il est possible de créer un type VARRAY dans la
base de données à l'aide du langage SQL.
Exemple :
TYPE location_type IS VARRAY(3) OF locations.city%TYPE;
La taille de ce VARRAY est limitée à 3. Vous pouvez initialiser un VARRAY à l'aide de
constructeurs. Si vous tentez d'initialiser le VARRAY avec plus de trois éléments, vous obtenez
le message d'erreur "Subscript outside of limit".

Synthèse

• définir et référencer des variables PL/SQL possédant
des types de données composites
– Enregistrement PL/SQL
– Table INDEX BY
– Table d'enregistrements INDEX BY
• définir un enregistrement PL/SQL à l'aide de l'attribut
%ROWTYPE

Synthèse
Un enregistrement PL/SQL est un ensemble de champs représentant une ligne dans une table.
Les enregistrements vous permettent de regrouper des données au sein d'une même structure
et de manipuler cette dernière comme une entité ou une unité logique. Vous pouvez ainsi
limiter l'écriture de code, ce qui facilite la maintenance et la compréhension des programmes.
Comme les enregistrements PL/SQL, la table est un autre type de données composite. Les
tables INDEX BY sont des objets de type TABLE semblables aux tables de base de données,
avec toutefois une légère différence. Les tables INDEX BY utilisent une clé primaire
permettant d'accéder aux lignes comme dans un tableau. Elles ne présentent pas de contrainte
de taille. Les tables INDEX BY contiennent des paires clé-valeur. La colonne de clé doit être
de type entier ou chaîne alors que la colonne contenant la valeur peut être de n'importe quel
type.
Les valeurs de clé d'une table imbriquée ne peuvent pas être négatives, contrairement à celles
d'une table INDEX BY. Par ailleurs, elles doivent être séquentielles.
Les tableaux de taille variable (VARRAY) sont semblables aux tables PL/SQL, à ceci près que
leur taille fait l'objet d'une contrainte.


• Déclarer des tables INDEX BY
• Traiter des données en utilisant des tables INDEX BY
• Déclarer un enregistrement PL/SQL
• Traiter des données à l'aide d'un enregistrement PL/SQL

Dans cet exercice, vous allez définir, créer et utiliser des tables INDEX BY, ainsi qu'un
enregistrement PL/SQL.

Exercice 6
1. Ecrivez un bloc PL/SQL permettant d'afficher les informations relatives à un pays donné.
a. Déclarez un enregistrement PL/SQL conforme à la structure de la table countries.
b. Déclarez une variable v_countryid. Affectez CA à v_countryid.
c. Dans la section déclarative, utilisez l'attribut %ROWTYPE et déclarez la variable
v_country_record de type countries.
d. Dans la section exécutable, obtenez toutes les informations de la table countries à l'aide
de countryid. Affichez les informations sélectionnées sur le pays. Voici un exemple de
résultat :

e. Vous pouvez exécuter et tester le bloc PL/SQL pour les pays dont l'ID est DE, UK et US.
2. Créez un bloc PL/SQL pour extraire le nom de chaque département de la table departments
et afficher le nom du département à l'écran, en utilisant une table INDEX BY. Enregistrez le
script sous le nom lab_06_02_soln.sql.
a. Déclarez une table INDEX BY nommée dept_table_type de type
departments.department_name. Déclarez une variable nommée
my_dept_table de type dept_table_type afin de stocker temporairement le
numéro des départements.
b. Déclarez deux variables nommées loop_count et deptno de type NUMBER. Affectez
la valeur 10 à loop_count et la valeur 0 à deptno.
c. A l'aide d'une boucle, extrayez les noms de 10 départements et stockez-les dans la table
INDEX BY. Commencez par la valeur department_id 10. Augmentez deptno de 10
à chaque itération de la boucle. Le tableau qui suit indique la valeur department_id
pour laquelle vous devez extraire la valeur department_name et la stocker dans la table
INDEX BY.
DEPARTMENT_ID DEPARTMENT_NAME
10 Administration
20 Marketing
30 Purchasing
40 Human Resources
50 Shipping
60 IT
70 Public Relations
80 Sales
90 Executive
100 Finance

Exercice 6 (suite)
d. A l'aide d'une autre boucle, extrayez les noms des départements de la table INDEX BY et
affichez-les.
e. Exécutez votre script et enregistrez-le sous le nom lab_06_02_soln.sql. Un exemple
de sortie est affiché ci-après.

Exercice 6 (suite)
3. Modifiez le bloc créé au point 2 afin d'extraire toutes les informations sur les départements de la
table departments et de les afficher. Utilisez une table d'enregistrements INDEX BY.
a. Chargez le script lab_06_02_soln.sql.
b. Vous avez déclaré la table INDEX BY comme étant de type
departments.department_name. Modifiez la déclaration de la table INDEX BY
afin de stocker temporairement le numéro, le nom et l'emplacement des départements.
Utilisez l'attribut %ROWTYPE.
c. Modifiez l'instruction SELECT afin d'extraire toutes les informations relatives aux
départements, actuellement contenues dans la table departments, et stockez celles-ci
dans la table INDEX BY.
d. A l'aide d'une autre boucle, extrayez les informations relatives aux départements de la table
INDEX BY et affichez-les. Voici un exemple de résultat :

Department Number: 10 Department Name: Administration Manager Id:
200 Location Id: 1700
Department Number: 20 Department Name: Marketing Manager Id: 201
Location Id: 1800
Department Number: 30 Department Name: Purchasing Manager Id: 114
Location Id: 1700
Department Number: 40 Department Name: Human Resources Manager Id:
Department Number: 50 Department Name: Shipping Manager Id: 121
Location Id: 1500
Department Number: 60 Department Name: IT Manager Id: 103 Location
Id: 1400
Department Number: 70 Department Name: Public Relations Manager
Id: 204 Location Id: 2700
Department Number: 80 Department Name: Sales Manager Id: 145
Location Id: 2500
Department Number: 90 Department Name: Executive Manager Id: 100
Location Id: 1700
Department Number: 100 Department Name: Finance Manager Id: 108
Location Id: 1700



Utiliser des curseurs explicites

Objectifs

• énoncer les raisons de l'utilisation des curseurs explicites
• déclarer et contrôler des curseurs explicites
• utiliser des boucles simples et des boucles FOR de curseur
pour extraire des données
• déclarer et utiliser des curseurs avec des paramètres
• verrouiller des lignes à l'aide de la clause FOR UPDATE

• référencer la ligne actuelle avec la clause WHERE CURRENT OF
But du chapitre
Nous avons étudié les curseurs implicites créés automatiquement par le compilateur PL/SQL
lors de l'exécution d'une instruction SQL SELECT ou d'une instruction LMD. Dans ce
chapitre, vous découvrirez les curseurs explicites. Vous apprendrez à faire la distinction entre
les curseurs implicites et les curseurs explicites. Vous apprendrez également à déclarer et à
contrôler des curseurs simples et des curseurs avec paramètres.

Curseurs
A chaque instruction SQL exécutée par le serveur Oracle est

associé un curseur individuel :
• Curseur implicite : Déclaré et géré par le compilateur
PL/SQL pour toutes les instructions LMD et les instructions
PL/SQL SELECT
• Curseur explicite : Déclaré et géré par le programmeur

Curseurs
Le serveur Oracle utilise des zones de travail (nommées zones de mémoire SQL privées) pour
exécuter les instructions SQL et assurer le stockage des informations de traitement. Vous
pouvez utiliser des curseurs explicites pour nommer ces zones et accéder aux informations
qu'elles contiennent.
Type de curseur Description
Implicite Les curseurs implicites sont déclarés par le compilateur

PL/SQL pour toutes les instructions LMD et les instructions
PL/SQL SELECT.
Explicite Pour les interrogations renvoyant plusieurs lignes, les curseurs
explicites sont déclarés et gérés par le programmeur, puis sont
manipulés à l'aide d'instructions spécifiques contenues dans les
actions exécutables du bloc.
Le serveur Oracle ouvre implicitement un curseur pour traiter chaque instruction SQL non
associée à un curseur explicitement déclaré. Le langage PL/SQL permet de référencer le
curseur implicite le plus récent en tant que curseur SQL.

Fonctionnalités des curseurs explicites
Table
100 King AD_PRES
101 Kochhar AD_VP
Ensemble actif
102 De Haan AD_VP
. . .
. . .

. . .
139 Seo ST_CLERK
140 Patel ST_CLERK
. . .
Fonctionnalités des curseurs explicites

Vous pouvez déclarer des curseurs explicites dans du code PL/SQL lorsqu'une instruction
SELECT renvoie plusieurs lignes. Vous pouvez traiter chaque ligne renvoyée par l'instruction
SELECT.
L'ensemble des lignes renvoyées par une interrogation se nomme l'ensemble actif. Sa taille est
égale au nombre de lignes satisfaisant aux critères de recherche. Le schéma de la diapositive
ci-dessus montre comment un curseur explicite "pointe" vers la ligne en cours dans l'ensemble
actif. Cela permet à votre programme de traiter les lignes une par une.
Fonctionnalités des curseurs explicites :
• Ils peuvent effectuer un traitement ligne par ligne, au-delà de la première ligne renvoyée
par une interrogation.
• Ils effectuent le suivi de la ligne en cours de traitement.
• Le programmeur peut contrôler manuellement les curseurs explicites dans le bloc
PL/SQL.

Contrôler les curseurs explicites
Non
Oui
DECLARE OPEN FETCH VIDE? CLOSE
• Créer • Identifier • Charger • Tester • Libérer

une zone l'ensemble la ligne l'existence l'ensemble
SQL actif en cours de lignes actif

nommée dans des
variables • Si des
lignes
existent,
revenir à
FETCH

Après avoir étudié les curseurs d'un point de vue conceptuel, revoyons les étapes de leur
utilisation.
1. Dans la section déclarative d'un bloc PL/SQL, déclarez un curseur en le nommant et en
définissant la structure de l'interrogation associée.
2. Ouverture du curseur
L'instruction OPEN exécute l'interrogation et effectue une affectation de valeur (bind)
pour toutes les variables référencées. Les lignes identifiées par l'interrogation constituent
l'ensemble actif et peuvent désormais faire l'objet d'une extraction (fetch).
3. Extraction des données à partir du curseur
Dans le diagramme de flux présenté dans la diapositive ci-dessus, après chaque
extraction, vous testez l'existence de la ligne dans le curseur. S'il n'y a plus de lignes à
traiter, vous devez fermer le curseur.
4. Fermeture du curseur
L'instruction CLOSE libère l'ensemble actif de lignes. Il est possible de rouvrir le curseur
pour établir un nouvel ensemble actif.

1 Ouverture du
curseur
Pointeur
de curseur
2 Extraction
d'une ligne
Pointeur
de curseur

3 Fermeture Pointeur
du curseur de curseur
Contrôler les curseurs explicites (suite)

Un programme PL/SQL ouvre un curseur, traite les lignes renvoyées par une interrogation,
puis ferme le curseur. Ce dernier marque la position actuelle dans l'ensemble actif.
1. L'instruction OPEN exécute l'interrogation associée au curseur, identifie l'ensemble actif
et positionne le curseur sur la première ligne.
2. L'instruction FETCH extrait la ligne en cours et place le curseur sur la ligne suivante
jusqu'à ce qu'il n'y ait plus de lignes ou que la condition indiquée soit satisfaite.
3. L'instruction CLOSE libère le curseur.

Déclarer un curseur
Syntaxe :
CURSOR cursor_name IS
select_statement;
Exemples :
DECLARE
CURSOR c_emp_cursor IS
SELECT employee_id, last_name FROM employees
WHERE department_id =30;

DECLARE
v_locid NUMBER:= 1700;
CURSOR c_dept_cursor IS
SELECT * FROM departments
WHERE location_id = v_locid;
...
Déclarer un curseur
La syntaxe permettant de déclarer un curseur est présentée dans la diapositive ci-dessus. Dans
la syntaxe :
cursor_name Identificateur PL/SQL.
select_statement Instruction SELECT sans clause INTO.
L'ensemble actif d'un curseur est déterminé par l'instruction SELECT dans la déclaration du
curseur. La clause INTO est obligatoire dans une instruction SELECT en langage PL/SQL.
Cependant, notez que l'instruction SELECT dans la déclaration de curseur ne peut pas
comporter de clause INTO. Cela est dû au fait que vous définissez uniquement un curseur
dans la section déclarative et que vous n'extrayez aucune ligne dans le curseur.
Remarque
• N'incluez pas de clause INTO dans la déclaration du curseur, car elle apparaît plus tard
dans l'instruction FETCH.
• S'il existe un ordre précis de traitement des lignes, utilisez la clause ORDER BY dans
l'interrogation.
• Le curseur peut contenir n'importe quelle instruction SELECT valide, notamment des
jointures, des sous-interrogations, etc.

Déclarer un curseur (suite)

Le curseur c_emp_cursor est déclaré pour extraire les colonnes employee_id et last_name
correspondant aux employés qui travaillent dans le département dont la valeur department_id
est 30.
Le curseur c_dept_cursor est déclaré pour extraire toutes les informations relatives au
département dont la valeur location_id est 1700. Notez qu'une variable est utilisée lors de la
déclaration du curseur. Ces variables sont considérées comme des variables attachées (bind
variables). Elles doivent être visibles lorsque vous déclarez le curseur. Ces variables sont examinées
une seule fois lors de l'ouverture du curseur. Nous avons vu que les curseurs explicites sont utilisés
lorsque vous devez extraire plusieurs lignes en langage PL/SQL et opérer sur ces lignes. Cependant,
l'exemple montre qu'il est aussi possible d'utiliser un curseur explicite lorsque l'instruction SELECT
renvoie une seule ligne.

Ouvrir le curseur
DECLARE
...
BEGIN
OPEN c_emp_cursor;

Ouvrir le curseur
L'instruction OPEN exécute l'interrogation associée au curseur, identifie l'ensemble actif et
positionne le pointeur de curseur sur la première ligne. L'instruction OPEN est incluse dans
la section exécutable du bloc PL/SQL.
OPEN est une instruction exécutable qui effectue les opérations suivantes :
1. Elle alloue de manière dynamique de la mémoire pour une zone de contexte.
2. Elle analyse (parse) l'instruction SELECT.
3. Elle attache les variables d'entrée (en d'autres termes, elle fixe la valeur des variables
d'entrée en obtenant leurs adresses mémoire).
4. Elle identifie l'ensemble actif (c'est-à-dire l'ensemble des lignes qui satisfont aux critères
de recherche). Les lignes de l'ensemble actif ne sont pas extraites pour être placées dans
des variables lors de l'exécution de l'instruction OPEN. L'instruction FETCH extrait les
lignes du curseur dans les variables.
5. Elle positionne le pointeur sur la première ligne dans l'ensemble actif.
Remarque : Si une interrogation ne renvoie aucune ligne lorsque le curseur est ouvert,
le code PL/SQL ne déclenche pas d'exception. Vous pouvez connaître le nombre de lignes
renvoyées par un curseur explicite en utilisant l'attribut <cursor_name>%ROWCOUNT.

Extraire des données du curseur
DECLARE
v_empno employees.employee_id%TYPE;
v_lname employees.last_name%TYPE;
BEGIN
OPEN c_emp_cursor;
FETCH c_emp_cursor INTO v_empno, v_lname;
DBMS_OUTPUT.PUT_LINE( v_empno ||' '||v_lname);
END;

/

L'instruction FETCH extrait, une par une, les lignes du curseur. Après chaque extraction,
le curseur passe à la ligne suivante de l'ensemble actif. Vous pouvez utiliser l'attribut
%NOTFOUND pour déterminer si l'ensemble actif a été extrait en totalité.
Examinez l'exemple de la diapositive ci-dessus. Deux variables, à savoir empno et lname,
sont déclarées pour le stockage des valeurs extraites du curseur. Examinez l'instruction
FETCH.
La sortie générée par l'exécution du bloc PL/SQL est la suivante :
Vous avez extrait avec succès les valeurs du curseur dans les variables. Cependant, le
département 30 compte six employés alors qu'une seule ligne a été extraite. Pour extraire
toutes les lignes, vous devez utiliser des boucles. La diapositive qui suit montre comment
utiliser une boucle pour extraire toutes les lignes.
L'instruction FETCH effectue les opérations suivantes :
1. Elle lit les données de la ligne en cours et les stocke dans les variables de sortie PL/SQL.
2. Elle fait passer le pointeur à la ligne suivante de l'ensemble actif.

Extraire des données du curseur (suite)

Dans la clause INTO de l'instruction FETCH, vous pouvez inclure un nombre de variables égal au
nombre de colonnes indiquées dans l'instruction SELECT. Assurez-vous que les types de données
sont compatibles. Ajustez la position des variables par rapport aux colonnes. Vous pouvez également
définir un enregistrement pour le curseur et le référencer dans la clause FETCH INTO. Enfin,
effectuez un test afin de déterminer si le curseur contient des lignes. Si l'instruction FETCH ne
renvoie aucune valeur, il n'y a plus de lignes à traiter dans l'ensemble actif et aucune erreur n'est
enregistrée.

DECLARE
v_lname employees.last_name%TYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_empno, v_lname;
EXIT WHEN c_emp_cursor%NOTFOUND;

END LOOP;
END;
/
Extraire des données du curseur (suite)

Notez qu'une boucle simple est utilisée pour extraire (fetch) toutes les lignes. En outre,
l'attribut de curseur %NOTFOUND est utilisé pour tester la condition de sortie. La sortie
générée par l'exécution du bloc PL/SQL se présente comme suit :

Fermer le curseur
...
LOOP
FETCH c_emp_cursor INTO empno, lname;
END LOOP;
CLOSE c_emp_cursor;
END;

/
Fermer le curseur
L'instruction CLOSE désactive le curseur, libère la zone de contexte et annule la définition de
l'ensemble actif. Fermez le curseur après avoir terminé le traitement de l'instruction FETCH.
Vous pouvez rouvrir le curseur si nécessaire. Un curseur ne peut être rouvert que s'il est
fermé. Si vous tentez d'extraire (fetch) des données à partir d'un curseur fermé, une exception
INVALID_CURSOR est générée.
Remarque : Bien qu'il soit possible de terminer le bloc PL/SQL sans fermer les curseurs,
prenez l'habitude de fermer les curseurs que vous déclarez explicitement, afin de libérer
les ressources.
Il existe une limite maximale quant au nombre de curseurs ouverts par session, lequel est
déterminé par le paramètre OPEN_CURSORS dans le fichier de paramètres de la base de
données. (OPEN_CURSORS = 50 par défaut)

Curseurs et enregistrements
Traitez les lignes de l'ensemble actif en extrayant les valeurs

pour les placer dans un enregistrement PL/SQL.
DECLARE
v_emp_record c_emp_cursor%ROWTYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_emp_record;

DBMS_OUTPUT.PUT_LINE( v_emp_record.employee_id
||' '||v_emp_record.last_name);
END LOOP;
CLOSE c_emp_cursor;
END;
Curseurs et enregistrements
Vous venez de voir comment définir des enregistrements possédant la structure des colonnes
d'une table. Vous pouvez également définir un enregistrement en fonction de la liste précise
des colonnes d'un curseur explicite. Cela est très pratique pour traiter les lignes de l'ensemble
actif, car il vous suffit de placer le résultat de l'extraction dans l'enregistrement. Ainsi, les
valeurs de la ligne sont chargées directement dans les champs correspondants de
l'enregistrement.

Boucles FOR de curseur
Syntaxe :
FOR record_name IN cursor_name LOOP
statement1;
statement2;
. . .
END LOOP;
• La boucle FOR de curseur simplifie le traitement des

curseurs explicites.

• Des opérations d'ouverture, d'extraction, de sortie
et de fermeture ont lieu de manière implicite.
• L'enregistrement est déclaré implicitement.

Vous avez appris à extraire (fetch) des données à partir de curseurs à l'aide de boucles
simples. Vous allez maintenant apprendre à utiliser une boucle FOR de curseur, laquelle traite
les lignes dans un curseur explicite. Il s'agit d'un raccourci car le curseur est ouvert et une
ligne est extraite une seule fois à chaque itération de la boucle. Celle-ci arrête son exécution
lorsque la dernière ligne est traitée et le curseur est fermé automatiquement. La boucle s'arrête
d'elle-même à la fin de l'itération après l'extraction de la dernière ligne.
Dans la syntaxe :
record_name Nom de l'enregistrement déclaré implicitement.
cursor_name Identificateur PL/SQL du curseur déclaré précédemment.
Règles
• Ne déclarez pas l'enregistrement qui contrôle la boucle. Sa déclaration est implicite.
• Testez les attributs de curseur durant l'exécution de la boucle, si nécessaire.
• Le cas échéant, indiquez les paramètres du curseur entre parenthèses, à la suite du nom
de celui-ci dans l'instruction FOR.

DECLARE
BEGIN
FOR emp_record IN c_emp_cursor
LOOP
DBMS_OUTPUT.PUT_LINE( emp_record.employee_id
||' ' ||emp_record.last_name);

END LOOP;
END;
/
Boucles FOR de curseur (suite)

L'exemple ayant servi à présenter l'utilisation d'une boucle simple pour extraire (fetch) des
données de curseur est réécrite afin d'utiliser la boucle FOR de curseur.
emp_record est l'enregistrement déclaré implicitement. Vous pouvez accéder aux données
extraites avec cet enregistrement implicite (comme illustré dans la diapositive ci-dessus).
Remarquez qu'aucune variable n'est déclarée pour contenir les données extraites à l'aide de la
clause INTO. Le code ne comprend pas d'instructions OPEN et CLOSE pour ouvrir et fermer
le curseur.

Attributs d'un curseur explicite
Utilisez des attributs de curseur explicite pour obtenir des

informations d'état sur un curseur.
Attribut Type Description
%ISOPEN Booléen Prend la valeur TRUE si le curseur est ouvert
%NOTFOUND Booléen Prend la valeur TRUE si la dernière extraction

ne renvoie pas de ligne
%FOUND Booléen Prend la valeur TRUE si la dernière extraction
renvoie une ligne ; complément de

%NOTFOUND
%ROWCOUNT Nombre Prend la valeur correspondant au nombre total

de lignes renvoyées jusqu'à présent
Attributs d'un curseur explicite

Comme pour les curseurs implicites, il existe quatre attributs permettant d'obtenir des
informations d'état sur un curseur. Une fois associés au nom de la variable de curseur, ces
attributs renvoient des informations utiles sur l'exécution d'une instruction de manipulation de
curseur.
Remarque : Vous ne pouvez pas référencer des attributs de curseur directement dans une
instruction SQL.

Attribut %ISOPEN
• Extrayez les lignes uniquement lorsque le curseur est

ouvert.
• Utilisez l'attribut de curseur %ISOPEN avant de réaliser
une extraction pour déterminer si le curseur est ouvert.
Exemple :
IF NOT c_emp_cursor%ISOPEN THEN

OPEN c_emp_cursor;
END IF;

LOOP
FETCH c_emp_cursor...
Attribut %ISOPEN
• Vous ne pouvez extraire des lignes que lorsque le curseur est ouvert. Utilisez l'attribut de
curseur %ISOPEN pour déterminer si le curseur est ouvert.
• Procédez à l'extraction des lignes à l'aide d'une boucle. Utilisez des attributs de curseur
pour déterminer dans quels cas la sortie de la boucle doit s'effectuer.
• Utilisez l'attribut de curseur %ROWCOUNT pour effectuer les tâches suivantes :
- Traiter un nombre exact de lignes
- Extraire des lignes avec une boucle et déterminer dans quels cas la sortie de la
boucle doit s'effectuer
Remarque : %ISOPEN renvoie l'état du curseur (TRUE s'il est ouvert et FALSE s'il est
fermé).

%ROWCOUNT et %NOTFOUND : Exemple
DECLARE
CURSOR c_emp_cursor IS SELECT employee_id,
last_name FROM employees;
v_emp_record c_emp_cursor%ROWTYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_emp_record;
EXIT WHEN c_emp_cursor%ROWCOUNT > 10 OR
c_emp_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( v_emp_record.employee_id
||' '||v_emp_record.last_name);

END LOOP;
CLOSE c_emp_cursor;
END;
/
%ROWCOUNT et %NOTFOUND : Exemple

L'exemple de la diapositive ci-dessus extrait les dix premiers employés, un par un. Il illustre
l'utilisation des attributs %ROWCOUNT et %NOTFOUND pour les conditions de sortie d'une
boucle. La sortie générée par le bloc PL/SQL se présente comme suit :

Boucles FOR de curseur utilisant
des sous-interrogations
Il n'est pas nécessaire de déclarer le curseur.

Exemple :
BEGIN
FOR emp_record IN (SELECT employee_id, last_name
FROM employees WHERE department_id =30)
LOOP
DBMS_OUTPUT.PUT_LINE( emp_record.employee_id
||' '||emp_record.last_name);
END LOOP;

END;
/
Boucles FOR de curseur utilisant des sous-interrogations

Notez que ce bloc PL/SQL ne comporte pas de section déclarative. La différence entre les
boucles FOR de curseur qui utilisent des sous-interrogations et la boucle FOR de curseur
réside dans la déclaration du curseur. Si vous écrivez des boucles FOR de curseur à l'aide de
sous-interrogations, il n'est pas nécessaire de déclarer le curseur dans la section déclarative.
Vous devez indiquer dans la boucle proprement dite l'instruction SELECT qui détermine
l'ensemble actif.
L'exemple utilisé pour illustrer la boucle FOR de curseur est réécrit dans la diapositive
ci-dessus pour illustrer la boucle FOR de curseur avec des sous-interrogations.
Remarque : Vous ne pouvez pas référencer des attributs de curseur explicite si vous utilisez
une sous-interrogation dans une boucle FOR de curseur, car vous ne pouvez pas affecter un
nom explicite au curseur.

Curseurs avec paramètres
Syntaxe :
CURSOR cursor_name
[(parameter_name datatype, ...)]
IS
select_statement;
• Transmettez des paramètres au curseur au moment de
son ouverture et de l'exécution de l'interrogation.
• Ouvrez un curseur explicite à plusieurs reprises, en
renvoyant un ensemble actif différent à chaque fois.

OPEN cursor_name(parameter_value,.....) ;

Vous pouvez transmettre des paramètres à un curseur. Autrement dit, vous pouvez ouvrir et
fermer un curseur explicite à plusieurs reprises dans un bloc, en renvoyant un ensemble actif
différent à chaque fois. A chaque exécution, le curseur précédent est fermé puis rouvert avec
un nouvel ensemble de paramètres.
A chaque paramètre formel dans la déclaration du curseur doit être associé un paramètre réel
dans l'instruction OPEN. Les types de données des paramètres sont les mêmes que ceux des
variables scalaires, mais aucune taille ne leur est affectée. Les noms des paramètres servent de
références dans l'expression d'interrogation du curseur.
Dans la syntaxe :
cursor_name Identificateur PL/SQL du curseur déclaré.
parameter_name Nom d'un paramètre.
datatype Type de données scalaire du paramètre.
select_statement Instruction SELECT sans clause INTO.
Le paramétrage de curseur n'offre pas d'autre fonctionnalité. Il permet simplement d'indiquer

facilement et clairement les valeurs d'entrée. Cela s'avère très utile lorsqu'un même curseur est
référencé plusieurs fois.

DECLARE
CURSOR c_emp_cursor (deptno NUMBER) IS
SELECT employee_id, last_name
FROM employees
WHERE department_id = deptno;
...
BEGIN
OPEN c_emp_cursor (10);
...

CLOSE c_emp_cursor;
OPEN c_emp_cursor (20);
...
Curseurs avec paramètres (suite)

Les types de données des paramètres sont les mêmes que ceux des variables scalaires, mais
aucune taille ne leur est affectée. Les noms des paramètres servent de références dans
l'interrogation du curseur. Dans l'exemple suivant, un curseur est déclaré et défini avec un
paramètre :
DECLARE
CURSOR c_emp_cursor(deptno NUMBER) IS SELECT ...
Les instructions suivantes permettent d'ouvrir le curseur et de renvoyer des ensembles actifs
différents :
OPEN c_emp_cursor(10);
OPEN c_emp_cursor(20);
Vous pouvez transmettre des paramètres au curseur utilisé dans une boucle FOR de curseur :
DECLARE
CURSOR c_emp_cursor(p_deptno NUMBER, p_job VARCHAR2)IS
SELECT ...
BEGIN
FOR emp_record IN c_emp_cursor(10, 'Sales') LOOP ...

Clause FOR UPDATE
Syntaxe :
SELECT ...
FROM ...
FOR UPDATE [OF column_reference][NOWAIT | WAIT n];
• Utilisez un verrouillage explicite pour interdire l'accès

aux autres sessions pendant la durée d'une transaction.
• Verrouillez les lignes avant la mise à jour ou la suppression.

Clause FOR UPDATE

S'il existe plusieurs sessions pour une même base de données, il se peut que les lignes d'une
table particulière aient été mises à jour après l'ouverture du curseur. Vous ne voyez les
données mises à jour que lorsque vous rouvrez le curseur. Il est donc préférable de placer des
verrous sur les lignes avant de les mettre à jour ou de les supprimer. Vous pouvez verrouiller
les lignes avec la clause FOR UPDATE dans l'interrogation du curseur.
Dans la syntaxe :
column_reference Colonne de la table sur laquelle l'interrogation est
exécutée (une liste de colonnes peut également être
utilisée).
NOWAIT Renvoie une erreur du serveur Oracle si les lignes
sont verrouillées par une autre session.
La clause FOR UPDATE est la dernière clause d'une instruction SELECT. Elle est donc placée
après la clause ORDER BY, le cas échéant. Lorsque plusieurs tables sont interrogées,
l'utilisation de la clause FOR UPDATE permet de limiter le verrouillage des lignes à des tables
particulières. FOR UPDATE OF col_name(s) verrouille uniquement les lignes des tables
contenant col_name(s).

Clause FOR UPDATE (suite)
L'instruction SELECT ... FOR UPDATE identifie les lignes qui doivent être mises à jour ou
supprimées, puis verrouille chaque ligne de l'ensemble de résultats. Cela s'avère utile lorsque vous
souhaitez qu'une mise à jour soit basée sur les valeurs existantes d'une ligne. Dans ce cas, vous devez
vous assurer que cette ligne n'est pas modifiée par une autre session avant la mise à jour.
Le mot-clé facultatif NOWAIT indique au serveur Oracle de ne pas attendre si les lignes demandées
sont verrouillées par un autre utilisateur. Le programme reprend immédiatement le contrôle. Il peut
ainsi effectuer d'autres travaux avant de réessayer d'obtenir le verrouillage. Si vous omettez le
mot-clé NOWAIT, le serveur Oracle attend que les lignes soient disponibles.
Exemple :
DECLARE
SELECT employee_id, last_name, FROM employees
WHERE department_id = 80 FOR UPDATE OF salary NOWAIT;

...
Si le serveur Oracle ne peut pas obtenir les verrous sur les lignes demandées dans une opération
SELECT FOR UPDATE, il attend indéfiniment. Utilisez le mot-clé NOWAIT pour gérer ces situations.
Si les lignes sont verrouillées par une autre session et que vous avez indiqué le mot-clé NOWAIT,
l'ouverture du curseur provoque une erreur. Vous pouvez essayer d'ouvrir le curseur ultérieurement.
Vous pouvez utiliser WAIT plutôt que NOWAIT, indiquer le nombre de secondes pendant lesquelles
attendre et déterminer si les lignes sont déverrouillées. Si les lignes sont toujours verrouillées après
n secondes, une erreur est renvoyée.
Il n'est pas indispensable que la clause FOR UPDATE OF fasse référence à une colonne, mais cela est
recommandé pour une meilleure lisibilité et une maintenance simplifiée.

Clause WHERE CURRENT OF
Syntaxe :
WHERE CURRENT OF cursor ;
• Utilisez des curseurs pour mettre à jour ou supprimer
la ligne en cours.
• Incluez la clause FOR UPDATE dans l'interrogation
du curseur pour verrouiller au préalable les lignes.
• Utilisez la clause WHERE CURRENT OF pour référencer
la ligne en cours à partir d'un curseur explicite.

UPDATE employees
SET salary = ...
WHERE CURRENT OF c_emp_cursor;
Clause WHERE CURRENT OF

La clause WHERE CURRENT OF est utilisée conjointement avec la clause FOR UPDATE afin
de faire référence à la ligne en cours dans un curseur explicite. La clause WHERE CURRENT
OF est utilisée dans l'instruction UPDATE ou DELETE, tandis que la clause FOR UPDATE est
définie dans la déclaration du curseur. Vous pouvez utiliser la combinaison pour mettre à jour
et supprimer la ligne actuelle de la table de base de données correspondante. Cela vous permet
d'effectuer des mises à jour et des suppressions sur cette ligne, sans avoir à référencer
explicitement le row ID (adresse de ligne). Vous devez inclure la clause FOR UPDATE dans
l'interrogation du curseur afin que les lignes soient verrouillées lors de l'ouverture (OPEN).
Dans la syntaxe :
cursor Nom d'un curseur déclaré (le curseur doit avoir été déclaré avec la clause
FOR UPDATE).

Curseurs contenant des sous-interrogations
Exemple :
DECLARE
CURSOR my_cursor IS
SELECT t1.department_id, t1.department_name,
t2.staff
FROM departments t1, (SELECT department_id,
COUNT(*) AS staff
FROM employees
GROUP BY department_id) t2

WHERE t1.department_id = t2.department_id
AND t2.staff >= 3;
...
Curseurs contenant des sous-interrogations

Une sous-interrogation est une interrogation (généralement placée entre parenthèses) qui
apparaît dans une autre instruction SQL. Lors de son exécution, elle fournit une valeur ou un
ensemble de valeurs à l'interrogation externe. Les sous-interrogations sont souvent utilisées
dans la clause WHERE d'une instruction SELECT. Elles peuvent également être utilisées dans
la clause FROM, fournissant ainsi une source de données temporaire à l'interrogation.
Dans l'exemple présenté, la sous-interrogation crée une source de données comprenant les
numéros de département et le nombre d'employés de chaque département (alias STAFF).
L'alias de table t2 fait référence à cette source de données temporaire dans la clause FROM.
Lorsque le curseur est ouvert, l'ensemble actif contient le numéro, le nom et le nombre total
d'employés de tous les départements comptant au moins trois employés.

Synthèse

• différencier les types de curseur :
– curseurs implicites : utilisés pour toutes les instructions LMD
et les interrogations monolignes
– curseurs explicites : utilisés pour les interrogations portant sur
zéro, une ou plusieurs lignes
• créer et gérer des curseurs explicites
• utiliser des boucles simples et des boucles FOR de curseur
pour gérer plusieurs lignes dans les curseurs

• évaluer l'état du curseur en utilisant des attributs de curseur
• utiliser les clauses FOR UPDATE et WHERE CURRENT OF afin
de mettre à jour ou de supprimer la ligne extraite actuelle
Synthèse
Le serveur Oracle utilise des zones de travail pour exécuter les instructions SQL et assurer le
stockage des informations relatives au traitement. Vous pouvez utiliser une structure PL/SQL
appelée curseur pour nommer une zone de travail et accéder aux informations qu'elle
contient. Il existe deux types de curseur : les curseurs implicites et les curseurs explicites.
Le compilateur PL/SQL déclare implicitement un curseur pour toutes les instructions SQL de
manipulation de données, y compris pour les interrogations ne renvoyant qu'une seule ligne.
Pour les interrogations renvoyant plusieurs lignes, vous pouvez explicitement déclarer un
curseur afin de traiter les lignes individuellement.
Les curseurs explicites et les variables de curseur admettent quatre attributs : %FOUND,
%ISOPEN %NOTFOUND et %ROWCOUNT. Une fois associés au nom d'une variable de curseur,
ces attributs renvoient des informations utiles sur l'exécution d'une instruction SQL. Vous
pouvez utiliser les attributs de curseur dans les instructions procédurales, mais pas dans les
instructions SQL.
Utilisez des boucles simples ou des boucles FOR de curseur pour opérer sur les différentes
lignes extraites par un curseur. Si vous utilisez des boucles simples, vous devez ouvrir,
extraire (fetch) et fermer le curseur. En revanche, les boucles FOR de curseur effectuent ces
opérations implicitement. Lorsque vous procédez à la mise à jour ou à la suppression de
lignes, verrouillez ces lignes à l'aide d'une clause FOR UPDATE. De la sorte, les données que
vous utilisez ne risquent pas d'être mises à jour par une autre session après l'ouverture du
curseur. Utilisez une clause WHERE CURRENT OF avec la clause FOR UPDATE afin de
référencer la ligne actuelle extraite par le curseur.


• Déclarer et utiliser des curseurs explicites pour interroger
les lignes d'une table
• Utiliser une boucle FOR de curseur
• Appliquer des attributs de curseur pour contrôler l'état du
curseur
• Déclarer et utiliser des curseurs avec des paramètres
• Utiliser les clauses FOR UPDATE et WHERE CURRENT OF

Dans cet exercice, vous allez mettre en pratique vos connaissances sur les curseurs pour traiter
un certain nombre de lignes à partir d'une table. Les résultats seront ensuite utilisés pour
remplir une autre table à l'aide d'une boucle FOR de curseur. Enfin, vous écrirez un curseur
avec des paramètres.

Exercice 7
1. Créez un bloc PL/SQL qui détermine les n salaires les plus élevés parmi les employés.
a. Exécutez le script lab_07_01.sql afin de créer une nouvelle table nommée
top_salaries, pour le stockage des salaires des employés.
b. Dans la section déclarative, déclarez une variable v_num de type NUMBER contenant un
nombre n qui représente le nombre n d'employés ayant les salaires les plus élevés dans la
table employees. Par exemple, pour afficher les cinq salaires les plus élevés, entrez 5.
Déclarez une autre variable sal de type employees.salary. Déclarez le curseur
c_emp_cursor qui extrait les salaires des employés par ordre décroissant.
c. Dans la section exécutable, ouvrez la boucle, extrayez les n salaires les plus élevés et
insérez-les dans la table top_salaries. Vous pouvez utiliser une boucle simple pour
opérer sur les données. Essayez également d'utiliser les attributs %ROWCOUNT et %FOUND
pour la condition de sortie.
d. Après l'insertion dans la table top_salaries, affichez les lignes avec une instruction

SELECT. La sortie illustrée présente les cinq salaires les plus élevés de la table
employees.
e. Testez les cas particuliers tels que v_num = 0 ou v_num supérieur au nombre d'employés
de la table employees. Videz la table top_salaries après chaque test.
2. Créez un bloc PL/SQL pour effectuer les tâches suivantes :
a. Dans la section déclarative, déclarez une variable v_deptno de type NUMBER et
affectez-lui la valeur contenant le numéro du département.
b. Déclarez un curseur nommé c_emp_cursor qui extrait les valeurs last_name,
salary et manager_id pour les employés qui travaillent dans le département indiqué
par v_deptno.

Exercice 7 (suite)
c. Dans la section exécutable, utilisez la boucle FOR de curseur pour opérer sur les données
extraites. Si le salaire de l'employé est inférieur à 5 000 et que l'ID du manager est 101 ou
124, affichez le message suivant : <<last_name>> Due for a raise. Dans le cas
contraire, affichez le message suivant : <<last_name>> Not due for a raise.
d. Testez les cas suivants à l'aide du bloc PL/SQL :
Numéro de Message
département
10 Whalen Due for a raise
20 Hartstein Not Due for a raise
Fay Not Due for a raise
50 Weiss Not Due for a raise
Fripp Not Due for a raise

Kaufling Not Due for a raise
Vollman Not Due for a raise. . .
. . .
OConnell Due for a raise
Grant Due for a raise
80 Russell Not Due for a raise
Partners Not Due for a raise
Errazuriz Not Due for a raise
Cambrault Not Due for a raise
. . .
Livingston Not Due for a raise
Johnson Not Due for a raise

Exercice 7 (suite)
3. Ecrivez un bloc PL/SQL qui déclare et utilise des curseurs avec des paramètres.
Dans une boucle, utilisez un curseur pour extraire, à partir de la table departments, le
numéro et le nom de tous les départements pour lesquels la valeur department_id est
inférieure à 100. Transmettez le numéro du département à un autre curseur en tant que
paramètre pour extraire de la table employees les informations (nom de famille, poste, date
d'embauche et salaire) concernant les employés travaillant dans ce département et dont la
valeur employee_id est inférieure à 120.
a. Dans la section déclarative, déclarez un curseur nommé dept_cursor afin d'extraire les
valeurs department_id et department_name pour les départements dont la valeur
department_id est inférieure à 100. Triez le résultat en fonction de la valeur
department_id.
b. Déclarez un autre curseur nommé emp_cursor, qui accepte le numéro de département
comme paramètre et qui extrait les valeurs last_name, job_id, hire_date et

salary des employés dont la valeur employee_id est inférieure à 120 et qui
travaillent dans ce département.
c. Déclarez des variables contenant les valeurs extraites de chaque curseur. Utilisez l'attribut
%TYPE dans la déclaration des variables.
d. Ouvrez dept_cursor, utilisez une boucle simple et extrayez les valeurs dans les
variables déclarées. Affichez le numéro et le nom du département.
e. Pour chaque département, ouvrez emp_cursor en transmettant le numéro de
département actuel comme paramètre. Ouvrez une autre boucle et extrayez les valeurs de
emp_cursor dans des variables, puis affichez tous les détails extraits de la table
employees.
Remarque : Vous pouvez afficher une ligne après avoir affiché les détails de chaque
département. Utilisez les attributs appropriés pour la condition de sortie. Par ailleurs, avant
d'ouvrir le curseur, déterminez si un curseur est déjà ouvert.
f. Fermez toutes les boucles et tous les curseurs, puis terminez la section exécutable.
Exécutez le script.

Exercice 7 (suite)
Le résultat est présenté ci-après.


Traiter les exceptions

Objectifs

• définir des exceptions PL/SQL
• reconnaître les exceptions non gérées
• répertorier et utiliser les différents types de gestionnaire
d'exceptions PL/SQL
• intercepter les erreurs non prédéfinies
• décrire l'effet de la propagation des exceptions dans des
blocs imbriqués

• personnaliser les messages d'exception PL/SQL
But du chapitre
Vous avez appris à écrire des blocs PL/SQL contenant une section déclarative et une section
exécutable. Tout le code SQL et PL/SQL à exécuter est écrit dans le bloc exécutable.
Jusqu'à présent, il a été considéré que le code fonctionnait correctement dès lors que les
erreurs détectées au moment de la compilation étaient corrigées. Cependant, le code peut
provoquer des erreurs non prévues lors de l'exécution. Dans ce chapitre, vous allez apprendre
à gérer ce type d'erreur dans un bloc PL/SQL.

Exemple d'exception
DECLARE
v_lname VARCHAR2(15);
BEGIN
SELECT last_name INTO v_lname
FROM employees
WHERE first_name='John';
DBMS_OUTPUT.PUT_LINE ('John''s last name is :'
||v_lname);
END;

Exemple d'exception
Examinez l'exemple de la diapositive ci-dessus. Le code ne présente aucune erreur de syntaxe,
ce qui veut dire que vous devez pouvoir exécuter avec succès le bloc anonyme. L'instruction
SELECT du bloc extrait le nom de famille de John. Lorsque vous exécutez le code, vous
obtenez la sortie ci-après :
Le code ne fonctionne pas comme prévu. Vous aviez prévu que l'instruction SELECT
n'extrairait qu'une seule ligne. Or, elle en a extrait plusieurs. Ce type d'erreur qui se produit
lors de l'exécution est appelé une exception. Lorsqu'une exception se produit, l'exécution du
bloc PL/SQL prend fin. Vous pouvez gérer ce type d'exception dans le bloc PL/SQL.

Exemple d'exception
DECLARE
v_lname VARCHAR2(15);
BEGIN
SELECT last_name INTO v_lname
FROM employees
WHERE first_name='John';
DBMS_OUTPUT.PUT_LINE ('John''s last name is :'
||v_lname);
EXCEPTION
WHEN TOO_MANY_ROWS THEN

DBMS_OUTPUT.PUT_LINE (' Your select statement
retrieved multiple rows. Consider using a
cursor.');
END;
/
Exemple d'exception (suite)

Vous avez écrit des blocs PL/SQL avec une section déclarative (commençant par le mot-clé
DECLARE) et une section exécutable (commençant et se terminant respectivement par les
mots-clés BEGIN et END). Pour le traitement des exceptions, vous incluez une autre section
(facultative), appelée section de traitement des exceptions. Elle commence par le mot-clé
EXCEPTION. Si elle est présente, il s'agit de la dernière section d'un bloc PL/SQL. Dans la
diapositive ci-dessus, examinez la section EXCEPTION incluse dans le code. Ne tenez pas
compte de la syntaxe et des instructions. Celles-ci seront abordées ultérieurement dans le
chapitre.
Le code de la diapositive précédente a été réécrit afin de traiter l'exception qui s'est produite.
La sortie du code est la suivante :
Cette fois-ci, l'exécution du programme PL/SQL ne s'interrompt pas brutalement. Lorsque

l'exception est générée, le contrôle passe à la section de traitement des exceptions et toutes les
instructions de cette section sont exécutées. L'exécution du bloc PL/SQL se termine
normalement.

Traiter les exceptions en langage PL/SQL
• Une exception est une erreur PL/SQL détectée pendant

l'exécution du programme.
• Une exception peut être générée :
– implicitement par le serveur Oracle
– explicitement par le programme
• Une exception peut être traitée :
– par interception à l'aide d'un gestionnaire
– par propagation vers l'environnement appelant

Traiter les exceptions en langage PL/SQL

Une exception est une erreur PL/SQL générée pendant l'exécution d'un bloc. L'exécution d'un
bloc s'arrête toujours quand une exception PL/SQL est déclenchée. Cependant, vous pouvez
définir un gestionnaire d'exceptions afin de réaliser certaines opérations avant la fin du bloc.
Deux méthodes de déclenchement d'une exception
• Lorsqu'une erreur Oracle se produit, l'exception associée est déclenchée
automatiquement. Par exemple, si l'erreur ORA-01403 survient parce que l'instruction
SELECT n'a extrait aucune ligne de la base de données, l'exception NO_DATA_FOUND
est déclenchée par le programme PL/SQL. Ces erreurs sont converties en exceptions
prédéfinies.
• Selon les fonctionnalités métier implémentées par le programme, vous pouvez être
amené à générer explicitement une exception. Pour cela, vous insérez une instruction
RAISE dans le bloc. L'exception émise peut être soit définie par l'utilisateur, soit
prédéfinie. Il existe également certaines erreurs Oracle non prédéfinies. Il s'agit d'erreurs
Oracle standard. Vous pouvez déclarer explicitement des exceptions et les associer aux
erreurs Oracle non prédéfinies.

L'exception Interrompre
est-elle brutalement
interceptée ? Non l'exécution
Oui
L'exception Exécuter les Propager

est générée. instructions de la l'exception
section EXCEPTION
Interrompre
correctement
l'exécution

Intercepter une exception
Incluez une section EXCEPTION dans votre programme PL/SQL afin d'intercepter les
exceptions. Si une exception se déclenche dans la section exécutable du bloc, le programme
effectue un branchement sur le gestionnaire d'exceptions défini dans la section de traitement
des exceptions du bloc. Si le programme PL/SQL traite convenablement l'exception, celle-ci
n'est pas propagée au bloc englobant ou à l'environnement appelant. Le bloc PL/SQL est
arrêté correctement.
Propager une exception
Si une exception se produit dans la section exécutable du bloc et qu'il n'y a pas de gestionnaire
d'exceptions correspondant, le bloc PL/SQL aboutit à une erreur et l'exception est propagée au
bloc englobant ou à l'environnement appelant. L'environnement appelant peut être n'importe
quelle application (telle que SQL*Plus qui appelle le programme PL/SQL).

Types d'exception
}
• Exception prédéfinie du serveur Oracle Exception
• Exception non prédéfinie du serveur Oracle déclenchée
implicitement
Exception
• Exception définie par l'utilisateur déclenchée
explicitement

Types d'exception
Il existe trois types d'exception.
Exception Description Gestion

Erreur prédéfinie du L'une des vingt erreurs les Il n'est pas nécessaire de déclarer ces
serveur Oracle plus fréquentes en langage exceptions. Elles sont prédéfinies par le
PL/SQL serveur Oracle et sont générées
implicitement.
Erreur non prédéfinie Toute autre erreur standard Vous devez déclarer ces exceptions
du serveur Oracle du serveur Oracle dans la section déclarative. Le serveur
Oracle déclenche l'erreur implicitement
et vous pouvez intercepter l'erreur dans
le gestionnaire d'exceptions.
Erreur définie par Condition considérée Déclarez ces exceptions dans la section
l'utilisateur comme anormale par le déclarative et déclenchez-les
développeur explicitement.
Remarque : Certains outils applicatifs dotés d'une interface PL/SQL côté client (par exemple
Oracle Developer Forms) possèdent leurs propres exceptions.

Intercepter les exceptions
Syntaxe :
EXCEPTION
WHEN exception1 [OR exception2 . . .] THEN
statement1;
statement2;
. . .
[WHEN exception3 [OR exception4 . . .] THEN
statement1;
statement2;

. . .]
[WHEN OTHERS THEN
statement1;
statement2;
. . .]
Intercepter les exceptions

Vous pouvez intercepter n'importe quelle erreur en insérant le gestionnaire correspondant
dans la section de traitement des exceptions du bloc PL/SQL. Chaque gestionnaire
d'exceptions contient une clause WHEN, qui définit le nom de l'exception, suivi d'une séquence
d'instructions à exécuter lorsque cette exception est déclenchée. Vous pouvez inclure un
nombre quelconque de gestionnaires dans une section EXCEPTION pour gérer des exceptions
spécifiques. En revanche, il n'est pas possible d'associer plusieurs gestionnaires à une même
exception.
Dans la syntaxe :
exception Nom standard d'une exception prédéfinie ou d'une exception définie
par l'utilisateur dans la section déclarative.
statement Constitué d'une ou de plusieurs instructions PL/SQL ou SQL.
OTHERS Clause facultative de traitement des exceptions qui intercepte toute
exception n'ayant pas été traitée explicitement.

Intercepter les exceptions (suite)

Gestionnaire d'exceptions WHEN OTHERS
La section de traitement des exceptions intercepte seulement les exceptions qui sont définies. Les
autres exceptions ne sont pas interceptées sauf si vous utilisez le gestionnaire d'exceptions OTHERS.
Ce dernier permet d'intercepter les exceptions qui n'ont pas encore été traitées. S'il est utilisé,
OTHERS doit être le dernier gestionnaire d'exceptions défini.
WHEN NO_DATA_FOUND THEN
statement1;
...
WHEN TOO_MANY_ROWS THEN
statement1;
...
WHEN OTHERS THEN
statement1;

Examinons l'exemple précédent. Si l'exception NO_DATA_FOUND est générée par le programme, les
instructions du gestionnaire correspondant sont exécutées. Si l'exception TOO_MANY_ROWS est
générée, les instructions du gestionnaire correspondant sont exécutées. Si d'autres exceptions sont
générées, les instructions du gestionnaire d'exceptions OTHERS sont exécutées.
Le gestionnaire OTHERS intercepte toutes les exceptions restantes. Certains outils Oracle ont leurs
propres exceptions prédéfinies que vous pouvez déclencher pour provoquer certains événements dans
une application. Le gestionnaire OTHERS permet également d'intercepter ces exceptions.

Règles d'interception des exceptions
• Le mot-clé EXCEPTION débute la section de traitement

des exceptions.
• Plusieurs gestionnaires d'exceptions sont autorisés.
• Un seul gestionnaire est traité avant la sortie du bloc.
• WHEN OTHERS est la dernière clause.

Règles d'interception des exceptions

• Commencez la section de traitement des exceptions du bloc par le mot-clé EXCEPTION.
• Définissez plusieurs gestionnaires d'exceptions pour un bloc, chacun ayant sa propre
séquence d'actions.
• Lorsqu'une exception se produit, le programme PL/SQL n'exécute qu'un seul gestionnaire
avant de quitter le bloc.
• Placez la clause OTHERS après toutes les autres clauses de traitement des exceptions.
• Vous ne pouvez utiliser qu'une seule clause OTHERS.
• Les exceptions ne doivent pas figurer dans les instructions d'affectation ni dans les
instructions SQL.

Intercepter les erreurs prédéfinies

du serveur Oracle
• Utilisez le nom prédéfini à l'intérieur du sous-programme
de traitement des exceptions.
• Exemples d'exceptions prédéfinies :
– NO_DATA_FOUND
– TOO_MANY_ROWS
– INVALID_CURSOR
– ZERO_DIVIDE
– DUP_VAL_ON_INDEX

Intercepter les erreurs prédéfinies du serveur Oracle

Pour intercepter une erreur prédéfinie du serveur Oracle, indiquez son nom dans le
sous-programme correspondant de traitement des exceptions.
Pour connaître la liste complète des exceptions prédéfinies, reportez-vous au manuel PL/SQL
User's Guide and Reference.
Remarque : Le langage PL/SQL déclare les exceptions prédéfinies dans le package
STANDARD.

Exceptions prédéfinies
Nom de l'exception Code Description

d'erreur
du serveur
Oracle
ACCESS_INTO_NULL ORA- Tentative d'affectation de valeurs aux
06530 attributs d'un objet non initialisé.
CASE_NOT_FOUND ORA- Aucun des choix proposés dans les clauses
06592 WHEN d'une instruction CASE n'est
sélectionné, et il n'existe pas de clause
ELSE.
COLLECTION_IS_NULL ORA- Tentative d'application de méthodes
06531 spécifiques aux ensembles (collections)
autres que EXISTS à une table imbriquée

ou à un tableau de taille variable
(VARRAY) non initialisé.
CURSOR_ALREADY_OPEN ORA- Tentative d'ouverture d'un curseur déjà
06511 ouvert.
DUP_VAL_ON_INDEX ORA- Tentative d'insertion d'un doublon.
00001
INVALID_CURSOR ORA- Opération non valide sur un curseur.
01001
INVALID_NUMBER ORA- Echec de la conversion d'une chaîne de
01722 caractères en valeur numérique.
LOGIN_DENIED ORA- Connexion au serveur Oracle à l'aide d'un
01017 nom utilisateur ou d'un mot de passe non
valide.
NO_DATA_FOUND ORA- Pas de données renvoyées par une
01403 instruction monoligne SELECT.
NOT_LOGGED_ON ORA- Exécution d'un appel de base de données
01012 par le programme PL/SQL alors
qu'aucune connexion n'est établie avec le
serveur Oracle.
PROGRAM_ERROR ORA- Problème interne au programme PL/SQL.
06501
ROWTYPE_MISMATCH ORA- Incompatibilité entre les types de données
06504 renvoyés par la variable du curseur hôte et
la variable du curseur PL/SQL lors d'une
affectation.

Exceptions prédéfinies (suite)
Nom de l'exception Code Description

d'erreur
du
serveur
Oracle
STORAGE_ERROR ORA- Mémoire insuffisante pour exécuter le code
06500 PL/SQL ou corruption de la mémoire.
SUBSCRIPT_BEYOND_COUNT ORA- Référence à un élément d'une table
06533 imbriquée ou d'un VARRAY via un numéro
d'index supérieur au nombre d'éléments
contenus dans l'ensemble.
SUBSCRIPT_OUTSIDE_LIMIT ORA- Référence à un élément d'une table
06532 imbriquée ou d'un VARRAY via un numéro

d'index situé en dehors de la plage valide
(–1 par exemple).
SYS_INVALID_ROWID ORA- Echec de la conversion d'une chaîne de
01410 caractères en ROWID universel, car cette
chaîne ne représente pas un ROWID valide.
TIMEOUT_ON_RESOURCE ORA- Dépassement du délai d'attente d'une
00051 ressource par le serveur Oracle.
TOO_MANY_ROWS ORA- Renvoi de plusieurs lignes par une
01422 instruction monoligne SELECT.
VALUE_ERROR ORA- Erreur arithmétique, de conversion, de
06502 troncation ou de taille limite.
ZERO_DIVIDE ORA- Tentative de division par zéro.
01476

Intercepter les erreurs non prédéfinies

du serveur Oracle
Déclarer Associer Référencer
Section déclarative Section EXCEPTION
Nommer Utiliser PRAGMA Traiter l'exception

l'exception EXCEPTION_INIT déclenchée

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

Les exceptions non prédéfinies sont semblables aux exceptions prédéfinies, à ceci près
qu'elles ne sont pas définies en tant qu'exceptions PL/SQL dans le serveur Oracle. Il s'agit
d'erreurs Oracle standard. Vous créez des exceptions avec des erreurs Oracle standard à l'aide
de la fonction PRAGMA EXCEPTION_INIT. De telles exceptions sont appelées exceptions
non prédéfinies.
Pour pouvoir intercepter une erreur non prédéfinie du serveur Oracle, vous devez commencer
par la déclarer. Une fois l'exception déclarée, elle se déclenche implicitement. Dans PL/SQL,
la clause PRAGMA EXCEPTION_INIT indique au compilateur d'associer un nom d'exception
à un code d'erreur Oracle. Ainsi, vous pouvez faire référence à une exception interne par son
nom et y associer un gestionnaire spécifique.
Remarque : Le mot-clé PRAGMA (également appelé pseudo-instruction) indique que
l'instruction est destinée au compilateur et qu'elle n'est donc pas traitée lors de l'exécution du
bloc PL/SQL. Par ailleurs, ce mot-clé oblige le compilateur PL/SQL à interpréter chaque
occurrence de l'exception dans le bloc comme le code d'erreur du serveur Oracle lui étant
associé.

Erreur non prédéfinie
Intercepter l'erreur numéro –01400 du serveur Oracle

("impossible d'insérer la valeur NULL")
DECLARE
e_insert_excep EXCEPTION; 1
PRAGMA EXCEPTION_INIT(e_insert_excep, -01400); 2
BEGIN
INSERT INTO departments
(department_id, department_name) VALUES (280, NULL);
EXCEPTION 3
WHEN e_insert_excep THEN

DBMS_OUTPUT.PUT_LINE('INSERT OPERATION FAILED');
DBMS_OUTPUT.PUT_LINE(SQLERRM);
END;
/
Erreur non prédéfinie

1. Déclarez le nom de l'exception dans la section déclarative.
Syntaxe :
exception EXCEPTION;
Dans la syntaxe, exception est le nom de l'exception.
2. Utilisez la fonction PRAGMA EXCEPTION_INIT pour associer l'exception déclarée au
code d'erreur standard du serveur Oracle.
Syntaxe :
PRAGMA EXCEPTION_INIT(exception, error_number);
Dans la syntaxe, exception désigne l'exception précédemment déclarée et
error_number est un code d'erreur standard du serveur Oracle.
3. Faites référence à l'exception ainsi déclarée dans le code du gestionnaire d'exceptions
correspondant.
Exemple
L'exemple de la diapositive tente d'insérer la valeur NULL pour la colonne
department_name de la table departments. Cependant, l'opération échoue, car
department_name est une colonne NOT NULL. Observez la ligne suivante de l'exemple :
DBMS_OUTPUT.PUT_LINE(SQLERRM);
La fonction SQLERRM est utilisée pour extraire le message d'erreur. Vous en apprendrez plus
sur SQLERRM dans les diapositives qui suivent.

Fonctions d'interception des exceptions
• SQLCODE : Renvoie la valeur numérique du code d'erreur

• SQLERRM : Renvoie le message associé au code d'erreur


Lorsqu'une exception se produit, vous pouvez identifier le code ou le message d'erreur associé
en utilisant deux fonctions. D'après le message ou le code d'erreur, vous pouvez décider de
l'action à entreprendre.
SQLCODE renvoie le code d'erreur du serveur Oracle pour les exceptions internes. SQLERRM
renvoie le message associé au code d'erreur.
Fonction Description
SQLCODE Renvoie la valeur numérique du code d'erreur (que vous pouvez affecter
à une variable NUMBER).
SQLERRM Renvoie une donnée de type caractère contenant le message associé au
code d'erreur.
Valeurs SQLCODE : Exemples

Valeur SQLCODE Description
0 Aucune exception détectée.
1 Exception définie par l'utilisateur.
+100 Exception NO_DATA_FOUND.
nombre négatif Autre code d'erreur du serveur Oracle.

Exemple
DECLARE
error_code NUMBER;
error_message VARCHAR2(255);
BEGIN
...
EXCEPTION
...
WHEN OTHERS THEN
ROLLBACK;
error_code := SQLCODE ;

error_message := SQLERRM ;
INSERT INTO errors (e_user, e_date, error_code,
error_message) VALUES(USER,SYSDATE,error_code,
error_message);
END;
/
Fonctions d'interception des exceptions (suite)

Vous pouvez utiliser un ensemble de fonctions génériques pour identifier les exceptions
interceptées par le gestionnaire WHEN OTHERS. L'exemple de la diapositive ci-dessus illustre
l'affectation des valeurs de SQLCODE et de SQLERRM à des variables, puis l'utilisation de ces
variables dans une instruction SQL.
Vous ne pouvez pas utiliser SQLCODE ni SQLERRM directement dans une instruction SQL.
Vous devez affecter leur valeur à des variables locales, puis utiliser ces variables dans
l'instruction SQL, comme le montre l'exemple suivant :
DECLARE
err_num NUMBER;
err_msg VARCHAR2(100);
BEGIN
...
EXCEPTION
...
WHEN OTHERS THEN
err_num := SQLCODE;
err_msg := SUBSTR(SQLERRM, 1, 100);
INSERT INTO errors VALUES (err_num, err_msg);
END;
/

Intercepter les exceptions définies par l'utilisateur
Déclarer Déclencher Référencer
Section Section Section de traitement

déclarative exécutable des exceptions
Nommer Déclencher Traiter l'exception

l'exception explicitement déclenchée
l'exception via
l'instruction

RAISE

PL/SQL vous permet de définir vos propres exceptions en fonction des besoins de votre
application. Par exemple, vous pouvez inviter l'utilisateur à saisir un numéro de département.
Définissez une exception afin de gérer les conditions d'erreur dans les données d'entrée.
Déterminez si le numéro de département existe. S'il n'existe pas, vous pouvez générer
l'exception définie par l'utilisateur.
Les exceptions PL/SQL doivent être :
• déclarées dans la section déclarative d'un bloc PL/SQL,
• déclenchées explicitement avec l'instruction RAISE,
• traitées dans la section EXCEPTION.

DECLARE
v_deptno NUMBER := 500;
v_name VARCHAR2(20) := 'Testing';
e_invalid_department EXCEPTION;
1
BEGIN
UPDATE departments
SET department_name = v_name
IF SQL % NOTFOUND THEN
RAISE e_invalid_department; 2
END IF;

COMMIT;
EXCEPTION 3
WHEN e_invalid_department THEN
DBMS_OUTPUT.PUT_LINE('No such department id.');
END;
/
Intercepter les exceptions définies par l'utilisateur (suite)

Pour intercepter une exception définie par l'utilisateur, vous devez la déclarer et la déclencher
explicitement.
1. Déclarez le nom de l'exception définie par l'utilisateur dans la section déclarative.
Syntaxe :
exception EXCEPTION;
Dans la syntaxe, exception est le nom de l'exception.
2. Utilisez l'instruction RAISE pour déclencher explicitement l'exception dans la section
exécutable.
Syntaxe :
RAISE exception;
Dans la syntaxe, exception est le nom de l'exception précédemment déclarée.
3. Faites référence à l'exception ainsi déclarée dans le code du gestionnaire d'exceptions
correspondant.
Exemple
Le bloc de la diapositive ci-dessus met à jour la valeur department_name d'un
département. L'utilisateur entre le numéro du département et son nouveau nom. Si le numéro
de département indiqué n'existe pas, aucune ligne n'est mise à jour dans la table
departments. Une exception est déclenchée et un message avertit l'utilisateur qu'il a saisi
un numéro de département incorrect.
Remarque : Utilisez l'instruction RAISE seule dans un gestionnaire d'exceptions pour
générer de nouveau la même exception et la propager vers l'environnement appelant.

Propagation des exceptions d'un sous-bloc
DECLARE
. . .
e_no_rows exception;
e_integrity exception;
PRAGMA EXCEPTION_INIT (e_integrity, -2292);
BEGIN
FOR c_record IN emp_cursor LOOP
BEGIN
Des sous-blocs
SELECT ...
peuvent traiter UPDATE ...
une exception ou IF SQL%NOTFOUND THEN
la transmettre à RAISE e_no_rows;
un bloc englobant. END IF;

END;
END LOOP;
EXCEPTION
WHEN e_integrity THEN ...
WHEN e_no_rows THEN ...
END;
/
Propagation des exceptions d'un sous-bloc

Lorsqu'un sous-bloc traite une exception, il se termine normalement. L'exécution du
traitement se poursuit dans le bloc englobant juste après l'instruction END du sous-bloc.
Cependant, si une exception est déclenchée dans un programme PL/SQL mais qu'aucun
gestionnaire n'est prévu, celle-ci se propage dans les blocs englobants successifs jusqu'à ce
qu'elle trouve un gestionnaire. Si aucun de ces blocs ne peut traiter l'exception, il en résulte
une exception non traitée dans l'environnement hôte.
Lorsque l'exception se propage à un bloc englobant, les actions exécutables restantes de ce
bloc sont ignorées.
Un des avantages de ce comportement est que vous pouvez insérer des instructions nécessitant
un gestionnaire d'exceptions spécifique dans leur propre bloc, tout en laissant au bloc
englobant le traitement des exceptions plus générales.
Dans l'exemple de la diapositive ci-dessus, les exceptions (no_rows et integrity) sont
déclarées dans le bloc externe. Dans le bloc interne, lorsque l'exception no_rows est
déclenchée, le programme PL/SQL la recherche dans le sous-bloc. L'exception n'étant pas
traitée dans le sous-bloc, elle se propage vers le bloc externe où le programme PL/SQL trouve
le gestionnaire.

Procédure RAISE_APPLICATION_ERROR
Syntaxe :
raise_application_error (error_number,
message[, {TRUE | FALSE}]);
• Vous pouvez utiliser cette procédure pour générer

des messages d'erreur définis par l'utilisateur à partir
de sous-programmes stockés.
• Elle permet de signaler les erreurs à l'application et
d'éviter le renvoi d'exceptions non traitées.

Grâce à la procédure RAISE_APPLICATION_ERROR, générez de manière interactive une
exception prédéfinie en renvoyant un code et un message d'erreur non standard. La procédure
RAISE_APPLICATION_ERROR permet de signaler les erreurs à l'application et d'éviter le
renvoi d'exceptions non traitées.
Dans la syntaxe :
error_number Valeur numérique définie par l'utilisateur pour l'exception, comprise
entre –20 000 et –20 999.
message Message défini par l'utilisateur pour l'exception. Il s'agit d'une chaîne
de caractères pouvant contenir jusqu'à 2 048 octets.
TRUE | FALSE Paramètre booléen facultatif. Si la valeur est TRUE, l'erreur est
placée dans la pile des erreurs précédentes. Si la valeur est FALSE
(valeur par défaut) l'erreur remplace toutes les erreurs précédentes.

• Elle peut être utilisée à deux endroits :

– Section exécutable
– Section de traitement des exceptions
• Elle renvoie les conditions d'erreur à l'utilisateur d'une
manière cohérente par rapport aux autres erreurs du
serveur Oracle.

Procédure RAISE_APPLICATION_ERROR (suite)

La procédure RAISE_APPLICATION_ERROR peut être utilisée dans la section exécutable
ou dans la section de traitement des exceptions d'un programme PL/SQL. L'erreur renvoyée
est cohérente par rapport aux erreurs du serveur Oracle, qu'elles soient prédéfinies, non
prédéfinies ou définies par l'utilisateur. Le code et le message d'erreur s'affichent pour
l'utilisateur.

Section exécutable :
BEGIN
...
WHERE manager_id = v_mgr;
IF SQL%NOTFOUND THEN
RAISE_APPLICATION_ERROR(-20202,
'This is not a valid manager');
END IF;
...
Section de traitement des exceptions :

...
EXCEPTION
RAISE_APPLICATION_ERROR (-20201,
'Manager is not a valid employee.');
END;
/
Procédure RAISE_APPLICATION_ERROR (suite)

L'exemple de la diapositive ci-dessus montre que la procédure
RAISE_APPLICATION_ERROR peut être utilisée à la fois dans la section exécutable et
dans la section de traitement des exceptions d'un programme PL/SQL.
Voici un autre exemple d'utilisation de la procédure RAISE_APPLICATION_ERROR :
DECLARE
e_name EXCEPTION;
PRAGMA EXCEPTION_INIT (e_name, -20999);
BEGIN
...
WHERE last_name = 'Higgins';
IF SQL%NOTFOUND THEN
RAISE_APPLICATION_ERROR(-20999,'This is not a
valid last name');
END IF;
EXCEPTION
WHEN e_name THEN
-- handle the error
...
END;
/

Synthèse

• définir des exceptions PL/SQL
• ajouter une section EXCEPTION au bloc PL/SQL
afin de traiter les exceptions lors de l'exécution
• gérer différents types d'exception :
– exceptions prédéfinies
– exceptions non prédéfinies
– exceptions définies par l'utilisateur

• propager des exceptions dans des blocs imbriqués
et appeler des applications
Synthèse
Dans ce chapitre, vous avez appris à traiter différents types d'exception. En langage PL/SQL,
une exception est une condition d'avertissement ou d'erreur. Les exceptions prédéfinies sont
des conditions d'erreur définies par le serveur Oracle. Les exceptions non prédéfinies peuvent
être n'importe quelle erreur standard du serveur Oracle. Les exceptions définies par
l'utilisateur sont des exceptions propres à une application. La fonction PRAGMA
EXCEPTION_INIT peut être utilisée pour associer un nom d'exception déclaré à une erreur
du serveur Oracle.
Vous pouvez définir vos propres exceptions dans la section déclarative d'un bloc PL/SQL.
Par exemple, vous pouvez définir une exception nommée INSUFFICIENT_FUNDS pour
mettre en évidence les comptes bancaires à découvert.
Lorsqu'une erreur se produit dans un programme, une exception est déclenchée. L'exécution
normale est interrompue et le contrôle est transféré à la section de traitement des exceptions
du bloc PL/SQL. Les exceptions internes sont générées implicitement (automatiquement) par
le système d'exécution. En revanche, les exceptions définies par l'utilisateur doivent être
générées explicitement. Pour traiter des exceptions déclenchées, vous devez écrire des
sous-programmes distincts appelés gestionnaires d'exceptions.


• Traiter des exceptions nommées
• Créer et appeler des exceptions définies par l'utilisateur

Dans cet exercice, vous allez créer des gestionnaires d'exceptions pour des situations
particulières.

Exercice 8
1. Ce point illustre l'utilisation des exceptions prédéfinies. Ecrivez un bloc PL/SQL permettant de
sélectionner le nom d'un employé en fonction de son salaire.
a. Supprimez tous les enregistrements de la table messages.
b. Dans la section déclarative, déclarez deux variables : v_ename de type
employees.last_name et v_emp_sal de type employees.salary. Initialisez
cette dernière variable avec la valeur 6000.
c. Dans la section exécutable, extrayez le nom des employés dont le salaire est égal à la valeur
de v_emp_sal.
Remarque : N'utilisez pas de curseurs explicites.
Si une seule ligne est renvoyée pour le salaire entré, insérez dans la table messages le
nom de l'employé et le montant de son salaire.
d. Si aucune ligne n'est renvoyée pour le salaire entré, traitez l'exception à l'aide d'un
gestionnaire approprié et insérez dans la table messages le message "No employee with a

salary of <salary>".
e. Si plusieurs lignes sont renvoyées pour le salaire entré, traitez l'exception à l'aide d'un
gestionnaire approprié et insérez dans la table messages le message "More than one
employee with a salary of <salary>".
f. Traitez toutes les autres exceptions à l'aide d'un gestionnaire approprié et insérez dans la
table messages le message "Some other error occurred".
g. Affichez les lignes de la table messages afin de déterminer si le bloc PL/SQL s'est
exécuté correctement. Voici un exemple de résultat :
2. Ce point montre comment déclarer des exceptions avec une erreur standard du serveur Oracle.
Utilisez l'erreur ORA-02292 du serveur Oracle (integrity constraint violated –
child record found).
a. Dans la section déclarative, déclarez l'exception e_childrecord_exists. Associez
l'exception déclarée au code d'erreur standard –02292 du serveur Oracle.
b. Dans la section exécutable, affichez "Deleting department 40.....". Incluez une instruction
DELETE afin de supprimer le département dont la valeur department_id est 40.

Exercice 8 (suite)
c. Incluez une section de traitement des exceptions afin de traiter l'exception
e_childrecord_exists et d'afficher le message approprié. Voici un exemple
de résultat :



Créer des procédures
et des fonctions stockées

Objectifs

• faire la distinction entre les blocs anonymes et les
sous-programmes
• créer une procédure simple et l'appeler à partir d'un bloc
anonyme
• créer une fonction simple
• créer une fonction simple qui accepte un paramètre
• faire la distinction entre les procédures et les fonctions

But du chapitre
Nous avons précédemment étudié les blocs anonymes. Nous allons maintenant étudier
les blocs nommés, également appelés sous-programmes. Les procédures et les fonctions sont
des sous-programmes PL/SQL. Dans ce chapitre, vous apprendrez à faire la distinction entre
les blocs anonymes et les sous-programmes.

Procédures et fonctions
• Blocs PL/SQL nommés

• Appelés sous-programmes PL/SQL
• Présentent des structures de bloc semblables à celle des
blocs anonymes :
– Section déclarative facultative (sans le mot-clé DECLARE)
– Section exécutable obligatoire
– Section facultative de traitement des exceptions

Procédures et fonctions
Les seuls exemples de code PL/SQL étudiés jusqu'à présent dans ce cours sont les blocs
anonymes. Comme leur nom l'indique, les blocs anonymes sont des blocs PL/SQL
exécutables non nommés. Etant donné qu'ils n'ont pas de nom, ils ne peuvent être ni réutilisés,
ni stockés pour une utilisation ultérieure.
Les procédures et les fonctions sont des blocs PL/SQL nommés. Elles sont également
appelées sous-programmes. Les sous-programmes sont compilés et stockés dans la base de
données. La structure de bloc des sous-programmes est semblable à la structure des blocs
anonymes. Les sous-programmes peuvent être déclarés non seulement au niveau schéma,
mais également dans n'importe quel autre bloc PL/SQL. Un sous-programme contient les
sections suivantes :
Section déclarative : Les sous-programmes peuvent comporter une section déclarative
facultative. En revanche, cette section ne commence pas par le mot-clé DECLARE,
contrairement à celle des blocs anonymes. La section déclarative facultative suit le mot-clé
IS ou AS dans la déclaration du sous-programme.
Section exécutable : Il s'agit d'une section obligatoire du sous-programme, qui contient
l'implémentation de la logique métier. L'examen de son code permet de déterminer facilement
les fonctionnalités métier du sous-programme. Cette section commence et se termine
respectivement par les mots-clés BEGIN et END.
Section de traitement des exceptions : Il s'agit d'une section facultative permettant de traiter
les exceptions.

Différences entre les blocs anonymes

et les sous-programmes
Blocs anonymes Sous-programmes

Blocs PL/SQL non nommés Blocs PL/SQL nommés
Compilés chaque fois Compilés une seule fois
Non stockés dans la base de Stockés dans la base de données

données
Pas d'appel possible par Appel possible par d'autres applications,
d'autres applications car nommés

Ne renvoient pas de valeurs Les sous-programmes appelés fonctions
doivent renvoyer des valeurs.
Ne peuvent pas accepter de Peuvent accepter des paramètres

paramètres
Différences entre les blocs anonymes et les sous-programmes

Le tableau de la diapositive ci-dessus indique les différences entre les blocs anonymes et les
sous-programmes, et il met également en évidence les avantages des sous-programmes.
Les blocs anonymes ne sont pas des objets de base de données persistants. Ils sont compilés et
exécutés une seule fois. Ils ne sont pas stockés dans la base de données en vue d'une
utilisation ultérieure. Si vous souhaitez les réutiliser, vous devez réexécuter le script qui crée
le bloc anonyme, ce qui entraîne la recompilation et l'exécution.
Les procédures et les fonctions sont compilées et sont stockées dans la base de données sous
forme compilée. Elles ne sont recompilées que suite à une modification. Etant donné que ces
sous-programmes sont stockés dans la base, toute application peut les utiliser dès lors qu'elle
dispose des droits appropriés. L'application appelante peut transmettre des paramètres à une
procédure si celle-ci est conçue pour accepter des paramètres. De la même façon, une
application appelante peut extraire une valeur si elle appelle une fonction ou une procédure.

Procédure : Syntaxe
CREATE [OR REPLACE] PROCEDURE procedure_name

[(argument1 [mode1] datatype1,
argument2 [mode2] datatype2,
. . .)]
IS|AS
procedure_body;

Procédure : Syntaxe
La diapositive ci-dessus présente la syntaxe permettant de créer des procédures. Dans la
syntaxe :
procedure_name Nom de la procédure à créer.
argument Nom affecté au paramètre de la procédure. Chaque argument est
associé à un mode et à un type de données. Vous pouvez indiquer
un nombre quelconque d'arguments, séparés par des virgules.
mode Mode de l'argument :
IN (par défaut)
OUT
IN OUT
datatype Type de données du paramètre associé. Le type de données des
paramètres ne peut pas présenter de taille explicite. Utilisez
%TYPE.
Procedure_body Bloc PL/SQL qui constitue le code.
La liste des arguments est facultative dans la déclaration d'une procédure. Pour en savoir plus
sur les procédures, reportez-vous au cours intitulé Oracle Database 10g : Objets procéduraux
basés d'Oracle.

Procédure : Exemple
...
CREATE TABLE dept AS SELECT * FROM departments;
CREATE PROCEDURE add_dept IS
v_dept_id dept.department_id%TYPE;
v_dept_name dept.department_name%TYPE;
BEGIN
v_dept_id:=280;
v_dept_name:='ST-Curriculum';

INSERT INTO dept(department_id,department_name)
VALUES(v_dept_id,v_dept_name);
DBMS_OUTPUT.PUT_LINE(' Inserted '|| SQL%ROWCOUNT
||' row ');
END;
Procédure : Exemple
Examinez le code de la diapositive ci-dessus. La procédure add_dept insère un nouveau
département avec le numéro de département 280 et le nom de département
ST-Curriculum. Elle déclare deux variables, à savoir dept_id et dept_name, dans la
section déclarative. La section déclarative d'une procédure commence immédiatement après
la déclaration de celle-ci. Elle ne commence pas par le mot-clé DECLARE. La procédure
utilise l'attribut de curseur implicite ou l'attribut SQL SQL%ROWCOUNT pour vérifier si la
ligne a été insérée avec succès. SQL%ROWCOUNT doit renvoyer la valeur 1 dans ce cas.
Remarque : Lorsque vous créez un objet quelconque (tel qu'une table, une procédure ou une
fonction), les entrées correspondantes sont créées dans la table user_objects. Lorsque le
code de la diapositive est exécuté avec succès, vous pouvez examiner le contenu de la table
user_objects en exécutant la commande suivante :
SELECT object_name,object_type FROM user_objects;

Procédure : Exemple (suite)

Le code source de la procédure est stocké dans la table user_source. Vous pouvez examiner
le code source de la procédure en exécutant la commande suivante :
SELECT * FROM user_source WHERE name='ADD_DEPT';

Appeler la procédure
BEGIN
add_dept;
END;
/
SELECT department_id, department_name FROM dept
WHERE department_id=280;

Appeler la procédure
La diapositive ci-dessus montre comment appeler une procédure à partir d'un bloc anonyme.
Vous devez inclure l'appel de la procédure dans la section exécutable du bloc anonyme. De la
même façon, vous pouvez appeler la procédure à partir de n'importe quelle application, telle
qu'une application Forms, une application Java, etc. L'instruction SELECT du code vérifie si
la ligne a été insérée avec succès.
Vous pouvez également appeler une procédure avec l'instruction SQL CALL
<procedure_name>.

Fonction : Syntaxe
CREATE [OR REPLACE] FUNCTION function_name

[(argument1 [mode1] datatype1,
argument2 [mode2] datatype2,
. . .)]
RETURN datatype
IS|AS
function_body;

Fonction : Syntaxe
La diapositive ci-dessus présente la syntaxe de création d'une fonction. Dans la syntaxe :
function_name Nom de la fonction à créer.
argument Nom affecté au paramètre de la fonction (chaque argument est
associé à un mode et à un type de données). Vous pouvez indiquer
un nombre quelconque d'arguments, séparés par des virgules.
Vous transmettez l'argument lors de l'appel de la fonction.
mode Type de paramètre (seuls les paramètres IN doivent être déclarés.)
datatype Type de données du paramètre associé.
RETURN datatype Type de données de la valeur renvoyée par la fonction.

function_body Bloc PL/SQL qui constitue le code de la fonction.
La liste des arguments est facultative dans la déclaration d'une fonction. La différence entre
une procédure et une fonction est qu'une fonction doit renvoyer une valeur au programme
appelant. Par conséquent, la syntaxe contient return_type, qui indique le type de données de la
valeur renvoyée. Une procédure peut renvoyer une valeur via un paramètre OUT ou IN OUT.

Fonction : Exemple
CREATE FUNCTION check_sal RETURN Boolean IS
v_dept_id employees.department_id%TYPE;
v_sal employees.salary%TYPE;
v_avg_sal employees.salary%TYPE;
BEGIN
v_empno:=205;
SELECT salary,department_id INTO v_sal,v_dept_id FROM
employees
SELECT avg(salary) INTO v_avg_sal FROM employees WHERE
department_id=v_dept_id;
IF v_sal > v_avg_sal THEN
RETURN TRUE;

ELSE
RETURN FALSE;
END IF;
EXCEPTION
RETURN NULL;
END;
Fonction : Exemple
La fonction check_sal permet de déterminer si le salaire d'un employé est supérieur ou
inférieur au salaire moyen de tous les employés travaillant dans le même département. La
fonction renvoie TRUE si le salaire de l'employé est supérieur au salaire moyen des employés
du département. Sinon, elle renvoie FALSE. La fonction renvoie NULL si une exception
NO_DATA_FOUND est générée.
Notez que la fonction effectue la vérification pour l'employé dont l'ID est 205. La vérification
est codée en dur pour cet ID uniquement. Si vous souhaitez effectuer la vérification pour tout
autre employé, vous devez modifier la fonction proprement dite. Vous pouvez résoudre ce
problème en déclarant la fonction de sorte qu'elle accepte un argument. Vous pouvez ensuite
transmettre l'ID de l'employé en tant que paramètre.

Appeler une fonction
BEGIN
IF (check_sal IS NULL) THEN
DBMS_OUTPUT.PUT_LINE('The function returned
NULL due to exception');
ELSIF (check_sal) THEN
DBMS_OUTPUT.PUT_LINE('Salary > average');
ELSE
DBMS_OUTPUT.PUT_LINE('Salary < average');
END IF;

END;
/
Appeler une fonction

Incluez l'appel de la fonction dans la section exécutable du bloc anonyme.
La fonction est appelée dans le cadre d'une instruction. Souvenez-vous que la fonction
check_sal renvoie une valeur booléenne ou NULL. L'appel de la fonction est donc inclus
comme expression conditionnelle pour le bloc IF.
Remarque : Vous pouvez utiliser la commande DESCRIBE pour examiner les arguments de
la fonction et le type de données renvoyé, comme dans l'exemple suivant :
DESCRIBE check_sal;

Transmettre un paramètre à une fonction
DROP FUNCTION check_sal;

CREATE FUNCTION check_sal(p_empno employees.employee_id%TYPE)
RETURN Boolean IS
v_dept_id employees.department_id%TYPE;
v_avg_sal employees.salary%TYPE;
BEGIN
SELECT salary,department_id INTO v_sal,v_dept_id FROM employees
WHERE employee_id=p_empno;
SELECT avg(salary) INTO v_avg_sal FROM employees
WHERE department_id=v_dept_id;
IF v_sal > v_avg_sal THEN

RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
EXCEPTION
...
Transmettre un paramètre à une fonction

La fonction considérée dans les diapositives précédentes était codée en dur. Elle mettait
seulement de vérifier le salaire de l'employé possédant l'ID 205. Dans la diapositive ci-dessus,
le code de la fonction a été réécrit de manière à supprimer cette contrainte. La fonction admet
maintenant le numéro de l'employé comme paramètre. Vous pouvez à présent transmettre
différents numéros d'employé afin de vérifier le salaire de l'employé correspondant.
Pour en savoir plus sur les fonctions, reportez-vous au cours intitulé Oracle Database 10g :
Objets procéduraux basés d'Oracle.

Appeler une fonction avec un paramètre

BEGIN
DBMS_OUTPUT.PUT_LINE('Checking for employee with id 205');
IF (check_sal(205) IS NULL) THEN
ELSIF (check_sal(205)) THEN
DBMS_OUTPUT.PUT_LINE('Salary > average');
ELSE
DBMS_OUTPUT.PUT_LINE('Salary < average');
END IF;
DBMS_OUTPUT.PUT_LINE('Checking for employee with id 70');
IF (check_sal(70) IS NULL) THEN

ELSIF (check_sal(70)) THEN
...
END IF;
END;
/
Appeler une fonction avec un paramètre

Le code de la diapositive ci-dessus appelle la fonction deux fois en transmettant des
paramètres. La sortie du code est la suivante :

Synthèse

• créer une procédure simple
• appeler la procédure à partir d'un bloc anonyme
• créer une fonction simple
• créer une fonction simple qui accepte des paramètres
• appeler la fonction à partir d'un bloc anonyme

Synthèse
Vous pouvez utiliser des blocs anonymes pour inclure des fonctionnalités en langage PL/SQL.
Cependant, la principale contrainte des blocs anonymes est qu'ils ne sont pas stockés et ne
peuvent donc pas être réutilisés.
Plutôt que de créer des blocs anonymes, vous pouvez créer des sous-programmes PL/SQL.
Les procédures et les fonctions sont appelées des sous-programmes, lesquels sont des blocs
PL/SQL nommés. La logique des sous-programmes peut être réutilisée grâce aux paramètres.
La structure d'une procédure ou d'une fonction est semblable à la structure d'un bloc anonyme.
Ces sous-programmes sont stockés dans la base de données et peuvent donc être réutilisés.


• Convertir un bloc anonyme existant en procédure
• Modifier la procédure afin qu'elle accepte un paramètre
• Ecrire un bloc anonyme afin d'appeler la procédure


Exercice 9
1. Chargez le script lab_02_04_soln.sql que vous avez créé au point 4 de l'exercice 2.
a. Modifiez le script afin de convertir le bloc anonyme en procédure nommée greet.
b. Exécutez le script afin de créer la procédure.
c. Enregistrez le script sous le nom lab_09_01_soln.sql.
d. Cliquez sur le bouton Clear afin de vider l'espace de travail.
e. Créez et exécutez un bloc anonyme afin d'appeler la procédure greet. Voici un exemple
de résultat :
2. Chargez le script lab_09_01_soln.sql.

a. Supprimez la procédure greet en exécutant la commande suivante :
DROP PROCEDURE greet
b. Modifiez la procédure afin qu'elle accepte un argument de type VARCHAR2. Nommez
l'argument p_name.
c. Affichez "Hello <name>" à la place de "Hello World".
d. Enregistrez le script sous le nom lab_09_02_soln.sql.
e. Exécutez le script afin de créer la procédure.
f. Créez et exécutez un bloc anonyme afin d'appeler la procédure greet avec un paramètre.
Voici un exemple de résultat :

__________________
__________________
A
Solutions des exercices

Remarques générales :
x Sauvegardez tous vos scripts dans le répertoire suivant : D:\labs\SQL1\labs.

x Entrez les instructions SQL dans une feuille de calcul SQL. Pour sauvegarder un script
dans SQL Developer, ouvrez le menu File et sélectionnez Save As, ou bien cliquez à
l'aide du bouton droit de la souris dans la feuille de calcul SQL, puis sélectionnez Save
file pour sauvegarder votre instruction SQL en tant que script sous le nom
lab_<lessonno>_<stepno>.sql. Pour modifier un script existant, utilisez File > Open pour
ouvrir le fichier script et le modifier. Veillez ensuite à utiliser l'option Save As pour le
sauvegarder sous un nom différent.
x Pour exécuter l'interrogation, cliquez sur l'icône Execute Statement (ou appuyez sur F9)
dans la feuille de calcul SQL. Pour les instructions LMD et LDD, utilisez l'icône Run
Script (ou appuyez sur F5).
x Une fois que vous avez exécuté un script sauvegardé, veillez à ne pas saisir l'interrogation
suivante dans la même feuille de calcul. Ouvrez une nouvelle feuille de calcul.
Oracle Database 11g : Les fondamentaux du langage PL/SQL A - 2

Exercice 1 : Introduction au langage PL/SQL
Le dossier labs est le répertoire de travail où vous sauvegardez vos scripts. Demandez au
formateur de vous aider à localiser le dossier labs pour ce cours. Les solutions de tous les
exercices se trouvent dans le dossier soln.
1. Parmi les blocs PL/SQL suivants, lesquels s'exécutent avec succès ?
a. BEGIN
END;
b. DECLARE
amount INTEGER(10);
END;
c. DECLARE

BEGIN
END;
d. DECLARE
amount INTEGER(10);
BEGIN
DBMS_OUTPUT.PUT_LINE(amount);
END;
Le bloc a ne s'exécute pas, car la section exécutable ne contient aucune instruction.

Le bloc b ne comporte pas la section exécutable obligatoire qui commence par le mot-clé
BEGIN.
Le bloc c comporte toutes les sections nécessaires, mais la section exécutable ne contient
aucune instruction.
2. Créez et exécutez un bloc anonyme simple qui affiche "Hello World". Exécutez ce script
et enregistrez-le sous le nom lab_01_02_soln.sql.
a. Démarrez SQL Developer. Les informations nécessaires vous seront fournies par
votre formateur.
b. Activez la sortie dans SQL Developer en cliquant sur le bouton Enable DBMS
Output, dans l'onglet DBMS Output.
Enable DBMS
DBMS Output
Output
Tab

c. Saisissez le code suivant dans l'espace de travail.
BEGIN
DBMS_OUTPUT.PUT_LINE(' Hello World ');
END;
d. Cliquez sur le bouton Run Script.

e. Vous devez obtenir le résultat suivant dans l'onglet Script Output :
f. Cliquez sur le bouton Save. Sélectionnez le dossier dans lequel vous souhaitez
enregistrer le fichier. Entrez le nom lab_01_02_soln.sql et cliquez sur le
bouton Save.

Exercice 2 : Déclarer des variables PL/SQL
1. Identifiez les identificateurs valides et non valides.

a. today Valide
b. last_name Valide
c. today’s_date Non valide
(le caractère ' n'est pas autorisé)
d. Number_of_days_in_February_this_year Non valide (trop long)
e. Isleap$year Valide
f. #number Non valide
(l'identificateur ne doit pas
commencer par "#")
g. NUMBER# Valide
h. number1to7 Valide
2. Identifiez les déclarations et initialisations valides et non valides des variables :

a. number_of_copies PLS_INTEGER; Valide
b. PRINTER_NAME constant VARCHAR2(10); Non valide
c. deliver_to VARCHAR2(10):=Johnson; Non valide
d. by_when DATE:= SYSDATE+1; Valide
La déclaration b n'est pas valide, car les variables de type constante doivent être
initialisées lors de la déclaration.
La déclaration c n'est pas valide, car les littéraux de type chaîne doivent être indiqués
entre apostrophes.
3. Examinez le bloc anonyme suivant et choisissez l'affirmation appropriée.

DECLARE
v_lname VARCHAR2(15) DEFAULT 'fernandez';
BEGIN
DBMS_OUTPUT.PUT_LINE(v_fname ||' ' ||v_lname);
END;
b. Le bloc renvoie une erreur, car la variable fname est utilisée sans initialisation.
c. Le bloc s'exécute avec succès et affiche "null fernandez".
d. Le bloc génère une erreur, car vous ne pouvez pas utiliser le mot-clé DEFAULT
pour initialiser une variable de type VARCHAR2.
e. Le bloc génère une erreur, car la variable v_fname n'est pas déclarée.

4. Créez un bloc anonyme. Dans SQL Plus, chargez le script lab_01_02_soln.sql que
vous avez créé au point 2 de l'exercice 1, en appliquant les instructions suivantes :
Sélectionnez File > Open.

Sélectionnez le fichier lab_01_02_soln.sql. Cliquez sur le bouton Open.
L'espace de travail contient à présent le code du fichier .sql.
a. Ajoutez une section déclarative à ce bloc PL/SQL. Dans la section déclarative,
déclarez les variables suivantes :
1. Variable today de type DATE. Initialisez today avec SYSDATE.
DECLARE
v_today DATE:=SYSDATE;
2. Variable tomorrow de type today. Utilisez l'attribut %TYPE pour déclarer

cette variable.
v_tomorrow v_today%TYPE;

b. Dans la section exécutable, initialisez la variable tomorrow avec une expression
qui calcule la date du lendemain (ajoutez la valeur "un" à la valeur de today).
Affichez la valeur de today et de tomorrow après l'affichage de "Hello
World".
BEGIN
v_tomorrow:=v_today +1;
DBMS_OUTPUT.PUT_LINE(' Hello World ');
DBMS_OUTPUT.PUT_LINE('TODAY IS : '|| v_today);
DBMS_OUTPUT.PUT_LINE('TOMORROW IS : ' || v_tomorrow);
END;
c. Exécutez et enregistrez le script sous le nom lab_02_04_soln.sql. Suivez

les instructions de l'étape 2 f) de l'exercice 1 afin d'enregistrer le fichier. Voici un
exemple de résultat :

Hello World
TODAY IS : 09-MAY-07
TOMORROW IS : 10-MAY-07

5. Editez le script lab_02_04_soln.sql.
a. Ajoutez du code afin de créer deux variables attachées.

Créez les variables attachées basic_percent et pf_percent de type
NUMBER.
VARIABLE b_basic_percent NUMBER
VARIABLE b_pf_percent NUMBER
b. Dans la section exécutable du bloc PL/SQL, affectez les valeurs 45 et 12

respectivement à basic_percent et à pf_percent.
:b_basic_percent:=45;
:b_pf_percent:=12;
c. Terminez le bloc PL/SQL avec "/" et affichez la valeur des variables attachées à
l'aide de la commande PRINT.

/
PRINT b_basic_percent
PRINT b_pf_percent
OU
PRINT


Exercice 3 : Ecrire des instructions executables
DECLARE
BEGIN
DECLARE
v_new_locn VARCHAR2(50) := 'Europe';
BEGIN
1
END;
v_message := v_message || ' is in stock';

2
END;
/
1. Observez le bloc PL/SQL qui précède et déterminez le type de données et la valeur de

chacune des variables suivantes d'après les règles relatives à la portée.
a. La valeur de v_weight à la position 1 est la suivante :
2
Le type de données est NUMBER.
b. La valeur de v_new_locn à la position 1 est la suivante :

Western Europe
Le type de données est VARCHAR2.
c. La valeur de v_weight à la position 2 est la suivante :

601
d. La valeur de v_message à la position 2 est la suivante :

Product 10012 is in stock.
e. La valeur de v_new_locn à la position 2 est :

Illegal, car v_new_locn n'est pas visible en dehors du bloc imbriqué.

DECLARE
v_customer VARCHAR2(50) := 'Womansport';

v_credit_rating VARCHAR2(50) := 'EXCELLENT';
BEGIN
DECLARE
v_customer NUMBER(7) := 201;
v_name VARCHAR2(25) := 'Unisports';
BEGIN
v_credit_rating :='GOOD';
…
END;
…
END;
2. Dans le bloc PL/SQL qui précède, déterminez les valeurs et les types de données pour
chacun des cas suivants.

a. La valeur de v_customer dans le bloc imbriqué est la suivante :
201
b. La valeur de v_name dans le bloc imbriqué est la suivante :
Unisports
c. La valeur de v_credit_rating dans le bloc imbriqué est la suivante :
GOOD
d. La valeur de v_customer dans le bloc principal est la suivante :
Womansport
e. La valeur de v_name dans le bloc principal est la suivante :
name n'est pas visible dans le bloc principal et vous voyez une erreur.
f. La valeur de v_credit_rating dans le bloc principal est la suivante :
GOOD
3. Utilisez la même session que celle qui a servi à exécuter les exercices du chapitre
"Déclarer des variables PL/SQL". Si vous avez ouvert une nouvelle session, exécutez le
script lab_02_05_soln.sql. Editez le fichier lab_02_05_soln.sql.
a. Mettez en commentaire les lignes de création des variables attachées (bind
variables), en utilisant la syntaxe de commentaire monoligne.
-- VARIABLE b_basic_percent NUMBER

-- VARIABLE b_pf_percent NUMBER

b. Dans la section exécutable, mettez en commentaire les lignes qui affectent des
valeurs aux variables attachées, en utilisant la syntaxe de commentaire multiligne.
/*:b_basic_percent:=45;
:b_pf_percent:=12;*/
c. Déclarez des variables : fname de type VARCHAR2 et de taille 15, et emp_sal

de type NUMBER et de taille 10.
DECLARE
v_basic_percent NUMBER:=45;
v_pf_percent NUMBER:=12;

v_emp_sal NUMBER(10);
d. Incluez l'instruction SQL suivante dans la section exécutable :
SELECT first_name, salary INTO v_fname, v_emp_sal

FROM employees WHERE employee_id=110;
e. Modifiez la ligne qui affiche "Hello World" afin d'afficher "Hello" et le prénom.
Si vous le souhaitez, vous pouvez mettre en commentaire les lignes qui affichent
les dates et afficher les variables attachées.
DBMS_OUTPUT.PUT_LINE(' Hello '|| v_fname);
f. Calculez la contribution de l'employé au fonds de prévoyance (PF).

La contribution PF est de 12 % du salaire de base, ce dernier représentant 45 % du
salaire. Utilisez les variables attachées pour le calcul. Essayez d'utiliser une seule
expression pour calculer la contribution PF. Affichez le salaire de l'employé et sa
contribution PF.
DBMS_OUTPUT.PUT_LINE('YOUR SALARY IS : '||v_emp_sal);

DBMS_OUTPUT.PUT_LINE('YOUR CONTRIBUTION TOWARDS PF:
'||v_emp_sal*v_basic_percent/100*v_pf_percent/100);
END;
g. Exécutez votre script et enregistrez-le sous le nom lab_03_03_soln.sql.


Exercice 4 : Interagir avec le serveur Oracle
1. Créez un bloc PL/SQL qui sélectionne l'ID de département le plus grand dans la table
departments et qui le stocke dans la variable v_max_deptno. Affichez l'ID de
département le plus élevé.
a. Déclarez une variable nommée v_max_deptno de type NUMBER dans la section
déclarative.
DECLARE
v_max_deptno NUMBER;
b. Commencez la section exécutable par le mot-clé BEGIN et incluez une instruction

SELECT afin d'extraire la valeur department_id maximale de la table
departments.
BEGIN

SELECT MAX(department_id) INTO v_max_deptno FROM departments;
c. Affichez v_max_deptno et terminez le bloc exécutable.
DBMS_OUTPUT.PUT_LINE('The maximum department_id is :

' || v_max_deptno);
END;

2. Modifiez le bloc PL/SQL créé au cours de l'exercice 1 afin d'insérer un nouveau

département dans la table departments.
a. Chargez le script lab_04_01_soln.sql. Déclarez deux variables :
v_dept_name de type departments.department_name
v_dept_id de type NUMBER
Affectez la valeur "Education" à v_dept_name dans la section déclarative.
v_dept_name departments.department_name%TYPE:= 'Education';

v_dept_id NUMBER;
b. Vous avez déjà extrait le numéro de département maximal actuel à partir de la

table departments. Ajoutez 10 à ce numéro et affectez le résultat à dept_id.
v_dept_id := 10 + v_max_deptno;
…

c. Incluez une instruction INSERT pour insérer des données dans les colonnes
department_name, department_id et location_id de la table
departments. Utilisez les valeurs de dept_name et dept_id

respectivement pour department_name et department_id et utilisez la
valeur NULL pour location_id.
…
INSERT INTO departments (department_id, department_name,
location_id)
VALUES (v_dept_id,v_dept_name, NULL);
d. Utilisez l'attribut SQL SQL%ROWCOUNT pour afficher le nombre de lignes

affectées.
DBMS_OUTPUT.PUT_LINE (' SQL%ROWCOUNT gives ' || SQL%ROWCOUNT);

…

e. Exécutez une instruction SELECT afin de déterminer si le nouveau département a
été inséré. Vous pouvez terminer le bloc PL/SQL par "/" et inclure l'instruction
SELECT dans le script.
…
/
SELECT * FROM departments WHERE department_id= 280;
f. Exécutez votre script et enregistrez-le sous le nom lab_04_02_soln.sql.

3. Dans l'exercice 2, vous avez affecté la valeur NULL à location_id. Créez un bloc
PL/SQL qui met à jour location_id avec la valeur 3000 pour le nouveau
département. Utilisez la variable attachée dept_id pour mettre à jour la ligne.
a. Si vous avez démarré une nouvelle session, supprimez le département que vous
avez ajouté à la table departments et exécutez le script
lab_04_02_soln.sql.
DELETE FROM departments WHERE department_id=280;

b. Commencez le bloc exécutable par le mot-clé BEGIN. Incluez l'instruction
UPDATE afin d'affecter la valeur 3000 à location_id pour le nouveau
département (dept_id = 280).
BEGIN
UPDATE departments SET location_id=3000 WHERE
department_id=280;
c. Terminez le bloc exécutable par le mot-clé END. Terminez le bloc PL/SQL par "/"
et incluez une instruction SELECT afin d'afficher le département que vous avez
mis à jour.
END;
/
SELECT * FROM departments WHERE department_id=280;
d. Finalement, incluez une instruction DELETE afin de supprimer le département

que vous avez ajouté.
DELETE FROM departments WHERE department_id=280;


DEPARTMENT_ID DEPARTMENT_NAME MANAGER_ID LOCATION_ID
-------------- --------------- ----------- --------------
280 Education 3000
1 rows selected
1 rows deleted

Exercice 5 : Ecrire des structures de contrôle
1. Exécutez la commande du fichier lab_05_01.sql pour créer la table messages.

Ecrivez un bloc PL/SQL permettant d'insérer des nombres dans la table messages.
a. Insérez les nombres de 1 à 10, en excluant 6 et 8.
b. Effectuez une validation (commit) avant la fin du bloc.
BEGIN
FOR i in 1..10 LOOP
IF i = 6 or i = 8 THEN
null;
ELSE
INSERT INTO messages(results)
VALUES (i);
END IF;
END LOOP;

COMMIT;
END;
/
c. Exécutez une instruction SELECT afin de vérifier le fonctionnement du bloc

PL/SQL.
SELECT * FROM messages;
Vous devez obtenir le résultat suivant :
2. Exécutez le script lab_05_02.sql. Ce script crée une table emp qui est une réplique
de la table employees. Il modifie la table emp afin d'ajouter une nouvelle colonne,
stars, de type VARCHAR2 et de taille 50. Créez un bloc PL/SQL qui insère un
astérisque dans la colonne stars pour chaque tranche de 1000 $ du salaire de l'employé.
Enregistrez le script sous le nom lab_05_02_soln.sql.
a. Dans la section déclarative du bloc, déclarez la variable v_empno de type
emp.employee_id et initialisez-la avec la valeur 176. Déclarez la variable
v_asterisk de type emp.stars et initialisez-la à NULL. Créez la variable
sal de type emp.salary.

DECLARE
v_empno emp.employee_id%TYPE := 176;
v_asterisk emp.stars%TYPE := NULL;

v_sal emp.salary%TYPE;
b. Dans la section exécutable, écrivez la logique permettant d'ajouter un astérisque

(*) à la chaîne pour chaque tranche de 1 000 $ du salaire. Par exemple, si
l'employé gagne 8 000 $, la chaîne doit contenir huit astérisques. Si l'employé
gagne 12 500 $, la chaîne doit contenir treize astérisques.
SELECT NVL(ROUND(salary/1000), 0) INTO v_sal

FROM emp WHERE employee_id = v_empno;
FOR i IN 1..v_sal
LOOP
v_asterisk := v_asterisk ||'*';

END LOOP;
c. Mettez à jour la colonne stars de l'employé avec la chaîne d'astérisques

correspondante. Effectuez une validation (commit) avant la fin du bloc.
UPDATE emp SET stars = v_asterisk

COMMIT;
d. Affichez la ligne de la table emp afin de vérifier que le bloc PL/SQL s'est exécuté
correctement.
SELECT employee_id,salary, stars

FROM emp WHERE employee_id =176;


Exercice 6 : Utiliser des types de données composites
1. Ecrivez un bloc PL/SQL permettant d'afficher les informations relatives à un pays donné.
a. Déclarez un enregistrement PL/SQL conforme à la structure de la table
countries.
b. Déclarez une variable v_countryid. Affectez CA à v_countryid.
SET VERIFY OFF

DECLARE
v_countryid varchar2(20):= 'CA';
c. Dans la section déclarative, utilisez l'attribut %ROWTYPE et déclarez la variable

v_country_record de type countries.
v_country_record countries%ROWTYPE;

d. Dans la section exécutable, obtenez toutes les informations de la table
countries à l'aide de v_countryid. Affichez les informations sélectionnées
sur le pays. Voici un exemple de résultat :
BEGIN
SELECT *
INTO v_country_record
FROM countries
WHERE country_id = UPPER(v_countryid);
DBMS_OUTPUT.PUT_LINE ('Country Id: ' || v_country_record.country_id ||

' Country Name: ' || v_country_record.country_name
|| ' Region: ' || v_country_record.region_id);
END;
e. Vous pouvez exécuter et tester le bloc PL/SQL pour les pays dont l'ID est DE, UK
et US.
2. Créez un bloc PL/SQL pour extraire le nom de chaque département de la table

departments et afficher le nom du département à l'écran, en utilisant une table
INDEX BY. Enregistrez le script sous le nom lab_06_02_soln.sql.

a. Déclarez une table INDEX BY nommée dept_table_type de type
departments.department_name. Déclarez une variable nommée
my_dept_table de type dept_table_type afin de stocker temporairement

le numéro des départements.
DECLARE
TYPE dept_table_type is table of departments.department_name%TYPE
my_dept_table dept_table_type;
b. Déclarez deux variables : f_loop_count et v_deptno de type NUMBER.

Affectez la valeur 10 à f_loop_count et la valeur 0 à v_deptno.
f_loop_count NUMBER (2):=10;

v_deptno NUMBER (4):=0;

c. A l'aide d'une boucle, extrayez les noms de 10 départements et stockez-les dans la
table INDEX BY. Commencez par la valeur department_id 10. Augmentez
v_deptno de 10 à chaque itération de la boucle. Le tableau qui suit indique la
valeur department_id pour laquelle vous devez extraire la valeur
department_name et la stocker dans la table INDEX BY.
DEPARTMENT_ID DEPARTMENT_NAME
10 Administration
20 Marketing
30 Purchasing
40 Human Resources
50 Shipping
60 IT
70 Public Relations
80 Sales
90 Executive
100 Finance
BEGIN
FOR i IN 1..f_loop_count
LOOP
v_deptno:=v_deptno+10;
SELECT department_name
INTO my_dept_table(i)
FROM departments
END LOOP;

d. A l'aide d'une autre boucle, extrayez les noms des départements de la table
INDEX BY et affichez-les.
LOOP
DBMS_OUTPUT.PUT_LINE (my_dept_table(i));
END LOOP;
END;


3. Modifiez le bloc créé au point 2 afin d'extraire toutes les informations sur les
départements de la table departments et de les afficher. Utilisez une table
d'enregistrements INDEX BY.
a. Chargez le script lab_06_02_soln.sql.
b. Vous avez déclaré la table INDEX BY comme étant de type
departments.department_name. Modifiez la déclaration de la table
INDEX BY afin de stocker temporairement le numéro, le nom et l'emplacement de
tous les départements. Utilisez l'attribut %ROWTYPE.

DECLARE
TYPE dept_table_type is table of departments%ROWTYPE

my_dept_table dept_table_type;
f_loop_count NUMBER (2):=10;
v_deptno NUMBER (4):=0;
c. Modifiez l'instruction SELECT afin d'extraire toutes les informations relatives aux
départements, actuellement contenues dans la table departments, et stockez
celles-ci dans la table INDEX BY.
BEGIN
LOOP
v_deptno := v_deptno + 10;
SELECT *

INTO my_dept_table(i)
FROM departments
END LOOP;
d. A l'aide d'une autre boucle, extrayez de la table INDEX BY les informations

relatives aux départements et affichez-les. Voici un exemple de résultat :
LOOP
DBMS_OUTPUT.PUT_LINE ('Department Number: ' ||
my_dept_table(i).department_id
|| ' Department Name: ' || my_dept_table(i).department_name
|| ' Manager Id: '|| my_dept_table(i).manager_id
|| ' Location Id: ' || my_dept_table(i).location_id);
END LOOP;
END;

Department Number: 10 Department Name: Administration Manager

Department Number: 20 Department Name: Marketing Manager Id:
Department Number: 30 Department Name: Purchasing Manager Id:
Department Number: 40 Department Name: Human Resources Manager
Department Number: 50 Department Name: Shipping Manager Id:
Department Number: 60 Department Name: IT Manager Id: 103
Location Id: 1400
Department Number: 70 Department Name: Public Relations
Manager Id: 204 Location Id: 2700
Department Number: 80 Department Name: Sales Manager Id: 145

Location Id: 2500
Department Number: 90 Department Name: Executive Manager Id:
Department Number: 100 Department Name: Finance Manager Id:


Exercice 7 : Utiliser des curseurs explicites
1. Créez un bloc PL/SQL qui détermine les n salaires les plus élevés parmi les employés.
a. Exécutez le script lab_07_01.sql afin de créer une nouvelle table nommée
top_salaries, pour le stockage des salaires des employés.
b. Dans la section déclarative, déclarez une variable v_num de type NUMBER
contenant un nombre n qui représente le nombre n d'employés ayant les salaires
les plus élevés dans la table employees. Par exemple, pour afficher les cinq
salaires les plus élevés, entrez 5. Déclarez une autre variable sal de type
employees.salary. Déclarez le curseur c_emp_cursor qui extrait les
salaires des employés par ordre décroissant. Rappelez-vous que les salaires ne
doivent pas être dupliqués.
DECLARE
v_num NUMBER(3) := 5;

SELECT salary
FROM employees
ORDER BY salary DESC;
c. Dans la section exécutable, ouvrez la boucle, extrayez les n salaires les plus élevés
et insérez-les dans la table top_salaries. Vous pouvez utiliser une boucle
simple pour opérer sur les données. Essayez également d'utiliser les attributs
%ROWCOUNT et %FOUND pour la condition de sortie.
BEGIN
OPEN c_emp_cursor;
FETCH c_emp_cursor INTO v_sal;
WHILE c_emp_cursor%ROWCOUNT <= v_num AND c_emp_cursor%FOUND LOOP
INSERT INTO top_salaries (salary)
VALUES (v_sal);
FETCH c_emp_cursor INTO v_sal;
END LOOP;
CLOSE c_emp_cursor;
END;

d. Après l'insertion dans la table top_salaries, affichez les lignes avec une
instruction SELECT. La sortie illustrée présente les cinq salaires les plus élevés de
la table employees.
/
SELECT * FROM top_salaries;
e. Testez les cas particuliers tels que v_num = 0 ou v_num supérieur au nombre

d'employés de la table employees. Videz la table top_salaries après
chaque test.
2. Créez un bloc PL/SQL pour effectuer les tâches suivantes :

a. Dans la section déclarative, déclarez une variable v_deptno de type NUMBER et
affectez-lui la valeur contenant le numéro du département.
DECLARE
v_deptno NUMBER := 10;
b. Déclarez un curseur nommé c_emp_cursor qui extrait les valeurs

last_name, salary et manager_id pour les employés qui travaillent dans
le département indiqué par v_deptno.
SELECT last_name, salary,manager_id
FROM employees
c. Dans la section exécutable, utilisez la boucle FOR de curseur pour opérer sur les
données extraites. Si le salaire de l'employé est inférieur à 5 000 et que l'ID du
manager est 101 ou 124, affichez le message suivant : <<last_name>> Due for a
raise. Dans le cas contraire, affichez le message suivant : <<last_name>> Not due
for a raise.

BEGIN
FOR emp_record IN c_emp_cursor

LOOP
IF emp_record.salary < 5000 AND (emp_record.manager_id=101 OR
emp_record.manager_id=124) THEN
DBMS_OUTPUT.PUT_LINE (emp_record.last_name || ' Due for a
raise');
ELSE
DBMS_OUTPUT.PUT_LINE (emp_record.last_name || ' Not Due for a
raise');
END IF;
END LOOP;
END;
d. Testez les cas suivants à l'aide du bloc PL/SQL :
Department ID Message

10 Whalen Due for a raise
20 Hartstein Not Due for a raise
Fay Not Due for a raise
50 Weiss Not Due for a raise
Fripp Not Due for a raise
Kaufling Not Due for a raise
Vollman Not Due for a raise. . .
. . .
OConnell Due for a raise
Grant Due for a raise
80 Russell Not Due for a raise
Partners Not Due for a raise
Errazuriz Not Due for a raise
Cambrault Not Due for a raise
. . .
Livingston Not Due for a raise
Johnson Not Due for a raise
3. Ecrivez un bloc PL/SQL qui déclare et utilise des curseurs avec des paramètres.
Dans une boucle, utilisez un curseur pour extraire, à partir de la table departments, le
numéro et le nom de tous les départements pour lesquels la valeur department_id est
inférieure à 100. Transmettez le numéro du département à un autre curseur en tant que
paramètre pour extraire de la table employees les informations (nom de famille, poste,
date d'embauche et salaire) concernant les employés travaillant dans ce département et
dont la valeur employee_id est inférieure à 120.

a. Dans la section déclarative, déclarez un curseur nommé c_dept_cursor afin
d'extraire les valeurs department_id et department_name pour les
départements dont la valeur department_id est inférieure à 100. Triez le

résultat en fonction de la valeur department_id.
DECLARE
CURSOR c_dept_cursor IS
SELECT department_id,department_name
FROM departments
WHERE department_id < 100
ORDER BY department_id;
b. Déclarez un autre curseur nommé emp_cursor, qui accepte le numéro de

département comme paramètre et qui extrait les valeurs last_name, job_id,
hire_date et salary des employés dont la valeur employee_id est
inférieure à 120 et qui travaillent dans ce département.

CURSOR c_emp_cursor(v_deptno NUMBER) IS
SELECT last_name,job_id,hire_date,salary
FROM employees
WHERE department_id = v_deptno
AND employee_id < 120;
c. Déclarez des variables contenant les valeurs extraites de chaque curseur. Utilisez
l'attribut %TYPE dans la déclaration des variables.
v_current_deptno departments.department_id%TYPE;
v_current_dname departments.department_name%TYPE;
v_ename employees.last_name%TYPE;
v_job employees.job_id%TYPE;
v_hiredate employees.hire_date%TYPE;
d. Ouvrez c_dept_cursor, utilisez une boucle simple et extrayez (fetch) les

valeurs dans les variables déclarées. Affichez le numéro et le nom du département.
BEGIN
OPEN c_dept_cursor;
LOOP
FETCH c_dept_cursor INTO v_current_deptno,v_current_dname;
EXIT WHEN c_dept_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE ('Department Number : ' ||
v_current_deptno || ' Department Name : ' || v_current_dname);
e. Pour chaque département, ouvrez c_emp_cursor en transmettant le numéro de

département actuel comme paramètre. Ouvrez une autre boucle et extrayez les
valeurs de emp_cursor dans des variables, puis affichez tous les détails extraits
de la table employees.
Remarque : Vous pouvez afficher une ligne après avoir affiché les détails de
chaque département. Utilisez les attributs appropriés pour la condition de sortie.
Par ailleurs, avant d'ouvrir le curseur, déterminez si un curseur est déjà ouvert.

IF c_emp_cursor%ISOPEN THEN
CLOSE c_emp_cursor;
END IF;
OPEN c_emp_cursor (v_current_deptno);
LOOP
FETCH c_emp_cursor INTO v_ename,v_job,v_hiredate,v_sal;
DBMS_OUTPUT.PUT_LINE (v_ename || ' ' || v_job
|| ' ' || v_hiredate || ' ' || v_sal);
END LOOP;
DBMS_OUTPUT.PUT_LINE('-----------------------------------------------
-----------------------------------------');
CLOSE c_emp_cursor;
f. Fermez toutes les boucles et tous les curseurs, puis terminez la section exécutable.
Exécutez le script.

END LOOP;
CLOSE c_dept_cursor;
END;

Le résultat est illustré ci-après.

Exercice 8 : Traiter les exceptions
1. Cet exercice illustre l'utilisation des exceptions prédéfinies. Ecrivez un bloc PL/SQL
permettant de sélectionner le nom d'un employé en fonction de son salaire.
a. Supprimez tous les enregistrements de la table messages.
DELETE FROM MESSAGES;

SET VERIFY OFF
b. Dans la section déclarative, déclarez deux variables : v_ename de type

employees.last_name et v_emp_sal de type employees.salary.
Initialisez cette dernière variable avec la valeur 6000.
DECLARE
v_ename employees.last_name%TYPE;
v_emp_sal employees.salary%TYPE := 6000;

c. Dans la section exécutable, extrayez le nom des employés dont le salaire est égal à
la valeur de v_emp_sal.
Remarque : N'utilisez pas de curseurs explicites.
Si une seule ligne est renvoyée pour le salaire entré, insérez dans la table
messages le nom de l'employé et le montant de son salaire.
BEGIN
SELECT last_name
INTO v_ename
FROM employees
WHERE salary = v_emp_sal;
INSERT INTO messages (results)
VALUES (v_ename || ' - ' || v_emp_sal);
d. Si le salaire entré ne renvoie aucune ligne, traitez l'exception à l'aide d'un

gestionnaire approprié et insérez dans la table messages le message "No
employee with a salary of <salary>".
EXCEPTION
WHEN no_data_found THEN
VALUES ('No employee with a salary of '|| TO_CHAR(v_emp_sal));
e. Si plusieurs lignes sont renvoyées pour le salaire entré, traitez l'exception à l'aide
d'un gestionnaire approprié et insérez dans la table messages le message "More
than one employee with a salary of <salary>".
WHEN too_many_rows THEN
VALUES ('More than one employee with a salary of '||
TO_CHAR(v_emp_sal));

f. Traitez toutes les autres exceptions à l'aide d'un gestionnaire approprié et insérez
dans la table messages le message "Some other error occurred".
WHEN others THEN

VALUES ('Some other error occurred.');
END;
g. Affichez les lignes de la table messages afin de déterminer si le bloc PL/SQL

s'est exécuté correctement. Voici un exemple de résultat :
/
SELECT * FROM messages;

2. Ce point montre comment déclarer des exceptions avec une erreur standard du serveur
Oracle. Utilisez l'erreur ORA-02292 du serveur Oracle (integrity constraint
violated – child record found).
a. Dans la section déclarative, déclarez l'exception e_childrecord_exists.
Associez l'exception déclarée au code d'erreur standard –02292 du serveur
Oracle.
DECLARE
e_childrecord_exists EXCEPTION;
PRAGMA EXCEPTION_INIT(e_childrecord_exists, -02292);
b. Dans la section exécutable, affichez "Deleting department 40....". Incluez une

instruction DELETE afin de supprimer le département dont la valeur
department_id est 40.
BEGIN
DBMS_OUTPUT.PUT_LINE(' Deleting department 40........');
delete from departments where department_id=40;
c. Incluez une section de traitement des exceptions afin de traiter l'exception

e_childrecord_exists et d'afficher le message approprié. Voici un
EXCEPTION
WHEN e_childrecord_exists THEN
DBMS_OUTPUT.PUT_LINE(' Cannot delete this department. There are
employees in this department (child records exist.) ');
END;


Exercice 9 : Créer des procédures et des fonctions stockées
1. Chargez le script lab_02_04_soln.sql que vous avez créé au point 4 de

l'exercice 2.
a. Modifiez le script afin de convertir le bloc anonyme en procédure nommée
greet.
CREATE PROCEDURE greet IS

today DATE:=SYSDATE;
tomorrow today%TYPE;
...
b. Exécutez le script afin de créer la procédure.

c. Enregistrez ce script sous le nom lab_09_01_soln.sql.
d. Cliquez sur le bouton Clear afin de vider l'espace de travail.
e. Créez et exécutez un bloc anonyme afin d'appeler la procédure greet. Voici un

BEGIN
greet;
END;
2. Chargez le script lab_09_01_soln.sql.

a. Supprimez la procédure greet en exécutant la commande suivante :
DROP PROCEDURE greet
b. Modifiez la procédure afin qu'elle accepte un argument de type VARCHAR2.

Nommez l'argument p_name.
CREATE PROCEDURE greet(p_name VARCHAR2) IS

today DATE:=SYSDATE;
tomorrow today%TYPE;
c. Affichez "Hello <name>" à la place de "Hello World".
BEGIN
tomorrow:=today +1;
DBMS_OUTPUT.PUT_LINE(' Hello '|| p_name);
d. Enregistrez le script sous le nom lab_09_02_soln.sql.

e. Exécutez le script afin de créer la procédure.

f. Créez et exécutez un bloc anonyme afin d'appeler la procédure greet avec un
paramètre. Voici un exemple de résultat :
BEGIN
greet('Neema');
END;


données des tables

B
Description et

DIAGRAMME ENTITE/RELATION
Oracle Database 11g : Les fondamentaux du langage PL/SQL B - 2

Tables du schéma
SELECT * FROM tab;

Table regions
DESCRIBE regions
SELECT * FROM regions;

Table countries
DESCRIBE countries
SELECT * FROM countries;

Table locations
DESCRIBE locations;
SELECT * FROM locations;

Table departments
DESCRIBE departments
SELECT * FROM departments;

Table jobs
DESCRIBE jobs
SELECT * FROM jobs;

Table employees
DESCRIBE employees

Table employees (suite)

Les en-têtes des colonnes commission_pct, manager_id et department_id sont
comm, mgrid et deptid dans la capture d'écran ci-après, afin que les valeurs de la table
correspondent.
SELECT * FROM employees;



Table job_history
DESCRIBE job_history
SELECT * FROM job_history;



Utiliser SQL Developer

Objectifs
Cette annexe traite des sujets suivants :

• Dresser la liste des principales fonctionnalités d'Oracle SQL
Developer
• Installer Oracle SQL Developer
• Identifier les options de menus d'Oracle SQL Developer
• Créer une connexion de base de données
• Gérer des objets de base de données
• Utiliser SQL Worksheet

• Exécuter des instructions et des scripts SQL
• Modifier et déboguer des instructions PL/SQL
• Créer et enregistrer des états
Objectifs
Cette annexe présente SQL Developer, outil graphique qui simplifie les tâches de
développement de base de données. Elle explique comment utiliser SQL Worksheet pour
exécuter des instructions et des scripts SQL. Elle explique également comment modifier et
déboguer du code PL/SQL.
Oracle Database 11g : Les fondamentaux du langage PL/SQL C - 2

Oracle SQL Developer
• Oracle SQL Developer est un outil graphique qui optimise

la productivité et simplifie les tâches de développement de
base de données.
• Vous pouvez vous connecter à tout schéma de base de
données Oracle cible en utilisant l'authentification de base
de données Oracle standard.

SQL Developer
Oracle SQL Developer

Oracle SQL Developer est un outil graphique gratuit, conçu pour optimiser votre productivité
et simplifier les tâches quotidiennes de gestion de base de données. En quelques clics, vous
pouvez facilement créer et déboguer des procédures stockées, tester des instructions SQL et
afficher les plans de l'optimiseur.
Cet outil de développement simplifie les tâches suivantes :
• Consultation et gestion des objets de base de données
• Exécution d'instructions et de scripts SQL
• Modification et débogage d'instructions PL/SQL
• Création d'états
Vous pouvez vous connecter à tout schéma de base de données Oracle cible en utilisant
l'authentification de base de données Oracle standard. Une fois connecté, vous effectuez les
opérations de votre choix sur les objets de la base.

SQL Developer : Principales fonctionnalités
• Est développé en Java

• Prend en charge les plates-formes Windows, Linux
et Mac OS X
• Offre une connectivité par défaut au moyen du pilote
JDBC Thin
• Ne nécessite pas de programme d'installation
• Se connecte à toute base de données Oracle de
version 9.2.0.1 ou supérieure

• Est fourni avec JRE 1.5
SQL Developer : Principales fonctionnalités

Oracle SQL Developer est développé en langage Java et tire ainsi parti de l'environnement
IDE (Integrated Development Environment) d'Oracle JDeveloper. Cet outil peut être exécuté
sur les plates-formes Windows, Linux et Mac OS X. Vous pouvez l'installer sur le serveur de
base de données et vous connecter à distance depuis votre poste de travail, ce qui vous permet
d'éviter le trafic réseau client-serveur.
La connectivité par défaut à la base de données passe par le pilote JDBC (Java Database
Connectivity) Thin. Il n'est donc pas nécessaire de disposer d'un répertoire d'origine Oracle
Home. SQL Developer ne requiert aucun programme d'installation. Vous avez simplement à
décompresser le fichier après l'avoir téléchargé.
Avec SQL Developer, les utilisateurs peuvent se connecter aux bases de données Oracle de
version 9.2.0.1 ou supérieure, et à toutes les éditions de la base de données Oracle, y compris
Express Edition. SQL Developer est fourni avec JRE (Java Runtime Environment) 1.5, avec
une archive tools.jar supplémentaire pour la prise en charge des clients Windows. Les
clients autres n'ont besoin que du kit JDK (Java Development Kit) 1.5.

Installer SQL Developer
Téléchargez le kit Oracle SQL Developer et décompressez-le

dans le répertoire de votre choix sur votre ordinateur.

Installer SQL Developer

Oracle SQL Developer ne requiert aucun programme d'installation. Seul un outil de
décompression suffit.
Pour installer SQL Developer, procédez de la manière suivante :
1. Créez un dossier <local drive>:\SQL Developer.
2. Téléchargez le kit SQL Developer à partir du site :
http://www.oracle.com/technology/software/products/sql/index.html
3. Décompressez le kit SQL Developer dans le dossier créé à l'étape 1.
Pour démarrer SQL Developer, naviguez jusqu'au dossier <local drive>:\SQL
Developer et cliquez deux fois sur sqldeveloper.exe.

Menus de SQL Developer
2 4 6
1 3 5

Menus de SQL Developer

SQL Developer comprend deux onglets de navigation principaux :
• Onglet Connections : Cet onglet, appelé Navigateur de connexions (Connections
Navigator), vous permet de naviguer parmi les objets et les utilisateurs de base de
données auxquels vous avez accès.
• Onglet Reports : Cet onglet vous permet de lancer des états prédéfinis ou de créer et
d'ajouter vos propres états.
SQL Developer utilise la partie gauche de la fenêtre pour la navigation et la sélection des
objets, et la partie droite pour l'affichage des informations relatives aux objets sélectionnés.
Vous pouvez personnaliser de nombreux aspects de la présentation et du comportement de
SQL Developer en définissant des préférences.
Le bandeau supérieur contient des menus standard et des menus spécifiques de SQL
Developer.
1. Le menu View contient des options qui définissent les éléments affichés dans l'interface
SQL Developer.
2. Le menu Navigate contient des options qui permettent d'accéder à différents volets et
d'exécuter des sous-programmes.
3. Le menu Run contient les options Run File et Execution Profile, qui peuvent être
utilisées quand une fonction ou une procédure est sélectionnée.
4. Le menu Debug contient des options qui peuvent être utilisées quand une fonction ou
une procédure est sélectionnée.
5. Le menu Source propose des options permettant de modifier des fonctions et des
procédures.
6. Le menu Tools permet d'appeler des outils SQL Developer tels que SQL*Plus,
Preferences et SQL Worksheet.
• Pour utiliser SQL Developer, il vous faut au moins une

connexion de base de données.
• Vous pouvez créer et tester des connexions :
– pour plusieurs bases de données
– pour plusieurs schémas
• SQL Developer importe automatiquement les connexions
définies dans le fichier tnsnames.ora de votre système.
• Vous pouvez exporter des connexions dans un fichier XML.

• Chaque nouvelle connexion de base de données que vous
créez apparaît dans la hiérarchie du navigateur de
connexions.

Une connexion est un objet SQL Developer qui précise les informations nécessaires pour se
connecter à une base de données spécifique à l'aide d'un nom utilisateur particulier. Pour
utiliser SQL Developer, il vous faut au moins une connexion de base de données. Il peut s'agir
d'une connexion existante, ou d'une connexion que vous créez ou importez.
Vous pouvez créer et tester des connexions pour plusieurs bases de données et plusieurs
schémas.
Par défaut, le fichier tnsnames.ora se trouve dans le répertoire
$ORACLE_HOME/network/admin. Il peut également se trouver dans le répertoire indiqué
par la variable d'environnement TNS_ADMIN ou une valeur du registre. Lorsque vous
démarrez SQL Developer et affichez la boîte de dialogue de connexion à la base de données,
SQL Developer importe automatiquement toutes les connexions définies dans le fichier
tnsnames.ora de votre système.
Remarque : Sur les systèmes Windows, si le fichier tnsnames.ora existe mais que SQL
Developer n'utilise pas ses connexions, définissez TNS_ADMIN comme variable
d'environnement système.
Vous pouvez exporter des connexions dans un fichier XML pour les réutiliser ultérieurement.
Vous pouvez créer des connexions supplémentaires avec des noms utilisateur différents pour
la même base de données ou pour des bases de données différentes.


Créer une connexion de base de données (suite)

Pour créer une connexion de base de données, procédez de la manière suivante :
1. Cliquez deux fois sur <your_path>\sqldeveloper\sqldeveloper.exe.
2. Dans l'onglet Connections, cliquez avec le bouton droit de la souris sur Connections et
sélectionnez New Database Connection.
3. Entrez le nom de la connexion, le nom utilisateur, le mot de passe, le nom d'hôte et
l'identificateur système (SID) de la base à laquelle vous souhaitez vous connecter.
4. Cliquez sur Test pour vérifier que la connexion est définie correctement.
5. Cliquez sur Connect.
Dans la partie inférieure de la page, dans l'onglet Basic, renseignez les champs suivants :
• Hostname : Système hôte de la base de données Oracle.
• Port : Port d'écoute.
• SID : Nom de la base de données.
• Service Name : Nom de service réseau pour une connexion à une base de données
distante.
Si vous cochez la case Save Password, le mot de passe est enregistré dans un fichier XML.
Vous n'aurez donc pas à le saisir à nouveau la prochaine fois que vous utiliserez cette
connexion SQL Developer.

Consulter les objets de base de données
Utilisez le navigateur de base de données pour :

• naviguer dans la liste des objets d'un schéma de base
de données
• vérifier d'un coup d'oeil la définition d'un objet

Consulter les objets de base de données

Une fois que vous avez créé une connexion de base de données, vous pouvez utiliser le
navigateur de base de données pour naviguer parmi les nombreux objets d'un schéma de
la base : tables, vues, index, packages, procédures, déclencheurs, types, etc.
SQL Developer utilise la partie gauche de la fenêtre pour accéder et sélectionner des objets,
et la partie droite pour afficher des informations relatives aux objets sélectionnés. Vous avez
la possibilité de changer la présentation de SQL Developer en définissant des préférences.
Vous pouvez afficher la définition des objets dans plusieurs onglets présentant les
informations extraites du dictionnaire de données. Par exemple, si vous sélectionnez une table
dans le navigateur, les informations telles que les colonnes, les contraintes, les privilèges,
les statistiques et les déclencheurs sont présentées dans des onglets distincts, ce qui facilite
leur lecture.
Pour afficher la définition de la table EMPLOYEES comme dans la diapositive ci-dessus,
procédez de la manière suivante :
1. Développez le noeud Connections dans le navigateur de connexions (onglet
Connections).
2. Développez Tables.
3. Cliquez deux fois sur EMPLOYEES.
Dans l'onglet Data, vous pouvez entrer de nouvelles lignes, mettre à jour les données et
valider les modifications apportées à la base.

Créer un objet de schéma
• SQL Developer prend en charge la création de tout objet de

schéma via :
– l'exécution d'une instruction SQL dans SQL Worksheet
– l'utilisation du menu contextuel
• Modifiez les objets au moyen de la boîte de dialogue
d'édition ou à partir de l'un des nombreux menus
contextuels.
• Consultez le code LDD pour voir les ajustements tels que
la création d'un nouvel objet ou la modification d'un objet de

schéma existant.
Créer un objet de schéma

SQL Developer permet de créer n'importe quel objet de schéma via l'exécution d'une
instruction SQL dans SQL Worksheet. Une autre solution consiste à créer des objets à l'aide
des menus contextuels. Une fois les objets créés, vous pouvez les modifier en utilisant la boîte
de dialogue d'édition ou l'un des menus contextuels.
A mesure que des objets sont créés ou modifiés, vous pouvez voir ces ajustements dans le
code LDD (langage de définition de données). L'option Export DDL vous permet de créer
l'intégralité de ce code pour un ou plusieurs objets du schéma.
La diapositive ci-dessus illustre la création d'une table à l'aide du menu contextuel. Pour
ouvrir une boîte de dialogue afin de créer une nouvelle table, cliquez avec le bouton droit de
la souris sur Tables et sélectionnez Create TABLE. Les boîtes de dialogue permettant de
créer et de modifier des objets de base de données proposent plusieurs onglets correspondant
à différents regroupements logiques de propriétés pour le type d'objet concerné.

Créer une nouvelle table : Exemple

Créer une nouvelle table : Exemple

Dans la boîte de dialogue Create Table, si vous ne cochez pas la case Show Advanced
Options, vous pouvez créer rapidement une table en indiquant les colonnes et quelques
caractéristiques courantes.
En revanche, si vous sélectionnez Show Advanced Options, la boîte de dialogue Create
Table affiche plusieurs onglets dans lesquels vous pouvez définir davantage de
caractéristiques lors de la création de la table.
L'exemple ci-dessus présente la création de la table DEPENDENTS lorsque la case Show
Advanced Options est cochée.
Pour créer une nouvelle table, procédez de la manière suivante :
1. Dans le navigateur de connexions, cliquez avec le bouton droit de la souris sur Tables.
2. Sélectionnez Create TABLE.
3. Dans la boîte de dialogue Create Table, cochez la case Show Advanced Options.
4. Indiquez les informations relatives aux colonnes.
5. Cliquez sur OK.
De manière facultative, vous pouvez indiquer une clé primaire dans l'onglet Primary Key de
la boîte de dialogue. Vous serez parfois amené à modifier une table que vous avez créée. Pour
modifier une table, cliquez sur celle-ci avec le bouton droit de la souris dans le navigateur de
connexions et sélectionnez Edit.

• Utilisez SQL Worksheet pour entrer et exécuter des

instructions SQL, PL/SQL et SQL*Plus.
• Indiquez les actions qui peuvent être traitées par la
connexion de base de données associée à la feuille de
calcul.


Lorsque vous vous connectez à une base de données, une fenêtre SQL Worksheet s'ouvre
alors automatiquement. Vous pouvez utiliser cette fenêtre pour entrer et exécuter des
instructions SQL, PL/SQL et SQL*Plus. SQL Worksheet ne prend en charge que certaines
instructions SQL*Plus. Les instructions qui ne peuvent pas être traitées sont ignorées et ne
sont pas transmises à la base.
Vous pouvez indiquer les actions qui peuvent être traitées par la connexion de base de
données associée à la feuille de calcul, par exemple :
• Créer une table
• Insérer des données
• Créer et modifier un déclencheur
• Enregistrer dans un fichier les données sélectionnées
Pour afficher une feuille de calcul SQL Worksheet, vous avez le choix entre deux méthodes :
• Sélectionner Tools > SQL Worksheet
• Cliquer sur l'icône Open SQL Worksheet

2 4 6
1 5 7 8
3

Utiliser SQL Worksheet (suite)

Vous avez la possibilité d'utiliser des touches de raccourci ou des icônes pour effectuer
certaines tâches, par exemple exécuter une instruction SQL ou un script, ou encore afficher
l'historique des instructions SQL que vous avez lancées. La barre d'outils SQL Worksheet
contient des icônes permettant d'effectuer les tâches suivantes :
1. Execute Statement : Exécute l'instruction désignée par le curseur dans la zone Enter
SQL Statement. Vous pouvez utiliser des variables attachées (bind variables) dans les
instructions SQL, mais pas de variables de substitution.
2. Run Script : Exécute toutes les instructions de la zone Enter SQL Statement à l'aide de
l'utilitaire d'exécution de script. Vous pouvez utiliser des variables de substitution dans
les instructions SQL, mais pas de variables attachées.
3. Commit : Ecrit les modifications dans la base de données et termine la transaction.
4. Rollback : Supprime les modifications apportées sans les écrire dans la base de données
et termine la transaction.
5. Cancel : Interrompt l'exécution des instructions en cours.
6. SQL History : Affiche une boîte de dialogue contenant des informations sur les
instructions SQL que vous avez exécutées.
7. Execute Explain Plan : Génère le plan d'exécution. Vous pouvez afficher celui-ci en
cliquant sur l'onglet Explain.
8. Clear : Efface les instructions figurant dans la zone Enter SQL Statement.

Utilisez la zone Enter SQL Statement pour entrer une ou

plusieurs instructions SQL.


Dans SQL Worksheet, vous pouvez utiliser la zone Enter SQL Statement pour entrer une ou
plusieurs instructions SQL. Si vous indiquez une seule instruction, le point-virgule final est
facultatif.
Lors de la saisie, les mots-clés SQL sont automatiquement mis en surbrillance. Pour exécuter
une instruction SQL, désignez-la avec le curseur et cliquez sur l'icône Execute Statement.
Vous pouvez également appuyer sur la touche [F9].
Pour exécuter plusieurs instructions SQL et afficher les résultats, cliquez sur l'icône Run
Script. Vous pouvez également appuyer sur la touche [F5].
L'exemple présenté dans la diapositive ci-dessus comprend plusieurs instructions SQL.
La première est donc terminée par un point-virgule. Le curseur désignant la première
instruction, la zone Results affiche les résultats lorsque l'instruction est exécutée.

Afficher le plan d'exécution

Afficher le plan d'exécution

Vous pouvez exécuter un script SQL et afficher le plan d'exécution. Pour exécuter un fichier
script SQL, procédez de la manière suivante :
1. A l'aide du bouton droit de la souris, cliquez dans la zone Enter SQL Statement et
sélectionnez Open File dans le menu contextuel.
2. Dans la boîte de dialogue Open, cliquez deux fois sur le fichier .sql.
3. Cliquez sur l'icône Run Script.
Lorsque vous cliquez deux fois sur le fichier .sql, les instructions SQL sont chargées dans
la zone Enter SQL Statement. Vous pouvez exécuter le script complet ou chaque ligne
individuellement. Les résultats sont affichés dans la zone Script Output.
La diapositive ci-dessus présente le plan d'exécution. L'icône Execute Explain Plan permet de
générer le plan d'exécution. Ce dernier correspond à la séquence d'opérations qui sera réalisée
pour exécuter l'instruction. Vous pouvez visualiser le plan d'exécution dans l'onglet Explain.

Mettre en forme le code SQL
Avant mise
en forme

Après mise
en forme
Mettre en forme le code SQL

Vous pouvez améliorer la présentation du code SQL en jouant sur l'indentation, l'espacement,
la mise en majuscules et la séparation des lignes. SQL Developer offre une fonctionnalité
permettant de mettre en forme le code SQL.
Pour mettre en forme le code SQL, cliquez avec le bouton droit de la souris dans la zone
d'édition des instructions et sélectionnez Format SQL.
Dans l'exemple présenté ci-dessus, vous pouvez constater qu'avant mise en forme du code
SQL, les mots-clés n'apparaissaient pas en majuscules et l'instruction n'était pas correctement
indentée. Après l'application de l'option Format SQL, le code SQL apparaît plus clairement
par une mise en majuscules des mots-clés et une indentation appropriée.

Utiliser des snippets
Les snippets sont des fragments de code représentant une

syntaxe ou des exemples.

Utiliser des snippets

Vous pouvez avoir besoin de certains fragments de code lorsque vous utilisez SQL Worksheet
ou pendant la création ou la modification d'une fonction ou d'une procédure PL/SQL. A cet
effet, SQL Developer fournit une fonctionnalité appelée Snippets. Les snippets sont des
fragments de code, tels que des fonctions SQL, des conseils de l'optimiseur et diverses
techniques de programmation PL/SQL. Ces snippets peuvent être insérés dans la fenêtre
d'édition par simple glissement.
Pour afficher les snippets disponibles, sélectionnez View > Snippets.
La fenêtre Snippets s'affiche dans la partie droite de l'écran. Utilisez la liste déroulante pour
sélectionner un groupe. Le bouton Snippets situé dans la marge de droite permet d'afficher à
nouveau la fenêtre Snippets si celle-ci est masquée.

Utiliser des snippets : Exemple
Insérer
un snippet
Modifier
le snippet

Utiliser des snippets : Exemple

Pour insérer un snippet dans le code d'une feuille de calcul SQL ou d'une fonction ou
procédure PL/SQL, faites-le glisser de la fenêtre Snippets jusqu'à l'emplacement souhaité dans
le code. Vous pouvez ensuite modifier la syntaxe pour que la fonction SQL soit valide dans le
contexte en cours. Pour afficher la description succincte d'une fonction SQL dans une
info-bulle, placez le curseur sur le nom de cette fonction.
La diapositive ci-dessus présente le déplacement de CONCAT(char1, char2) à partir du
groupe Character Functions de la fenêtre Snippets. La syntaxe de la fonction CONCAT est
alors modifiée de la façon suivante :
SELECT CONCAT(first_name, last_name)
FROM employees;

Utiliser SQL*Plus
• SQL Worksheet ne prend pas en charge toutes les

instructions SQL*Plus.
• Vous pouvez appeler l'interface SQL*Plus en mode ligne
de commande à partir de SQL Developer.

Utiliser SQL*Plus
SQL Worksheet prend en charge certaines instructions SQL*Plus. Celles-ci doivent être
interprétées par SQL Worksheet avant d'être transmises à la base de données. Toute
instruction SQL*Plus qui n'est pas prise en charge par SQL Worksheet est ignorée et n'est pas
transmise à la base. Par exemple, les instructions SQL*Plus suivantes ne sont pas prises en
charge par SQL Worksheet :
• append
• archive
• attribute
• break
Pour connaître la liste complète des instructions SQL*Plus prises en charge et non prises en
charge par SQL Worksheet, reportez-vous à l'aide en ligne de SQL Developer.
Pour afficher la fenêtre de commande SQL*Plus, sélectionnez SQL*Plus dans le menu Tools.
Pour que cette fonctionnalité soit disponible, il faut que le système sur lequel vous utilisez
SQL Developer dispose d'un répertoire d'origine ou d'un dossier Oracle Home dans lequel
l'exécutable SQL*Plus est installé. Si l'emplacement du fichier exécutable SQL*Plus n'est pas
indiqué dans vos préférences SQL Developer, vous êtes invité à le préciser.

Créez un bloc anonyme et affichez le résultat des instructions

du package DBMS_OUTPUT.


Vous pouvez créer un bloc anonyme et afficher le résultat des instructions du package
DBMS_OUTPUT. Pour cela, procédez de la manière suivante :
1. Entrez le code PL/SQL dans la zone Enter SQL Statement.
2. Cliquez sur l'onglet DBMS Output. Cliquez ensuite sur l'icône Enable DBMS Output
pour activer la sortie serveur.
3. Cliquez sur l'icône Execute Statement au-dessus de la zone Enter SQL Statement.
Cliquez ensuite sur le panneau DBMS Output pour afficher les résultats.

Modifier le code PL/SQL
Utilisez les fonctionnalités complètes de l'éditeur pour les

programmes PL/SQL.

Modifier le code PL/SQL

Vous avez la possibilité d'apporter des modifications à votre code PL/SQL. Pour cela, utilisez
l'éditeur très complet proposé par SQL Developer pour les programmes PL/SQL. Outre les
fonctionnalités d'édition courantes, il intègre des fonctionnalités personnalisables de mise en
évidence de la syntaxe PL/SQL, notamment :
• Signets
• Ecriture automatique
• Masquage
• Recherche et remplacement
Pour modifier le code PL/SQL, cliquez sur le nom d'un objet dans le navigateur de
connexions, puis cliquez sur l'icône Edit. Vous pouvez éventuellement cliquer deux fois sur
le nom de l'objet pour appeler la page à onglets Object Definition et la page Edit. Vous ne
pouvez procéder à une mise à jour que dans l'onglet Edit.
La diapositive ci-dessus présente la fonctionnalité Code Insight. Par exemple, si vous entrez
DBMS_OUTPUT. et appuyez sur [Ctrl] + [Barre d'espacement], vous pouvez sélectionner un
membre de ce package dans la liste proposée. Notez que, par défaut, la fonctionnalité Code
Insight est appelée automatiquement si vous faites une pause de plus d'une seconde après
avoir entré un point (".").
Lorsque vous utilisez l'éditeur de code pour modifier du code PL/SQL, vous avez le choix
entre les options Compile et Compile for Debug.

Créer une procédure PL/SQL

2
Créer une procédure PL/SQL

Vous pouvez créer des fonctions, des procédures et des packages PL/SQL à l'aide de SQL
Developer. Pour créer une procédure PL/SQL, procédez de la manière suivante :
1. A l'aide du bouton droit de la souris, cliquez sur le noeud Procedures dans le navigateur
de connexions afin d'appeler le menu contextuel et sélectionnez Create Procedure.
2. Dans la boîte de dialogue Create Procedure, indiquez les informations relatives à la
procédure et cliquez sur OK.
Remarque : Veillez à appuyer sur [Entrée] avant de cliquer sur OK.
L'exemple présenté dans la diapositive ci-dessus crée une procédure nommée EMP_LIST.
Les nom et type de paramètre par défaut sont remplacés respectivement par pMaxRows et
NUMBER.

Compiler une procédure PL/SQL

Compiler une procédure PL/SQL

Une fois que vous avez indiqué les informations relatives aux paramètres dans la boîte de
dialogue Create Procedure et cliqué sur OK, l'onglet Procedure s'affiche dans la fenêtre de
droite. Vous pouvez alors remplacer le bloc anonyme par votre code PL/SQL.
Pour compiler le sous-programme PL/SQL, cliquez sur le bouton Save dans la barre d'outils.
Si vous développez Procedures dans le navigateur de connexions, vous constatez qu'un noeud
a été ajouté pour la nouvelle procédure.
Lorsqu'un sous-programme PL/SQL non valide est détecté par SQL Developer, l'icône
correspondante est marquée d'un X rouge dans le navigateur de connexions. Les erreurs de
compilation sont affichées dans la fenêtre Log. Cliquez deux fois sur une erreur pour accéder
à la ligne dans laquelle elle a été détectée. SQL Developer affiche également des erreurs et
des conseils dans la marge droite. Si vous placez le curseur sur l'une des barres rouges
affichées dans cette marge, le message d'erreur correspondant apparaît. Par exemple, si le
message indique une erreur de mise en forme, modifiez le code en conséquence et cliquez sur
l'icône Compile.

Exécuter une procédure PL/SQL

Exécuter une procédure PL/SQL

Après avoir créé et compilé une procédure PL/SQL, vous pouvez l'exécuter à l'aide de SQL
Developer. Pour exécuter une procédure PL/SQL, cliquez avec le bouton droit de la souris sur
son nom dans le navigateur de connexions dans la partie gauche de l'écran et sélectionnez
Run. Vous pouvez également utiliser le bouton Run dans la fenêtre de droite. La boîte de
dialogue Run PL/SQL apparaît alors. Cette dernière vous permet de sélectionner la procédure
ou la fonction cible à exécuter et affiche une liste de paramètres pour la cible sélectionnée.
Vous pouvez utiliser la zone PL/SQL Block pour indiquer les paramètres à transmettre au
programme et pour gérer les types de retour complexes. Après avoir effectué les
modifications nécessaires dans la boîte de dialogue Run PL/SQL, cliquez sur OK.
Vous pouvez voir les résultats attendus dans la fenêtre Running-Log.
Dans l'exemple présenté ci-dessus, PMAXROWS := NULL; est modifié en
PMAXROWS := 5;. Les résultats des 5 lignes renvoyés sont affichés dans la fenêtre
Running-Log.

Déboguer du code PL/SQL

Déboguer du code PL/SQL

Vous pouvez avoir besoin de déboguer une fonction, une procédure ou un package PL/SQL.
SQL Developer offre une prise en charge totale du débogage de code PL/SQL. Pour déboguer
une fonction ou une procédure, procédez de la manière suivante :
1. Cliquez sur le nom de l'objet dans le navigateur de connexions.
2. A l'aide du bouton droit de la souris, cliquez sur l'objet et sélectionnez Compile for
debug.
3. Cliquez sur l'icône Edit. Cliquez ensuite sur l'icône Debug au-dessus du code source.
Si vous ne voyez pas de numéros en regard des lignes de code, cliquez avec le bouton droit de
la souris dans la marge de l'éditeur de code et sélectionnez Toggle Line Numbers.
Le débogueur PL/SQL fournit plusieurs commandes pour contrôler l'exécution des
programmes, notamment Step Into, Step Over, Step Out, Run to Cursor, etc. Pendant que le
programme de débogage est en pause, vous pouvez examiner et modifier la valeur des
variables à partir des fenêtres Smart Data, Watches et Inspector.
La fenêtre Breakpoints répertorie les points d'arrêt définis. Vous pouvez l'utiliser pour ajouter
de nouveaux points d'arrêt ou personnaliser le comportement des points d'arrêt existants.
Remarque : Pour déboguer du code PL/SQL, vous devez disposer des privilèges debug
any procedure et debug connect session.

Générer des états relatifs à la base de données
SQL Developer fournit de nombreux états prédéfinis relatifs à

la base de données et à ses objets.

Générer des états relatifs à la base de données

SQL Developer fournit de nombreux états relatifs à la base de données et à ses objets. Ces
états sont regroupés selon les catégories suivantes :
• About Your Database
• Database Administration
• Table
• PL/SQL
• Security
• XML
• Jobs
• Streams
• All Objects
• Data Dictionary
• User Defined
Pour afficher des états, cliquez sur l'onglet Reports dans la partie gauche de la fenêtre.
Les états sont affichés dans des onglets distincts dans la partie droite de la fenêtre. Pour
chaque état, vous pouvez sélectionner (dans une liste déroulante) la connexion de base de
données à prendre en compte. En ce qui concerne les états relatifs à des objets, ils affichent
uniquement les objets qui sont visibles à l'utilisateur associé à la connexion de base de
données sélectionnée. Les lignes sont généralement ordonnées en fonction du propriétaire
(Owner) de l'objet.

Créer un état défini par l'utilisateur
Vous pouvez créer et enregistrer des états personnalisés en

vue de leur réutilisation.

Créer un état défini par l'utilisateur

Un état défini par l'utilisateur est un état créé par un utilisateur de SQL Developer. Pour créer
un tel état, procédez de la manière suivante :
1. Cliquez avec le bouton droit de la souris sur le noeud User Defined Reports (sous
Reports) et sélectionnez Add Report.
2. Dans la boîte de dialogue Create Report Dialog, indiquez le nom de l'état et
l'interrogation SQL permettant d'extraire les informations de l'état. Cliquez ensuite sur
Apply.
Dans l'exemple présenté ci-dessus, le nom de l'état est emp_sal. La description facultative
fournie indique que l'état contient des informations sur les employés dont le salaire est
supérieur ou égal à 10 000. L'instruction SQL complète permettant d'extraire les informations
à afficher dans l'état défini par l'utilisateur est indiquée dans la zone de code SQL. De manière
facultative, vous pouvez ajouter une info-bulle à afficher lorsque le curseur passe sur le nom
de l'état dans l'arborescence Reports.
Vous pouvez classer hiérarchiquement les états définis par l'utilisateur dans des dossiers et
sous-dossiers. Pour créer un dossier destiné aux états définis par l'utilisateur, cliquez avec le
bouton droit de la souris sur le noeud User Defined Reports ou sur un nom de dossier figurant
sous ce noeud, puis sélectionnez Add Folder.
Les informations relatives aux états définis par l'utilisateur (y compris les dossiers contenant
ces états) sont stockées dans un fichier nommé UserReports.xml qui se trouve dans le
répertoire des informations spécifiques de l'utilisateur.

Synthèse
Cette annexe a traité des sujets suivants :

• Consulter, créer et modifier des objets de base de données
• Exécuter des instructions et des scripts SQL dans
SQL Worksheet
• Modifier et déboguer des instructions PL/SQL
• Créer et enregistrer des états personnalisés

Synthèse
SQL Developer est un outil graphique gratuit conçu pour simplifier les tâches de
développement d'une base de données. Ainsi, à l'aide de cet outil, vous pouvez consulter,
créer et modifier des objets de base de données. Vous pouvez utiliser SQL Worksheet pour
exécuter des instructions et des scripts SQL. Vous pouvez éditer et déboguer du code
PL/SQL. SQL Developer permet en outre de créer et d'enregistrer des jeux d'états
personnalisés en vue de leur réutilisation.

Utiliser SQL*Plus

Objectifs
Cette annexe traite des sujets suivants :

• Se connecter à SQL*Plus
• Editer des commandes SQL
• Mettre en forme la sortie à l'aide de commandes SQL*Plus
• Interagir avec des fichiers script

Objectifs
Cette annexe montre comment créer des instructions SELECT réutilisables plusieurs fois. Elle
explique également comment utiliser les commandes SQL*Plus pour exécuter des instructions
SQL. Enfin, elle présente la mise en forme d'une sortie à l'aide de commandes SQL*Plus,
l'édition de commandes SQL et l'enregistrement de scripts dans SQL*Plus.
Oracle Database 11g : Les fondamentaux du langage PL/SQL D - 2

Interaction entre SQL et SQL*Plus
Instructions SQL
Serveur
SQL*Plus
Résultats d'interrogation
Tampon

Scripts SQL
SQL et SQL*Plus
SQL est un langage de commande qui permet de communiquer avec le serveur Oracle à partir
de n'importe quel outil ou application. Oracle SQL contient de nombreuses extensions.
Lorsque vous entrez une instruction SQL, elle est stockée dans une région de la mémoire
appelée tampon SQL (SQL Buffer) jusqu'à ce que vous entriez une nouvelle instruction SQL.
SQL*Plus est un outil Oracle qui reconnaît les instructions SQL et les soumet à Oracle9i
Server en vue de leur exécution. Cet outil possède son propre langage de commande.
Caractéristiques du langage SQL
• Il est à la portée de nombreux utilisateurs, y compris de ceux ayant peu ou pas
d'expérience en programmation.
• Ce n'est pas un langage procédural.
• Il réduit le temps nécessaire à la création et à la gestion des systèmes.
• Il s'agit d'un langage proche de l'anglais.
Caractéristiques de l'environnement SQL*Plus
• Il accepte la saisie ad hoc d'instructions.
• Il accepte en entrée des instructions SQL stockées dans un fichier.
• Il fournit un éditeur de ligne permettant la modification d'instructions SQL.
• Il contrôle les paramètres d'environnement.
• Il met en forme les résultats des interrogations de manière à générer des états de base.
• Il donne accès à des bases de données locales et distantes.

Différences entre les instructions SQL

et les commandes SQL*Plus
SQL SQL*Plus
• Il s'agit d'un langage. • Il s'agit d'un environnement.
• Il est conforme à la norme • Il s'agit d'un outil
ANSI. propriétaire d'Oracle.
• Les mots-clés ne peuvent pas • Les mots-clés peuvent être
être abrégés. abrégés.
• Les instructions manipulent • Les commandes ne
des données et des peuvent manipuler les
définitions de table dans la valeurs de la base de

base de données. données.
Instructions Tampon Commandes Tampon

SQL SQL SQL*Plus SQL*Plus
SQL et SQL*Plus (suite)

Le tableau suivant offre une comparatif entre SQL et SQL*Plus :
SQL SQL*Plus
Il s'agit d'un langage permettant de Il reconnaît les instructions SQL et les envoie
communiquer avec le serveur Oracle pour au serveur.
accéder aux données.
Il est basé sur la norme SQL définie par l'ANSI Il s'agit de l'interface propriétaire d'Oracle
(American National Standards Institute). qui permet l'exécution d'instructions SQL.
Il manipule les données et les définitions Il ne permet pas la manipulation de valeurs
de table dans la base de données. dans la base de données.
Les instructions SQL sont placées dans Les commandes sont saisies une ligne à la fois
le tampon SQL sur une ou plusieurs lignes. et ne sont pas stockées dans le tampon SQL.
Il n'offre pas de caractère de suite. Le tiret (–) est utilisé en tant que caractère
de suite si la commande excède une ligne.
Les mots-clés ne peuvent pas être abrégés. Les mots-clés peuvent être abrégés.
Il utilise un caractère de fin pour exécuter Il ne requiert pas de caractère de fin pour
les commandes immédiatement. exécuter les commandes immédiatement.
Il utilise des fonctions pour la mise en forme Il utilise des commandes pour la mise en forme
des données. des données.

Présentation de l'environnement SQL*Plus
• Se connecter à SQL*Plus
• Afficher la structure d'une table
• Editer des instructions SQL
• Exécuter du code SQL à partir de SQL*Plus
• Sauvegarder des instructions SQL dans des fichiers
et ajouter des instructions SQL à la fin de ces fichiers
• Exécuter des fichiers sauvegardés
• Charger les commandes d'un fichier dans le tampon

à des fins d'édition
SQL*Plus
SQL*Plus est un environnement dans lequel vous pouvez effectuer les opérations suivantes :
• Exécuter des instructions SQL pour extraire, modifier, ajouter ou supprimer des données
dans la base.
• Mettre en forme les résultats des interrogations, effectuer des calculs sur ces résultats,
les stocker et générer des états.
• Créer des fichiers script afin d'enregistrer des instructions SQL pour une utilisation
ultérieure.
Les commandes SQL* Plus se répartissent dans les catégories principales suivantes :
Catégorie Fonction
Environnement Définition du comportement général des instructions SQL
pour la session.
Mise en forme Mise en forme des résultats des interrogations.
Manipulation de Sauvegarde, chargement et exécution de fichiers script.
fichiers
Exécution Envoi des instructions SQL du tampon SQL au serveur Oracle.
Edition Modification des instructions SQL dans le tampon.
Interaction Création de variables et transmission à des instructions SQL,
affichage des valeurs des variables et affichage des messages à l'écran.
Divers Connexion à la base de données, manipulation de l'environnement
SQL*Plus et affichage des définitions de colonne.

Se connecter à SQL*Plus
sqlplus [username[/password[@database]]]

2
Se connecter à SQL*Plus
Le mode d'appel de SQL*Plus dépend du type de système d'exploration ou d'environnement
Windows utilisé.
Pour vous connecter à partir d'un environnement Windows :
1. Sélectionnez Démarrer (Start) > Programmes (Programs) > Oracle > Application
Development > SQL*Plus.
2. Entrez le nom utilisateur, le mot de passe et le nom de base de données.
Pour vous connecter à partir d'un environnement de ligne de commande :
1. Ouvrez une session sur votre ordinateur.
2. Entrez la commande sqlplus comme indiqué dans la diapositive ci-dessus.
Dans la syntaxe :
username Votre nom utilisateur de base de données
password Votre mot de passe de base de données (il est visible dans ce cas)
@database Chaîne de connexion de base de données
Remarque : Pour préserver la confidentialité de votre mot de passe, ne le saisissez pas à
l'invite du système d'exploitation. Entrez uniquement votre nom utilisateur. Entrez votre mot
de passe lorsque vous êtes invité à le saisir.

Modifier les paramètres

de l'environnement SQL*Plus

Modifier les paramètres de l'environnement SQL*Plus

Si vous le souhaitez, vous pouvez modifier la présentation de l'environnement SQL*Plus à
l'aide de la boîte de dialogue SQL*Plus Properties.
Dans la fenêtre SQL*Plus, cliquez dans la barre de titre à l'aide du bouton droit de la souris et,
dans le menu contextuel qui apparaît, sélectionnez Properties. Vous pouvez alors utiliser
l'onglet Colors de la boîte de dialogue SQL*Plus Properties pour définir l'arrière-plan (Screen
Background) et le texte (Screen Text).

Afficher la structure d'une table
Utilisez la commande SQL*Plus DESCRIBE pour afficher

la structure d'une table :
DESC[RIBE] tablename


Dans SQL*Plus, vous pouvez afficher la structure d'une table à l'aide de la commande
DESCRIBE. Cette commande affiche les noms des colonnes et les types de données
correspondants, et indique si une colonne doit contenir des données.
Dans la syntaxe :
tablename Nom d'une table, d'une vue ou d'un synonyme existant et accessible à
l'utilisateur.
Pour obtenir la description de la table DEPARTMENTS, utilisez la commande suivante :
SQL> DESCRIBE DEPARTMENTS
Name Null? Type
----------------------- -------- ---------------
DEPARTMENT_ID NOT NULL NUMBER(4)

DEPARTMENT_NAME NOT NULL VARCHAR2(30)
MANAGER_ID NUMBER(6)
LOCATION_ID NUMBER(4)

DESCRIBE departments
Name Null? Type

----------------------- -------- ------------
DEPARTMENT_ID NOT NULL NUMBER(4)
DEPARTMENT_NAME NOT NULL VARCHAR2(30)

MANAGER_ID NUMBER(6)
LOCATION_ID NUMBER(4)
Afficher la structure d'une table (suite)

L'exemple de la diapositive affiche les informations relatives à la structure de la table
DEPARTMENTS. Dans le résultat :
Null? : Indique si une colonne est obligatoire (la valeur NOT NULL indique qu'une
colonne doit contenir des données).
Type : Affiche le type de données d'une colonne.

Commandes SQL*Plus d'édition
• A[PPEND] text
• C[HANGE] / old / new
• C[HANGE] / text /
• CL[EAR] BUFF[ER]
• DEL
• DEL n
• DEL m n


Les commandes SQL*Plus doivent être saisies ligne par ligne et ne sont pas stockées dans le
tampon SQL.
Commande Description
A[PPEND] text Ajoute du texte à la fin de la ligne en cours.
C[HANGE] / old / new Remplace le texte old par le texte new dans la ligne
en cours.
C[HANGE] / text / Supprime text de la ligne en cours.
CL[EAR] BUFF[ER] Supprime toutes les lignes du tampon SQL.
DEL Supprime la ligne en cours.
DEL n Supprime la ligne n.
DEL m n Supprime les lignes m à n (incluse)
Indications
• Si vous appuyez sur [Entrée] avant de terminer une commande, SQL*Plus affiche un
numéro de ligne.
• Vous indiquez la fin de la saisie dans le tampon SQL en entrant l'un des caractères de fin
(point-virgule ou barre oblique) ou en appuyant deux fois sur [Entrée]. L'invite SQL
apparaît alors.

• I[NPUT]
• I[NPUT] text
• L[IST]
• L[IST] n
• L[IST] m n
• R[UN]
• n
• n text

• 0 text
Commandes SQL*Plus d'édition (suite)
Commande Description
I[NPUT] Insère un nombre de lignes indéfini.
I[NPUT] text Insère une ligne contenant text.
L[IST] Liste toutes les lignes du tampon SQL.
L[IST] n Liste la ligne n.
L[IST] m n Liste la fourchette de lignes m à n (incluse).
R[UN] Affiche et exécute l'instruction SQL en cours dans le tampon.
n Indique la ligne devant être la ligne en cours.
n text Remplace la ligne n par text.
0 text Insère une ligne avant la ligne 1.
Remarque : En regard d'une invite SQL, vous ne pouvez entrer qu'une seule commande
SQL*Plus. Les commandes SQL*Plus ne sont pas stockées dans le tampon. Pour continuer
une commande SQL*Plus sur la ligne suivante, terminez la première ligne par un tiret (-).

Utiliser les commandes LIST, n et APPEND
LIST
1 SELECT last_name
2* FROM employees
1
1* SELECT last_name
A , job_id
1* SELECT last_name, job_id

LIST
1 SELECT last_name, job_id
2* FROM employees
Utiliser les commandes LIST, n et APPEND

• Utilisez la commande L[IST] pour afficher le contenu du tampon SQL. L'astérisque (*)
en regard de la ligne 2, dans le tampon, indique qu'il s'agit de la ligne en cours. Toutes les
modifications effectuées s'appliquent à la ligne en cours.
• Modifiez le numéro de la ligne en cours en entrant le numéro (n) de la ligne que vous
souhaitez éditer. La nouvelle ligne en cours est affichée.
• Utilisez la commande A[PPEND] pour ajouter du texte à la ligne en cours. La nouvelle
ligne éditée est affichée. Vérifiez le nouveau contenu du tampon à l'aide de la commande
LIST.
Remarque : De nombreuses commandes SQL*Plus, y compris LIST et APPEND, peuvent
être abrégées à leur initiale. LIST et APPEND peuvent ainsi être abrégées respectivement en
L et A.

Utiliser la commande CHANGE
LIST
1* SELECT * from employees
c/employees/departments
1* SELECT * from departments

LIST
1* SELECT * from departments
Utiliser la commande CHANGE

• Utilisez la commande L[IST] pour afficher le contenu du tampon.
• Utilisez la commande C[HANGE] pour modifier le contenu de la ligne en cours dans le
tampon SQL. Dans ce cas, remplacez la table employees par la table departments.
La nouvelle ligne en cours est affichée.
• Utilisez la commande L[IST] pour vérifier le nouveau contenu du tampon.

Commandes SQL*Plus de manipulation

de fichiers
• SAVE filename
• GET filename
• START filename
• @ filename
• EDIT filename
• SPOOL filename
• EXIT

Commandes SQL*Plus de manipulation de fichiers

Les instructions SQL communiquent avec le serveur Oracle. Les commandes SQL*Plus
permettent de contrôler l'environnement, de mettre en forme le résultat des interrogations et
de gérer les fichiers. Vous pouvez utiliser les commandes décrites dans le tableau suivant :
Comm ande Description
SAV[E] filename [.ext] Sauvegarde le contenu en cours du tampon SQL dans
[REP[LACE]APP[END]] un fichier. Utilisez APPEND pour effectuer un ajout
à un fichier existant. Utilisez REPLACE pour remplacer
le contenu d'un fichier existant. L 'extension par défaut
est .sql.
GET filename [.ext] Ecrit dans le tampon SQL le contenu d'un fichier
précédemment sauvegardé. L 'extension par défaut du nom
de fichier est .sql.
STA[RT] filename [.ext] Exécute un fichier de com mandes précédemment
sauvegardé.
@ filename Exécute un fichier de com mandes précédemment
sauvegardé (identique à START).
ED[IT] Appelle l'éditeur et sauvegarde le contenu du tam pon
ans un fichier nomm é afiedt.buf
ED[IT] [filename[.ext]] Appelle l'éditeur pour permettre de modifier le contenu
d'un fichier sauvegardé.
SPO[OL] [filename[.ext]| Stocke les résultats des interrogations dans un fichier.
OFF|OUT] L 'option OFF ferme le fichier spool. L 'option OUT ferme
le fichier spool et transmet son contenu à l'imprimante.
EXIT Permet de quitter SQL *Plus.

Utiliser les commandes SAVE, START et EDIT
LIST
1 SELECT last_name, manager_id, department_id
2* FROM employees
SAVE my_query
Created file my_query
START my_query
LAST_NAME MANAGER_ID DEPARTMENT_ID

------------------------- ---------- -------------
King 90
Kochhar 100 90
...
107 rows selected.

SAVE
Utilisez la commande SAVE pour sauvegarder le contenu en cours du tampon dans un fichier.
Vous pouvez ainsi stocker les scripts fréquemment utilisés, en vue d'une utilisation ultérieure.
START
Utilisez la commande START pour exécuter un script dans SQL*Plus. Pour cela, vous pouvez
également utiliser le symbole @.
@my_query

EDIT my_query

Utiliser les commandes SAVE, START et EDIT (suite)

EDIT
Utilisez la commande EDIT pour modifier un script existant. Vous accédez alors à un éditeur
contenant le fichier script. Lorsque vous avez effectué les modifications souhaitées, quittez
l'éditeur pour revenir à la ligne de commande SQL*Plus.
Remarque : Le caractère "/" est un délimiteur signifiant la fin d'une instruction. Lorsque
SQL*Plus le rencontre dans un fichier, il exécute l'instruction qui le précède. Le délimiteur
doit correspondre au premier caractère d'une nouvelle ligne qui suit l'instruction.

Utiliser la commande SERVEROUTPUT
• Utilisez la commande SET SERVEROUT[PUT] pour indiquer si

la sortie des procédures stockées ou des blocs PL/SQL doit être
affichée dans SQL*Plus.
• La longueur limite de la ligne DBMS_OUTPUT est passée de
255 octets à 32 767 octets.
• Il n'y a plus de taille limite par défaut.
• Les ressources ne sont pas pré-allouées lorsque SERVEROUTPUT
est défini.
• Etant donné que les performances ne s'en trouvent pas affectées,
utilisez UNLIMITED, sauf si vous souhaitez économiser la

mémoire physique.
SET SERVEROUT[PUT] {ON | OFF} [SIZE {n | UNL[IMITED]}]

[FOR[MAT] {WRA[PPED] | WOR[D_WRAPPED] | TRU[NCATED]}]
Utiliser la commande SERVEROUTPUT

La plupart des programmes PL/SQL effectuent des entrées et des sorties via des instructions
SQL pour stocker des données dans des tables de base de données ou pour interroger ces
tables. Toutes les autres E/S PL/SQL sont effectuées via des API qui interagissent avec
d'autres programmes. Par exemple, le package DBMS_OUTPUT contient des procédures
telles que PUT_LINE. L'affichage du résultat hors de PL/SQL requiert un autre programme,
tel que SQL*Plus qui permet de lire et d'afficher les données transmises à ce package.
SQL*Plus n'affiche pas les données DBMS_OUTPUT, sauf si vous exécutez préalablement
la commande SQL*Plus SET SERVEROUTPUT ON comme suit :
SET SERVEROUTPUT ON
Remarques :
• SIZE définit le nombre d'octets de la sortie pouvant être placés dans le tampon sur le
serveur Oracle Database. La valeur par défaut est UNLIMITED. Le nombre indiqué ne
peut pas être inférieur à 2 000 ni supérieur à 1 000 000.
• Pour plus d'informations sur SERVEROUTPUT, consultez le manuel Database PL/SQL
User's Guide and Reference 11g.

Utiliser la commande SQL*Plus SPOOL
SPO[OL] [file_name[.ext] [CRE[ATE] | REP[LACE] |

APP[END]] | OFF | OUT]
Option Description
file_name[.ext] Stocke la sortie dans le fichier spool indiqué.
CRE[ATE] Crée un fichier avec le nom indiqué.
REP[LACE] Remplace le contenu d'un fichier existant. Si le fichier

n'existe pas, il est créé.
APP[END] Ajoute le contenu du tampon à la fin du fichier que vous

indiquez.
OFF Arrête le stockage dans le fichier spool.
OUT Arrête le stockage dans le fichier spool et envoie le

fichier à l'imprimante standard (par défaut) de votre
ordinateur.
Utiliser la commande SQL*Plus SPOOL

La commande SPOOL permet de stocker les résultats des interrogations dans un fichier.
Elle permet également d'envoyer ce fichier à une imprimante. La commande SPOOL a été
améliorée. Auparavant, elle permettait uniquement de créer (ou de remplacer) un fichier.
A présent, elle offre en outre la possibilité d'effectuer un ajout à la fin d'un fichier. L'option
par défaut est REPLACE.
Pour placer la sortie générée par les commandes d'un script dans un fichier spool sans
l'afficher à l'écran, utilisez SET TERMOUT OFF. Cette option n'affecte pas la sortie des
commandes exécutées de manière interactive.
Vous devez utiliser des guillemets autour des noms de fichier contenant des espaces.
Pour créer un fichier HTML valide à l’aide des commandes SPOOL APPEND, vous devez
utiliser PROMPT ou une commande similaire afin de créer l’en-tête et le pied de page HTML.
La commande SPOOL APPEND n’analyse pas les balises HTML. Pour désactiver les
paramètres CREATE, APPEND et SAVE, affectez à l’option SET
SQLPLUSCOMPAT[IBILITY] un numéro de version inférieur ou égal à 9.2.

Utiliser la commande AUTOTRACE
• Affiche un état une fois l'exécution d'instructions LMD SQL

telles que SELECT, INSERT, UPDATE ou DELETE aboutie.
• L'état peut à présent inclure les statistiques d'exécution et
le chemin d'exécution de l'interrogation.
SET AUTOT[RACE] {ON | OFF | TRACE[ONLY]} [EXP[LAIN]]

[STAT[ISTICS]]

SET AUTOTRACE ON
-- The AUTOTRACE report includes both the optimizer
-- execution path and the SQL statement execution
-- statistics.
Utiliser la commande AUTOTRACE

L'option EXPLAIN montre le chemin d'exécution de l'interrogation en exécutant la
commande EXPLAIN PLAN. L'option STATISTICS affiche les statistiques relatives aux
instructions SQL. La mise en forme de l'état AUTOTRACE peut varier en fonction de la
version et de la configuration du serveur auquel vous êtes connecté. Le package
DBMS_XPLAN facilite l'affichage de la sortie de la commande EXPLAIN PLAN selon
plusieurs formats prédéfinis.
Remarques :
• Pour plus d'informations sur les packages et les sous-programmes, consultez le manuel
Oracle Database PL/SQL Packages and Types Reference 11g.
• Pour plus d'informations sur la commande EXPLAIN PLAN, consultez le manuel Oracle
Database SQL Reference 11g.
• Pour plus d'informations sur les plans d'exécution et les statistiques, consultez le manuel
Oracle Database Performance Tuning Guide 11g.

Synthèse
Cette annexe a traité des sujets suivants :

• Exécuter des instructions SQL
• Editer des instructions SQL
• Mettre en forme la sortie
• Interagir avec des fichiers script

Synthèse
SQL*Plus est un environnement d'exécution qui permet d'envoyer des commandes SQL
au serveur de base de données, ou encore d'éditer et de sauvegarder des commandes SQL.
Vous pouvez exécuter des commandes à partir de l'invite SQL ou d'un fichier script.

Utiliser JDeveloper

Oracle JDeveloper

Oracle JDeveloper
Oracle JDeveloper est un environnement IDE (Integrated Development Environment)
permettant de développer et de déployer des applications Java et des services Web. Il prend en
charge chaque étape du cycle de développement des logiciels (SDLC - Software Development
Life Cycle), de la modélisation au déploiement. Il comporte des fonctionnalités permettant
d'utiliser les dernières normes de l'industrie informatique pour les langages Java, XML et SQL
lors du développement d'une application.
Oracle JDeveloper 10g fournit une nouvelle approche pour le développement J2EE en
proposant des fonctionnalités qui permettent un développement graphique et déclaratif. Grâce
à cette approche novatrice, le développement J2EE est simple et efficace.
Oracle Database 11g : Les fondamentaux du langage PL/SQL E - 2

Navigateur de connexions
(Connections Navigator)

Navigateur de connexions (Connections Navigator)

Dans Oracle JDeveloper, vous pouvez stocker les informations nécessaires pour vous
connecter à une base de données dans un objet appelé "connexion". Une connexion est
stockée en tant que partie intégrante des paramètres de l'environnement IDE, et peut être
exportée et importée pour un partage facile entre des groupes d'utilisateurs. Une connexion
permet de réaliser différentes opérations, de la navigation au sein de la base de données au
déploiement en passant par la construction d'applications.

Navigateur d'applications
(Applications Navigator)

Navigateur d'applications (Applications Navigator)

Le navigateur d'applications fournit une vue logique de l'application et des données qu'elle
contient. Différentes extensions peuvent se connecter à l'infrastructure fournie par le
navigateur. Elles peuvent l'utiliser pour organiser leurs données et leurs menus de façon
cohérente et synthétique. Bien que le navigateur d'applications puisse contenir des fichiers
individuels (tels que des fichiers source Java), il est avant tout conçu pour la consolidation de
données complexes. Les types de données complexes tels que les objets entité, les
diagrammes UML, les composants EJB ou les services Web apparaissent dans ce navigateur
sous la forme de noeuds uniques. Les fichiers RAW qui constituent ces noeuds apparaissent
dans la fenêtre Structure.

Fenêtre Structure

Fenêtre Structure
La fenêtre Structure offre une vue structurelle des données figurant dans le document
sélectionné dans la fenêtre active parmi les fenêtres contribuant à la gestion de la structure :
les navigateurs, les éditeurs et les visualiseurs, et le gestionnaire de propriétés.
Dans la fenêtre Structure, vous pouvez afficher les données du document de différentes
manières. Les structures disponibles pour affichage sont basées sur le type de document. Pour
un fichier Java, vous pouvez afficher la structure du code, la structure de l'interface utilisateur
ou les données du modèle d'interface utilisateur. Pour un fichier XML, vous pouvez afficher
la structure du code XML, la structure de conception ou les données du modèle d'interface
utilisateur.
La fenêtre Structure est dynamique : elle reflète toujours la sélection en cours de la fenêtre
active (sauf si vous gelez le contenu de la fenêtre sur une vue particulière) de façon pertinente
pour l'éditeur actif. Lorsque la sélection en cours est un noeud dans le navigateur, l'éditeur par
défaut est utilisé. Pour modifier la vue de la structure pour la sélection en cours, sélectionnez
un autre onglet de structure.

Fenêtre de l'éditeur

Fenêtre de l'éditeur
Vous pouvez afficher l'ensemble des fichiers de projet dans une même fenêtre de l'éditeur,
ouvrir plusieurs vues du même fichier ou ouvrir plusieurs vues de différents fichiers.
Les onglets figurant en haut de la fenêtre de l'éditeur sont les onglets de document. Lorsque
vous sélectionnez un onglet de document, cela entraîne la sélection du fichier correspondant,
qui est amené au premier plan de la fenêtre de l'éditeur en cours.
Les onglets figurant au bas de la fenêtre de l'éditeur pour un fichier donné sont les onglets
d'éditeur. Lorsque vous sélectionnez un de ces onglets, le fichier est ouvert dans l'éditeur
correspondant.

Déployer des procédures Java stockées
Avant de déployer des procédures Java stockées, procédez

de la façon suivante :
1. Créez une connexion de base de données.
2. Créez un profil de déploiement.
3. Déployez les objets.

1 2 3
Déployer des procédures Java stockées

Créez un profil de déploiement pour les procédures Java stockées, puis déployez les classes
et, éventuellement, toute méthode static publique dans JDeveloper à l'aide des paramètres du
profil.
Le déploiement dans la base de données fait appel aux informations fournies dans l'assistant
Deployment Profile Wizard et à deux utilitaires Oracle Database :
• loadjava charge la classe Java contenant les procédures stockées vers une base de
données Oracle.
• publish génère les wrappers propres à l'appel PL/SQL pour les méthodes static
publiques chargées. La publication permet l'appel des méthodes Java en tant que
fonctions ou procédures PL/SQL.

Publier du code Java dans une procédure PL/SQL

Publier du code Java dans une procédure PL/SQL

La diapositive ci-dessus contient du code Java et illustre le mode de publication de ce dernier
dans une procédure PL/SQL.

Créer des programmes
Squelette de la fonction

Créer des programmes

Pour créer un programme PL/SQL :
1. Sélectionnez View > Connection Navigator.
2. Développez Database et sélectionnez une connexion de base de données.
3. Dans la connexion, développez un schéma.
4. Cliquez avec le bouton droit de la souris sur le dossier correspondant au type d'objet
(Procedures, Packages ou Functions).
5. Choisissez "New PL/SQL object_type". La boîte de dialogue Create PL/SQL apparaît
pour la fonction, le package ou la procédure.
6. Entrez un nom valide pour la fonction, le package ou la procédure, puis cliquez sur OK.
Une définition de squelette est créée et ouverte dans l'éditeur de code. Vous pouvez alors
modifier le sous-programme en fonction de vos besoins.

Compilation
Compilation avec erreurs

Compilation sans erreurs
Compilation
Après avoir modifié la définition de squelette, vous devez compiler le programme. Dans le
navigateur de connexions, cliquez avec le bouton droit de la souris sur l'objet PL/SQL à
compiler, puis sélectionnez Compile. Vous pouvez également procéder à la compilation
à l'aide de la combinaison de touches [CTRL] + [MAJ] + [F9].

Exécuter un programme

Exécuter un programme
Pour exécuter un programme, cliquez avec le bouton droit de la souris sur l'objet et
sélectionnez Run. La boîte de dialogue Run PL/SQL apparaît. Vous devez éventuellement
remplacer les valeurs NULL par des valeurs acceptables qui sont transmises au programme.
Après avoir modifié les valeurs, cliquez sur OK. Le résultat apparaît dans la fenêtre
Message-Log.

Supprimer un programme

Supprimer un programme
Pour supprimer un programme, cliquez avec le bouton droit de la souris sur l'objet et
sélectionnez Drop. La boîte de dialogue Drop Confirmation apparaît. Cliquez sur Yes. L'objet
est supprimé de la base de données.

Déboguer des programmes PL/SQL
JDeveloper prend en charge deux types de débogage :

• Local
• Distant
Pour déboguer des programmes PL/SQL, vous devez disposer
des privilèges suivants :
• DEBUG ANY PROCEDURE
• DEBUG CONNECT SESSION


JDeveloper permet aussi bien le débogage local que le débogage distant. Pour lancer une
session de débogage local, configurez des points d'arrêt dans les fichiers source, puis
démarrez le programme de débogage. Le débogage distant requiert deux processus
JDeveloper : un processus debugger et un processus debuggee qui peut résider sur une
autre plate-forme.
Pour que vous puissiez déboguer un programme PL/SQL, ce dernier doit être compilé en
mode INTERPRETED. Vous ne pouvez pas déboguer un programme PL/SQL compilé en
mode NATIVE. Ce mode est défini dans le fichier init.ora de la base de données.
Les programmes PL/SQL doivent être compilés avec l'option DEBUG activée. Cette option
peut être activée de différentes manières. A l'aide de SQL*Plus, exécutez ALTER SESSION
SET PLSQL_DEBUG = true afin d'activer l'option DEBUG. Vous pouvez ensuite créer ou
recompiler le programme PL/SQL à déboguer. Vous pouvez également, pour activer l'option
DEBUG, utiliser la commande suivante dans SQL*Plus :
ALTER <procedure, function, package> <name> COMPILE DEBUG;


Déboguer des programmes PL/SQL (suite)

Avant de commencer le débogage, vérifiez que la case Generate PL/SQL Debug Information
est cochée. Vous pouvez accéder à la boîte de dialogue correspondante en sélectionnant
Tools > Preferences > Database Connections.
Vous aviez sans doute l'habitude de tester manuellement les fonctions et procédures PL/SQL
à partir de SQL*Plus ou en exécutant une procédure factice dans la base de données.
JDeveloper vous permet de tester ces objets de façon automatique. Avec cette version de
JDeveloper, vous pouvez exécuter et déboguer les programmes PL/SQL. Par exemple, vous
pouvez indiquer les paramètres transmis ou les valeurs renvoyées à partir d'une fonction, ce
qui vous donne davantage de contrôle sur les éléments exécutés et vous fournit des détails sur
les éléments testés.
Remarque : Les procédures ou les fonctions de la base de données Oracle peuvent être
autonomes ou figurer dans un package.

Déboguer des programmes PL/SQL (suite)

Pour exécuter ou déboguer des fonctions, des procédures et des packages :
1. Créez une connexion de base de données à l'aide de l'assistant Database Wizard.
2. Dans le navigateur, développez le noeud Database afin d'afficher le nom utilisateur de base de
données et le nom de schéma spécifiques.
3. Développez le noeud Schema.
4. Développez le noeud correspondant au type d'élément que vous déboguez : procédure, fonction
ou corps du package.
5. (Facultatif pour le débogage uniquement) Sélectionnez la fonction, la procédure ou le package à
déboguer, et cliquez deux fois dessus pour l'ouvrir dans l'éditeur de code.
6. (Facultatif pour le débogage uniquement) Définissez un point d'arrêt dans le code PL/SQL en
cliquant à gauche de la marge.
Remarque : Le point d'arrêt doit être défini sur une ligne de code exécutable. Si le programme
de débogage ne s'arrête pas, le point d'arrêt n'a peut-être pas été défini sur une ligne de code

exécutable (assurez-vous que le point d'arrêt a été correctement défini). Vérifiez également que
les conditions préalables au débogage PL/SQL sont remplies. En particulier, vérifiez que le
programme PL/SQL est compilé en mode INTERPRETED.
7. Vérifiez que l'éditeur de code ou que la procédure dans le navigateur est sélectionné(e).
8. Dans la barre d'outils, cliquez sur le bouton Debug ou, si vous préférez procéder à une exécution
sans débogage, cliquez sur le bouton Run.
9. La boîte de dialogue Run PL/SQL apparaît.
- Sélectionnez une cible, c'est-à-dire le nom de la procédure ou de la fonction à déboguer.
Notez que le contenu des zones Parameters et PL/SQL Block change de façon dynamique
en même temps que la cible.
Remarque : Vous aurez à choisir entre différentes cibles uniquement si vous décidez d'exécuter
ou de déboguer un package contenant plusieurs programmes.
La zone Parameters répertorie les arguments de la cible (le cas échéant).
La zone PL/SQL Block affiche le code généré de façon personnalisée par JDeveloper pour la
cible sélectionnée. Selon la finalité de la fonction ou de la procédure, vous devrez peut-être
remplacer les valeurs NULL par des valeurs acceptables qui seront transmises à la procédure, à
la fonction ou au package. Vous pouvez parfois être amené à écrire du code supplémentaire afin
d'initialiser les valeurs à transmettre en tant qu'arguments. Dans ce cas, vous pouvez modifier le
texte du bloc PL/SQL en fonction des besoins.
10. Cliquez sur OK pour exécuter ou déboguer la cible.
11. Analysez les informations de sortie affichées dans la fenêtre Log.
Dans le cas de fonctions, la valeur renvoyée est affichée. Les messages DBMS_OUTPUT sont
également affichés.

Définir des points d'arrêt

Définir des points d'arrêt

Pour examiner les valeurs des variables d'un programme, vous pouvez utiliser un point d'arrêt.
Il s'agit d'un déclencheur (trigger) figurant dans un programme. Une fois atteint, il met
l'exécution du programme en pause, ce qui vous permet d'examiner les valeurs de certaines ou
de l'ensemble des variables du programme. En définissant un point d'arrêt dans une zone
potentiellement problématique du code source, vous pouvez exécuter le programme jusqu'à
atteindre l'emplacement où vous souhaitez procéder à un débogage. Lorsqu'un point d'arrêt est
détecté, l'exécution du programme est mise en pause et le programme de débogage affiche la
ligne contenant le point d'arrêt dans l'éditeur de code. Vous pouvez alors utiliser le
programme de débogage pour connaître l'état du programme. Les points d'arrêt offrent une
grande souplesse dans la mesure où ils peuvent être définis avant le lancement de l'exécution
d'un programme ou à tout moment lors du débogage.
Pour définir un point d'arrêt dans l'éditeur de code, cliquez sur la marge de gauche en regard
d'une ligne de code exécutable. Les points d'arrêt définis sur des lignes de commentaires, des
lignes vides, des lignes de déclaration et toute autre ligne de code non exécutable ne sont pas
vérifiés par le programme de débogage et sont considérés comme non valides.

Exécuter le code ligne par ligne
Débogage Reprise

Exécuter le code ligne par ligne

Après avoir défini le point d'arrêt, lancez le programme de débogage en cliquant sur l'icône de
débogage. Le programme de débogage met en pause l'exécution du programme à l'endroit où
le point d'arrêt a été défini. A ce stade, vous pouvez vérifier les valeurs des variables. Vous
pouvez poursuivre l'exécution du programme en cliquant sur l'icône de reprise. Le programme
de débogage poursuit le traitement jusqu'au point d'arrêt suivant. Après avoir exécuté tous les
points d'arrêt, le programme de débogage arrête l'exécution du programme et affiche les
résultats dans la zone Debugging – Log.

Examiner et modifier les variables
Fenêtre Data


Lorsque le débogage est activé, vous pouvez examiner et modifier la valeur des variables à
l'aide des fenêtres Data, Smart Data et Watches. Vous pouvez modifier les valeurs des
données d'un programme pendant une session de débogage afin de tester d'éventuelles
corrections de bug lors de l'exécution d'un programme. Si vous découvrez qu'une modification
corrige une erreur de programme, vous pouvez quitter la session de débogage, corriger le code
du programme en conséquence, puis recompiler le programme afin de rendre la correction
permanente.
Utilisez la fenêtre Data pour afficher des informations sur les variables du programme. La
fenêtre Data affiche les arguments, les variables locales et les champs static pour le contexte
en cours, qui est défini par la sélection effectuée dans la fenêtre Stack. Si vous changez de
contexte, la fenêtre Data est mise à jour afin d'afficher les données de ce nouveau contexte. Si
le programme en cours a été compilé sans informations de débogage, vous ne pourrez pas voir
les variables locales.

Fenêtre Smart Data

Examiner et modifier les variables (suite)

Contrairement à la fenêtre Data qui affiche toutes les variables du programme, la fenêtre
Smart Data affiche uniquement les données pertinentes pour le code source que vous exécutez
ligne par ligne.

Fenêtre Watches


Un examen de variables et expressions choisies (watch) vous permet de surveiller les valeurs
changeantes des variables ou des expressions lors de l'exécution du programme. Une fois que
vous avez entré une expression à examiner, la fenêtre Watch affiche la valeur en cours de
l'expression. Pendant l'exécution du programme, la valeur de l'expression examinée change au
fur et à mesure que le programme met à jour les valeurs des variables dans l'expression.

Fenêtre Stack


Vous pouvez activer la fenêtre Stack en sélectionnant View > Debugger > Stack. La pile
d'appels du thread en cours est ainsi affichée. Lorsque vous sélectionnez une ligne dans la
fenêtre Stack, la fenêtre Data, la fenêtre Watch et toutes les autres fenêtres sont mises à jour
de façon à afficher les données de la classe sélectionnée.


Fenêtre Classes

La fenêtre Classes affiche toutes les classes en cours de chargement pour l'exécution du
programme. Si JDeveloper est utilisé avec Oracle Java Virtual Machine (OJVM), la fenêtre
indique également le nombre d'instances d'une classe donnée et la mémoire utilisée par ces
instances.

Curseurs REF

Variables de curseur
• Les variables de curseur sont semblables aux pointeurs C

ou Pascal, lesquels conservent l'emplacement en mémoire
(adresse) d'un élément à la place de l'élément proprement
dit.
• En langage PL/SQL, un pointeur est déclaré en tant que
REF X, où REF représente l'abréviation de REFERENCE et X
une classe d'objets.
• Une variable de curseur possède le type de données
REF CURSOR.

• Un curseur est statique, tandis qu'une variable de curseur
est dynamique.
• Les variables de curseur offrent une plus grande souplesse
d'utilisation.
Variables de curseur
Les variables de curseur sont semblables aux pointeurs C ou Pascal, lesquels conservent
l'emplacement en mémoire (adresse) d'un élément à la place de l'élément proprement dit.
Par conséquent, la déclaration d'une variable de curseur permet de créer un pointeur, et non un
élément. En langage PL/SQL, un pointeur présente le type de données REF X, où REF
représente l'abréviation de REFERENCE et X une classe d'objets. Une variable de curseur
présente le type de données REF CURSOR.
A l'image d'un curseur, une variable de curseur pointe vers la ligne en cours de l'ensemble de
résultats d'une interrogation dont les résultats comportent plusieurs lignes. Cependant, les
curseurs se distinguent des variables de curseur de la même façon que les constantes se
différencient des variables. Un curseur est statique, tandis qu'une variable de curseur est
dynamique. En effet, cette dernière n'est pas liée à une interrogation précise. Vous pouvez
ouvrir une variable de curseur pour exécuter n'importe quelle interrogation dont le type est
compatible. Ainsi, vous bénéficiez d'une souplesse d'utilisation accrue.
Les variables de curseur sont accessibles par n'importe quel client PL/SQL. Par exemple, vous
pouvez déclarer une variable de curseur dans un environnement hôte PL/SQL, tel qu'un
programme OCI ou Pro*C, puis transmettre celle-ci au compilateur PL/SQL en tant que
variable hôte d'entrée (variable attachée (bind variable)). De plus, les outils de développement
d'applications tels que Oracle Forms et Oracle Reports, qui disposent d'un moteur PL/SQL,
peuvent utiliser les variables de curseur intégralement côté client. Le serveur Oracle possède
également un moteur PL/SQL. Vous pouvez transmettre les variables de curseur entre une
application et un serveur, et vice versa, via les appels RPC.
Oracle Database 11g : Les fondamentaux du langage PL/SQL F - 2

Utiliser des variables de curseur
• Vous pouvez utiliser des variables de curseur pour

transmettre les ensembles de résultats des interrogations
entre les sous-programmes PL/SQL stockés et les divers
clients.
• Le langage PL/SQL peut partager un pointeur vers la zone
de travail de l'interrogation où est stocké l'ensemble de
résultats.
• Vous pouvez transmettre sans difficulté la valeur d'une
variable de curseur d'une portée à une autre.

• Vous pouvez réduire le trafic du réseau en utilisant un bloc
PL/SQL pour ouvrir (ou fermer) plusieurs variables de
curseur hôte en un seul aller-retour réseau.
Utiliser des variables de curseur

Les variables de curseur permettent de transmettre les ensembles de résultats des
interrogations entre les sous-programmes PL/SQL stockés et divers clients. Ni le moteur
PL/SQL, ni ses clients ne possèdent d'ensemble de résultats. Ils partagent simplement un
pointeur vers la zone de travail de l'interrogation où est stocké l'ensemble de résultats. Par
exemple, un client OCI, une application Oracle Forms et le serveur Oracle peuvent tous faire
référence à la même zone de travail.
Une zone de travail d'interrogation reste accessible tant qu'une variable de curseur pointe vers
elle. Vous pouvez donc transmettre librement la valeur d'une variable de curseur d'une portée
à une autre. Par exemple, si vous transmettez une variable de curseur hôte à un bloc PL/SQL
intégré dans un programme Pro*C, la zone de travail vers laquelle pointe la variable de
curseur reste accessible à la fin de l'exécution du bloc.
Si vous disposez d'un moteur PL/SQL côté client, aucune restriction n'est imposée aux appels
du client vers le serveur. Par exemple, vous pouvez déclarer une variable de curseur côté
client, l'ouvrir et en extraire des données côté serveur, puis poursuivre l'extraction côté client.
De même, vous pouvez réduire le trafic du réseau en utilisant un bloc PL/SQL pour ouvrir (ou
fermer) plusieurs variables de curseur hôte en un seul aller-retour réseau.
Une variable de curseur conserve en mémoire PGA (Program Global Area) une référence à la
zone de travail du curseur, au lieu de représenter cette dernière par un nom statique. Etant
donné que vous faites référence à cette zone, vous bénéficiez de la souplesse d'utilisation
d'une variable.

Définir des types REF CURSOR
Définissez un type REF CURSOR :

Define a REF CURSOR type
TYPE ref_type_name IS REF CURSOR [RETURN return_type];
Déclarez une variable de curseur de ce type :

ref_cv ref_type_name;
Exemple :

DECLARE
TYPE DeptCurTyp IS REF CURSOR RETURN
departments%ROWTYPE;
dept_cv DeptCurTyp;
Définir des types REF CURSOR

La définition d'un type REF CURSOR s'effectue en deux étapes. Vous devez définir au
préalable un type REF CURSOR, puis déclarer des variables de curseur de ce type. Vous
pouvez définir des types REF CURSOR dans n'importe quel bloc, sous-programme ou package
PL/SQL, grâce à la syntaxe suivante :
TYPE ref_type_name IS REF CURSOR [RETURN return_type];
où :
ref_type_name Est un identificateur de type utilisé dans les déclarations
ultérieures de variables de curseur.
return_type Représente un enregistrement ou une ligne dans une table de base
de données.
Dans l'exemple de la diapositive ci-dessus, vous indiquez un type de données renvoyé
représentant une ligne de la table de base de données DEPARTMENT.
Les types REF CURSOR peuvent être forts (restrictifs) ou faibles (non restrictifs). Comme
l'illustre l'exemple suivant, la définition d'un type REF CURSOR fort indique le type de
données renvoyé, ce qui n'est pas le cas pour la définition d'un type faible :
DECLARE
TYPE EmpCurTyp IS REF CURSOR RETURN employees%ROWTYPE; --
strong
TYPE GenericCurTyp IS REF CURSOR; -- weak

Définir des types REF CURSOR (suite)
Les types REF CURSOR forts sont moins sujets aux erreurs, car le compilateur PL/SQL ne permet
d'associer une variable de curseur de type fort qu'aux interrogations dont le type est compatible.
Cependant, les types REF CURSOR faibles sont plus souples d'utilisation, car le compilateur permet
d'associer une variable de curseur de type faible à n'importe quelle interrogation.
Déclarer des variables de curseur
Après avoir défini un type REF CURSOR, vous pouvez déclarer des variables de curseur du même
type dans n'importe quel bloc ou sous-programme PL/SQL. Dans l'exemple suivant, vous déclarez la
variable de curseur DEPT_CV :
DECLARE
TYPE DeptCurTyp IS REF CURSOR RETURN departments%ROWTYPE;
dept_cv DeptCurTyp; -- declare cursor variable

Remarque : Vous ne pouvez pas déclarer des variables de curseur dans un package. Contrairement
aux variables de package, les variables de curseur ne présentent pas d'états persistants. Rappelons que
la déclaration d'une variable de curseur permet de créer un pointeur, et non un élément. Les variables
de curseur ne peuvent pas être enregistrées dans la base de données. Elles suivent les règles de portée
et d'instanciation habituelles.
Dans la clause RETURN d'une définition de type REF CURSOR, vous pouvez utiliser %ROWTYPE pour
indiquer un type d'enregistrement représentant une ligne renvoyée par une variable de curseur de type
fort (pas de type faible), en procédant comme suit :
DECLARE
TYPE TmpCurTyp IS REF CURSOR RETURN employees%ROWTYPE;
tmp_cv TmpCurTyp; -- declare cursor variable
TYPE EmpCurTyp IS REF CURSOR RETURN tmp_cv%ROWTYPE;
emp_cv EmpCurTyp; -- declare cursor variable
De même, vous pouvez utiliser %TYPE pour indiquer le type de données d'une variable de type
RECORD, comme le montre l'exemple suivant :
DECLARE
dept_rec departments%ROWTYPE; -- declare record variable
TYPE DeptCurTyp IS REF CURSOR RETURN dept_rec%TYPE;
dept_cv DeptCurTyp; -- declare cursor variable
Dans le dernier exemple, vous indiquez dans la clause RETURN un type RECORD défini par
l'utilisateur :
DECLARE
TYPE EmpRecTyp IS RECORD (
empno NUMBER(4),
ename VARCHAR2(1O),
sal NUMBER(7,2));
TYPE EmpCurTyp IS REF CURSOR RETURN EmpRecTyp;

Variables de curseur en tant que paramètres

Vous pouvez déclarer des variables de curseur en tant que paramètres formels de fonctions et de
procédures. Dans l'exemple suivant, vous définissez le type REF CURSOR EmpCurTyp, puis vous
déclarez une variable de curseur du même type en tant que paramètre formel d'une procédure :
DECLARE
TYPE EmpCurTyp IS REF CURSOR RETURN emp%ROWTYPE;
PROCEDURE open_emp_cv (emp_cv IN OUT EmpCurTyp) IS ...

Utiliser les instructions OPEN-FOR, FETCH
et CLOSE
• L'instruction OPEN-FOR associe une variable de curseur
à une interrogation dont les résultats comportent plusieurs
lignes. Elle exécute l'interrogation, identifie l'ensemble de
résultats et fait pointer le curseur vers la première ligne de
cet ensemble de résultats.
• L'instruction FETCH renvoie une ligne à partir de l'ensemble
de résultats d'une interrogation dont les résultats
comportent plusieurs lignes. Elle affecte les valeurs des
colonnes renvoyées par l'instruction SELECT aux variables

ou aux champs correspondants dans la clause INTO, elle
incrémente le nombre de lignes de %ROWCOUNT et fait
pointer le curseur sur la ligne suivante.
• L'instruction CLOSE désactive une variable de curseur.
Utiliser les instructions OPEN-FOR, FETCH et CLOSE

Trois instructions permettent de traiter une interrogation dynamique dont les résultats
comportent plusieurs lignes : OPEN-FOR, FETCH et CLOSE. Vous commencez par "ouvrir"
(open) une variable de curseur "pour" (for) une interrogation dont les résultats comportent
plusieurs lignes. Ensuite, vous "extrayez" (fetch) une par une les lignes de l'ensemble de
résultats. Enfin, lorsque toutes les lignes sont traitées, vous "fermez" (close) la variable de
curseur.
Ouvrir la variable de curseur
L'instruction OPEN-FOR associe une variable de curseur à une interrogation dont les résultats
comportent plusieurs lignes. Elle exécute l'interrogation, identifie l'ensemble de résultats, fait
pointer le curseur vers la première ligne de cet ensemble de résultats, puis affecte la valeur
zéro à %ROWCOUNT, qui correspond au nombre de lignes traitées. Contrairement à la forme
statique de OPEN-FOR, la forme dynamique comprend une clause facultative USING. Lors
de l'exécution, les arguments attachés (bind arguments) de la clause USING remplacent les
marques de réservation correspondantes dans l'instruction dynamique SELECT. La syntaxe
est la suivante :
OPEN {cursor_variable | :host_cursor_variable} FOR
dynamic_string
[USING bind_argument[, bind_argument]...];
où CURSOR_VARIABLE correspond à une variable de curseur de type faible (qui ne possède
pas de type de données renvoyé), où HOST_CURSOR_VARIABLE correspond à une variable
de curseur déclarée dans un environnement hôte PL/SQL tel qu'un programme OCI, et où
dynamic_string correspond à une expression de type chaîne représentant une
interrogation dont les résultats comportent plusieurs lignes.

Utiliser les instructions OPEN-FOR, FETCH et CLOSE (suite)
L'exemple suivant déclare une variable de curseur, puis associe cette dernière à une instruction
SELECT dynamique qui renvoie des lignes à partir de la table employees :
DECLARE
TYPE EmpCurTyp IS REF CURSOR; -- define weak REF CURSOR
type
my_ename VARCHAR2(15);
my_sal NUMBER := 1000;
BEGIN
OPEN emp_cv FOR -- open cursor variable
'SELECT last_name, salary FROM employees WHERE salary >
:s'
USING my_sal;

...
END;
Les arguments attachés de l'interrogation sont évalués uniquement lorsque la variable de curseur est
ouverte. Par conséquent, pour extraire les lignes du curseur avec des valeurs attachées différentes,
vous devez rouvrir la variable de curseur en utilisant les arguments attachés initialisés d'après leurs
nouvelles valeurs.
Extraire des données de la variable de curseur
L'instruction FETCH renvoie une ligne à partir de l'ensemble de résultats d'une interrogation dont les
résultats comportent plusieurs lignes. Elle affecte les valeurs des colonnes renvoyées par l'instruction
SELECT aux variables ou aux champs correspondants dans la clause INTO, elle incrémente le
nombre de lignes de %ROWCOUNT et fait pointer le curseur sur la ligne suivante. Utilisez la syntaxe
suivante :
FETCH {cursor_variable | :host_cursor_variable}
INTO {define_variable[, define_variable]... | record};
Poursuivez l'exemple en extrayant les lignes de la variable de curseur EMP_CV dans les variables
MY_ENAME et MY_SAL :
LOOP
FETCH emp_cv INTO my_ename, my_sal; -- fetch next row
EXIT WHEN emp_cv%NOTFOUND; -- exit loop when last row is
fetched
-- process row
END LOOP;
Pour chaque valeur de colonne renvoyée par l'interrogation associée à la variable de curseur, une
variable ou un champ correspondant de type compatible doit exister dans la clause INTO. Vous
pouvez utiliser une autre clause INTO lors d'extractions distinctes avec la même variable de curseur.
Chaque extraction permet de récupérer une ligne du même ensemble de résultats. Si vous essayez
d'effectuer une extraction (fetch) à partir d'une variable de curseur fermée ou n'ayant jamais été
ouverte, le langage PL/SQL déclenche l'exception prédéfinie INVALID_CURSOR.

Utiliser les instructions OPEN-FOR, FETCH et CLOSE (suite)
Fermer la variable de curseur

L'instruction CLOSE désactive une variable de curseur. Dès lors, l'ensemble de résultats associé n'est
plus défini. Utilisez la syntaxe suivante :
CLOSE {cursor_variable | :host_cursor_variable};
Dans cet exemple, lorsque la dernière ligne est traitée, fermez la variable de curseur EMP_CV :
LOOP
FETCH emp_cv INTO my_ename, my_sal;
EXIT WHEN emp_cv%NOTFOUND;
-- process row
END LOOP;
CLOSE emp_cv; -- close cursor variable

Si vous essayez de fermer une variable de curseur déjà fermée ou n'ayant jamais été ouverte, le
langage PL/SQL déclenche l'exception INVALID_CURSOR.

Exemple d'extraction
DECLARE
TYPE EmpCurTyp IS REF CURSOR;
emp_cv EmpCurTyp;
emp_rec employees%ROWTYPE;
sql_stmt VARCHAR2(200);
my_job VARCHAR2(10) := 'ST_CLERK';
BEGIN
sql_stmt := 'SELECT * FROM employees
WHERE job_id = :j';
OPEN emp_cv FOR sql_stmt USING my_job;
LOOP
FETCH emp_cv INTO emp_rec;

EXIT WHEN emp_cv%NOTFOUND;
-- process record
END LOOP;
CLOSE emp_cv;
END;
/
Exemple d'extraction
L'exemple de la diapositive ci-dessus montre que vous pouvez extraire (fetch) des lignes de
l'ensemble de résultats d'une interrogation dynamique dont les résultats comportent plusieurs
lignes, et placer cette extraction dans un enregistrement. Vous devez définir au préalable un
type REF CURSOR, à savoir EmpCurTyp. Ensuite, vous devez définir une variable de
curseur emp_cv, de type EmpcurTyp. Dans la section exécutable du bloc PL/SQL,
l'instruction OPEN-FOR associe la variable de curseur EMP_CV à une interrogation dont les
résultats comportent plusieurs lignes, à savoir sql_stmt. L'instruction FETCH renvoie une
ligne à partir de l'ensemble de résultats de cette interrogation, puis affecte les valeurs des
colonnes renvoyées par l'instruction SELECT à EMP_REC dans la clause INTO. Une fois la
dernière ligne traitée, vous devez fermer la variable de curseur EMP_CV.

Exercices
complémentaires

Présentation des exercices complémentaires

Les exercices complémentaires suivants complètent le cours Oracle Database 11g :
Les fondamentaux du langage PL/SQL. Ils vous permettront de mettre en pratique les concepts
que vous avez étudiés dans le cours.
Ils vous permettront de renforcer vos connaissances concernant la déclaration de variables,
l'écriture d'instructions exécutables, l'interaction avec le serveur Oracle, l'écriture de structures
de contrôle, ou encore l'utilisation de types de données composites, de curseurs et d'exceptions
de traitement. Ces exercices utiliseront les tables employees, jobs, job_history et
departments.
Oracle Database 11g : Les fondamentaux du langage PL/SQL

Exercices complémentaires - 2
Exercices complémentaires 1 et 2
Remarque : Les exercices suivants complètent les exercices relatifs à la déclaration de variables
et à l'écriture d'instructions exécutables.
1. Evaluez chacune des déclarations suivantes. Déterminez celles qui ne sont pas valides et
expliquez pourquoi.
a. DECLARE
name,dept VARCHAR2(14);
b. DECLARE
test NUMBER(5);
c. DECLARE
MAXSALARY NUMBER(7,2) = 5000;
d. DECLARE
JOINDATE BOOLEAN := SYSDATE;

2. Pour chacune des affectations suivantes, déterminez le type de données de l'expression
obtenue.
a. email := firstname || to_char(empno);
b. confirm := to_date('20-JAN-1999', 'DD-MON-YYYY');
c. sal := (1000*12) + 500
d. test := FALSE;
e. temp := temp1 < (temp2/ 3);
f. var := sysdate;

Exercice complémentaire 3
3. DECLARE
v_custid NUMBER(4) := 1600;
v_custname VARCHAR2(300) := 'Women Sports Club';
v_ new_custid NUMBER(3) := 500;
BEGIN
DECLARE
v_custname VARCHAR2(300) := 'Shape up Sports Club';
v_new_custid NUMBER(3) := 300;
v_new_custname VARCHAR2(300) := 'Jansports Club';
BEGIN

v_custid := v_new_custid;
v_custname := v_custname || ' ' || v_new_custname;
1
END;
v_custid := (v_custid *12) / 10;
2
END;
/
Observez le bloc PL/SQL ci-dessus et déterminez le type de données et la valeur de chacune des
variables suivantes d'après les règles de portée :
a. La valeur de v_custid à la position 1 est la suivante :
b. La valeur de v_custname à la position 1 est la suivante :
c. La valeur de v_new_custid à la position 2 est la suivante :
d. La valeur de v_new_custname à la position 1 est la suivante :
e. La valeur de v_custid à la position 2 est la suivante :
f. La valeur de v_custname à la position 2 est la suivante :
Remarque : Les exercices suivants complètent les exercices relatifs à l'interaction avec le serveur
Oracle et à l'écriture de structures de contrôle.
4. Ecrivez un bloc PL/SQL qui accepte une année en tant que donnée d'entrée, et qui vérifie s'il
s'agit d'une année bissextile. Par exemple, si l'année entrée est 1990, le résultat doit être
"1990 is not a leap year".
Indice : L'année doit être divisible par 4, mais pas par 100, ou bien elle doit l'être par 400.

Testez la solution en utilisant les années suivantes :
1990 Année non bissextile
2000 Année bissextile

5. a. Pour effectuer les exercices suivants, vous devez créer une table temporaire où seront
stockés les résultats. Vous pouvez la créer vous-même ou exécuter le script
lab_ap_05.sql qui le fera à votre place. Créez une table nommée TEMP, qui
comporte les trois colonnes suivantes :
Nom de la colonne NUM_STORE CHAR_STORE DATE_STORE
Type de clé
Valeurs
Nulls/uniques
Table de clé
étrangère
Colonne de clé
étrangère
Type de données Number VARCHAR2 Date
Longueur 7,2 35
b. Ecrivez un bloc PL/SQL contenant deux variables, V_MESSAGE et

V_DATE_WRITTEN. Déclarez V_MESSAGE en tant que type de données
VARCHAR2 d'une longueur de 35 caractères et V_DATE_WRITTEN en tant que type
DATE. Affectez les valeurs suivantes aux variables :
Variable Contenu
V_MESSAGE This is my first PL/SQL program
V_ DATE_WRITTEN Date actuelle
Stockez les valeurs dans les colonnes appropriées de la table TEMP. Vérifiez les résultats en
interrogeant la table TEMP.

6. a. Stockez un numéro de département dans une variable de substitution.
b. Ecrivez un bloc PL/SQL pour afficher le nombre de personnes travaillant dans ce
département.
7. Ecrivez un bloc PL/SQL qui déclare une variable nommée sal, contenant le salaire d'un
employé. Dans la section exécutable du programme, effectuez les opérations suivantes :
a. Stockez un nom d'employé dans une variable de substitution.
b. Stockez son salaire dans la variable v_sal.

c. Si le salaire est inférieur à 3 000, accordez à l'employé une augmentation de 500 et
affichez le message "<Employee Name>"s salary updated" dans la fenêtre.
d. Si le salaire est supérieur à 3 000, affichez le salaire de l'employé au format
"<Employee Name> earns …...………".
e. Testez les noms suivants à l'aide du bloc PL/SQL :
NOM SALAIRE
Pataballa 4800
Greenberg 12000
Ernst 6000

8. Ecrivez un bloc PL/SQL permettant le stockage du salaire d'un employé dans une variable
de substitution PL/SQL.
Dans la section exécutable du programme, effectuez les opérations suivantes :
- Calculez le salaire annuel de la façon suivante : salaire * 12.
- Calculez la prime comme indiqué ci-après :
Salaire annuel Prime
>= 20 000 2 000
19 999 – 10 000 1 000
<= 9 999 500
Affichez le montant de la prime dans la fenêtre, en respectant le format suivant :

"The bonus is $……………….."
• Testez le bloc PL/SQL avec les cas suivants :
SALAIRE PRIME
5000 2000
1000 1000
15000 2000
Remarque : Les exercices suivants complètent les exercices relatifs à l'utilisation des types de
données composites et des curseurs, et au traitement des exceptions.
9. a. Exécutez le script lab_ap_09_a.sql afin de créer une table temporaire nommée
emp. Ecrivez un bloc PL/SQL permettant le stockage d'un numéro d'employé, du
nouveau numéro de département et du pourcentage d'augmentation de salaire dans des
variables de substitution.
b. Mettez à jour le numéro de département et le salaire de l'employé en utilisant les
nouvelles valeurs correspondantes. Utilisez la table emp pour effectuer les mises à jour.
Une fois celles-ci terminées, affichez le message "Update complete" dans la fenêtre. Si
aucun enregistrement correspondant n'est trouvé, affichez le message "No Data Found".
Testez le bloc PL/SQL avec les cas suivants :
ID EMPLOYE NOUVEL ID % AUGMENT. MESSAGE
DEPARTEMENT
100 20 2 Update
Complete
10 30 5 No Data
found
126 40 3 Update
Complete

10. Créez un bloc PL/SQL qui déclare le curseur EMP_CUR et permet de sélectionner le nom,
le salaire et la date d'embauche d'un employé, à partir de la table employees. Traitez
chaque ligne à partir du curseur. Si le salaire est supérieur à 15 000 et que la date
d'embauche est postérieure à 01-FEB-1988, affichez le nom, le salaire et la date
d'embauche de l'employé dans la fenêtre, en respectant le format de l'exemple de résultat
ci-après :
11. Créez un bloc PL/SQL permettant d'extraire, à partir de la table EMPLOYEES, le nom de
famille et le numéro de département de chaque employé dont la valeur EMPLOYEE_ID est
inférieure à 114. A l'aide des valeurs extraites de la table employees, remplissez deux

tables PL/SQL, la première avec les enregistrements correspondant aux noms de famille
des employés et la deuxième avec leur numéro de département. En utilisant une boucle,
extrayez à partir des tables PL/SQL les informations relatives au nom et au salaire de
chaque employé. Affichez ensuite les résultats dans une fenêtre à l'aide de
DBMS_OUTPUT.PUT_LINE. Procédez de la sorte pour les 15 premiers employés
contenus dans les tables PL/SQL.

Exercices complémentaires 12, 13 et 14

12. a. Créez un bloc PL/SQL qui déclare un curseur nommé DATE_CUR. Transmettez un
paramètre de type DATE au curseur et affichez les détails relatifs aux employés
embauchés après cette date.
DEFINE B_HIREDATE = 08-MAR-00
b. Testez le bloc PL/SQL avec les dates d'embauche suivantes : 08-MAR-00,
25-JUN-97, 28-SEP-98 et 07-FEB-99.
13. Exécutez le script lab_ap_09_a.sql afin de recréer la table emp. Créez un bloc
PL/SQL permettant d'accorder une promotion aux employés gagnant plus de 3 000, en

les affectant au poste SR CLERK et en augmentant leur salaire de 10 %. Utilisez la table
EMP pour cet exercice. Vérifiez les résultats en interrogeant la table emp.
Indice : Utilisez un curseur avec la syntaxe FOR UPDATE et CURRENT OF.
14. a. Pour effectuer l'exercice suivant, vous devez disposer d'une table où seront stockés les
résultats. Vous pouvez créer la table analysis vous-même ou exécuter le script
lab_ap_14_a.sql qui le fera à votre place. Créez une table nommée analysis
qui comporte les trois colonnes suivantes :
Nom de colonne ENAME YEARS SAL
Type de clé
Valeurs
Nulls/uniques
Table de clé
étrangère
Colonne de clé
étrangère
Type de données VARCHAR2 Number Number
Longueur 20 2 8,2
b. Créez un bloc PL/SQL permettant d'alimenter la table analysis avec les

informations contenues dans la table employees. Utilisez une variable de
substitution pour stocker un nom d'employé.

Exercices complémentaires 12, 13 et 14 (suite)

c. Interrogez la table employees afin de déterminer si l'employé a passé plus de
5 années dans l'organisation. Si son salaire est inférieur à 3500, générez une exception.
Cette dernière doit être traitée à l'aide d'un gestionnaire d'exceptions approprié qui
insère les valeurs suivantes dans la table analysis : nom de l'employé, nombre
d'années dans l'organisation et salaire actuel. Si le salaire de l'employé est supérieur à
3500, affichez le message Not due for a raise dans la fenêtre. Vérifiez les
résultats en interrogeant la table analysis. Testez le bloc PL/SQL avec les cas
suivants :
NOM MESSAGE
Austin Not due for a raise
Nayer Due for a raise

Fripp Not due for a raise
Khoo Due for a raise

Solutions
des exercices
complémentaires

Solutions des exercices complémentaires 1 et 2

1. Evaluez chacune des déclarations suivantes. Déterminez celles qui ne sont pas valides et
expliquez pourquoi.
a. DECLARE
name,dept VARCHAR2(14);
Cette déclaration n'est pas valide, car un seul identificateur est autorisé par
déclaration.
b. DECLARE
test NUMBER(5);
Cette déclaration est valide.
c. DECLARE
MAXSALARY NUMBER(7,2) = 5000;

Cette déclaration n'est pas valide, car l'opérateur d'affectation est incorrect.
Il doit être : =.
d. DECLARE
JOINDATE BOOLEAN := SYSDATE;
Cette déclaration n'est pas valide, car les types de données ne correspondent pas.
Une date ne doit pas être affectée à un type de données booléen. Les données
doivent être du type date.
2. Pour chacune des affectations suivantes, déterminez le type de données de l'expression
obtenue.
a. email := firstname || to_char(empno);
Chaîne de caractères
b. confirm := to_date('20-JAN-1999', 'DD-MON-YYYY');
Date
c. sal := (1000*12) + 500
Nombre
d. test := FALSE;
Booléen
e. temp := temp1 < (temp2/ 3);
Booléen
f. var := sysdate;
Date

Solutions des exercices complémentaires - 2
Solutions de l'exercice complémentaire 3

3. DECLARE
v_custname VARCHAR2(300) := 'Women Sports Club';
v_ new_custid NUMBER(3) := 500;
BEGIN
DECLARE
v_custname VARCHAR2(300) := 'Shape up Sports Club';
v_new_custid NUMBER(3) := 300;
v_new_custname VARCHAR2(300) := 'Jansports Club';
BEGIN
v_custid := v_new_custid;
v_custname := v_custname || ' ' || v_new_custname;
1

END;
v_custid := (v_custid *12) / 10;
2 END;
Observez le bloc PL/SQL ci-dessus et déterminez le type de données et la valeur de chacune des
variables suivantes d'après les règles de portée.
a. La valeur de v_custid à la position 1 est la suivante :
300, et le type de données est NUMBER.
b. La valeur de v_custname à la position 1 est la suivante :
Shape up Sports Club Jansports Club, et le type de données est VARCHAR2.
c. La valeur de v_new_custid à la position 1 est la suivante :
500, et le type de données est NUMBER (ou INTEGER).
d. La valeur de v_new_custname à la position 1 est la suivante :
Jansports Club, et le type de données est VARCHAR2.
e. La valeur de v_custid à la position 2 est la suivante :
1920, et le type de données est NUMBER.
f. La valeur de v_custname à la position 2 est la suivante :
Women Sports Club, et le type de données est VARCHAR2.


4. Ecrivez un bloc PL/SQL qui accepte une année en tant que donnée d'entrée, et qui vérifie s'il
s'agit d'une année bissextile. Par exemple, si l'année entrée est 1990, le résultat doit être
"1990 is not a leap year".
Indice : L'année doit être divisible par 4, mais pas par 100, ou bien elle doit l'être par 400.
Testez la solution en utilisant les années suivantes :


DECLARE
v_YEAR NUMBER(4) := &P_YEAR;
v_REMAINDER1 NUMBER(5,2);
BEGIN
v_REMAINDER1 := MOD(v_YEAR,4);
IF ((v_REMAINDER1 = 0 AND v_REMAINDER2 <> 0 ) OR
v_REMAINDER3 = 0) THEN
DBMS_OUTPUT.PUT_LINE(v_YEAR || ' is a leap year');
ELSE
DBMS_OUTPUT.PUT_LINE (v_YEAR || ' is not a leap year');
END IF;
END;
/


5. a. Pour effectuer les exercices suivants, vous devez disposer d'une table temporaire où
seront stockés les résultats.
Vous pouvez la créer vous-même ou exécuter le script lab_ap_05.sql qui le fera à
votre place. Créez une table nommée TEMP, qui comporte les trois colonnes suivantes :
Nom de la colonne NUM_STORE CHAR_STORE DATE_STORE
Type de clé
Valeurs
Nulls/uniques
Table de clé
étrangère
Colonne de clé
étrangère
Type de données Number VARCHAR2 Date

Longueur 7,2 35
CREATE TABLE temp

(num_store NUMBER(7,2),
char_store VARCHAR2(35),
date_store DATE);
b. Ecrivez un bloc PL/SQL contenant deux variables, V_MESSAGE et

V_DATE_WRITTEN. Déclarez V_MESSAGE en tant que type de données VARCHAR2
d'une longueur de 35 caractères et V_DATE_WRITTEN en tant que type DATE.
Affectez les valeurs suivantes aux variables :
Variable Contenu
V_MESSAGE This is my first PL/SQL program
V_ DATE_WRITTEN Date actuelle
Stockez les valeurs dans les colonnes appropriées de la table TEMP. Vérifiez les
résultats en interrogeant la table TEMP.
DECLARE
V_MESSAGE VARCHAR2(35);
V_DATE_WRITTEN DATE;
BEGIN
V_MESSAGE := 'This is my first PLSQL Program';
V_DATE_WRITTEN := SYSDATE;
INSERT INTO temp(CHAR_STORE,DATE_STORE)
VALUES (V_MESSAGE,V_DATE_WRITTEN);
END;
/
SELECT * FROM TEMP;


6. a. Stockez un numéro de département dans une variable de substitution.
DEFINE P_DEPTNO = 30
b. Ecrivez un bloc PL/SQL pour afficher le nombre de personnes travaillant dans ce
département.
Indice : Activez DBMS_OUTPUT dans SQL Developer.
DECLARE
V_HOWMANY NUMBER(3);
V_DEPTNO DEPARTMENTS.department_id%TYPE := &P_DEPTNO;
BEGIN
SELECT COUNT(*) INTO V_HOWMANY FROM employees
WHERE department_id = V_DEPTNO;

DBMS_OUTPUT.PUT_LINE (V_HOWMANY || ' employee(s) work
for department number ' ||V_DEPTNO);
END;
/
7. Ecrivez un bloc PL/SQL qui déclare une variable nommée sal, contenant le salaire d'un
employé. Dans la section exécutable du programme, effectuez les opérations suivantes :
a. Stockez un nom d'employé dans une variable de substitution :
DEFINE P_LASTNAME = Pataballa
b. Stockez son salaire dans la variable sal.
c. Si le salaire est inférieur à 3 000, accordez à l'employé une augmentation de 500 et
affichez le message "<Employee Name>"s salary updated" dans la fenêtre.
d. Si le salaire est supérieur à 3 000, affichez le salaire de l'employé au format
"<Employee Name> earns …...………"
e. Testez les noms à l'aide du bloc PL/SQL.
Remarque : Supprimez la définition de la variable contenant le nom
d'employé à la fin du script.
NOM SALAIRE
Pataballa 4800
Greenberg 12000
Ernst 6000


DECLARE
V_SAL NUMBER(7,2);
V_LASTNAME EMPLOYEES.LAST_NAME%TYPE;
BEGIN
SELECT salary INTO V_SAL
FROM employees WHERE last_name = INITCAP('&P_LASTNAME')
FOR UPDATE of salary;
V_LASTNAME := INITCAP('&P_LASTNAME');
IF V_SAL < 3000 THEN
UPDATE employees SET salary = salary + 500
WHERE last_name = INITCAP('&P_LASTNAME') ;

DBMS_OUTPUT.PUT_LINE (V_LASTNAME || '''s salary updated');
ELSE
DBMS_OUTPUT.PUT_LINE (V_LASTNAME || ' earns ' ||
TO_CHAR(V_SAL));
END IF;
END;
/
8. Ecrivez un bloc PL/SQL permettant le stockage du salaire d'un employé dans une variable
de substitution. Dans la section exécutable du programme, effectuez les opérations
suivantes :
• Calculez le salaire annuel de la façon suivante : salaire * 12.
• Calculez la prime comme indiqué ci-après :
Salaire annuel Prime
>= 20 000 2 000
19 999 – 10 000 1 000
<= 9 999 500
• Affichez le montant de la prime dans la fenêtre, en respectant le format suivant :

"The bonus is $……………….."
• Testez le bloc PL/SQL avec les cas suivants :
SALAIRE PRIME
5000 2000
1000 1000
15000 2000


DEFINE B_SALARY = 5000
DECLARE
V_SAL NUMBER(7,2) := &B_SALARY;
V_BONUS NUMBER(7,2);
V_ANN_SALARY NUMBER(15,2);
BEGIN
V_ANN_SALARY := V_SAL * 12;
IF V_ANN_SALARY >= 20000 THEN
V_BONUS := 2000;
ELSIF V_ANN_SALARY <= 19999 AND V_ANN_SALARY >=10000 THEN
V_BONUS := 1000;
ELSE
V_BONUS := 500;
END IF;
DBMS_OUTPUT.PUT_LINE ('The Bonus is $ ' ||

TO_CHAR(V_BONUS));
END;
/
9. a. Exécutez le script lab_ap_09_a.sql afin de créer une table temporaire nommée

emp. Ecrivez un bloc PL/SQL permettant le stockage d'un numéro d'employé, du
nouveau numéro de département et du pourcentage d'augmentation de salaire dans des
variables de substitution.
DEFINE B_EMPNO = 100
DEFINE B_NEW_DEPTNO = 10
DEFINE B_PER_INCREASE = 2
b. Mettez à jour le numéro de département et le salaire de l'employé en utilisant les

nouvelles valeurs correspondantes. Utilisez la table emp pour effectuer les mises à jour.
Une fois celles-ci terminées, affichez le message "Update complete" dans la fenêtre. Si
aucun enregistrement correspondant n'est trouvé, affichez le message "No Data Found".
Testez le bloc PL/SQL avec les cas suivants :
ID EMPLOYE NOUVEL ID % AUGMENT. MESSAGE
DEPARTMENT
100 20 2 Update
Complete
10 30 5 No Data
found
126 40 3 Update
Complete


DECLARE
V_EMPNO emp.EMPLOYEE_ID%TYPE := &B_EMPNO;
V_NEW_DEPTNO emp.DEPARTMENT_ID%TYPE := & B_NEW_DEPTNO;
V_PER_INCREASE NUMBER(7,2) := & B_PER_INCREASE;
BEGIN
UPDATE emp
SET department_id = V_NEW_DEPTNO,
salary = salary + (salary *
V_PER_INCREASE/100)
WHERE employee_id = V_EMPNO;
IF SQL%ROWCOUNT = 0 THEN
DBMS_OUTPUT.PUT_LINE ('No Data Found');
ELSE

DBMS_OUTPUT.PUT_LINE ('Update Complete');
END IF;
END;
/
10. Créez un bloc PL/SQL qui déclare le curseur EMP_CUR et permet de sélectionner le nom, le
salaire et la date d'embauche d'un employé, à partir de la table employees. Traitez chaque
ligne à partir du curseur. Si le salaire est supérieur à 15 000 et que la date d'embauche est
postérieure à 01-FEB-1988, affichez le nom, le salaire et la date d'embauche de l'employé
dans la fenêtre.
DECLARE
CURSOR C_EMP_CUR IS
SELECT last_name,salary,hire_date FROM EMPLOYEES;
V_ENAME VARCHAR2(25);
V_SAL NUMBER(7,2);
V_HIREDATE DATE;
BEGIN
OPEN C_EMP_CUR;
FETCH C_EMP_CUR INTO V_ENAME,V_SAL,V_HIREDATE;
WHILE C_EMP_CUR%FOUND
LOOP
IF V_SAL > 15000 AND V_HIREDATE >=
TO_DATE('01-FEB-1988','DD-MON-YYYY') THEN
DBMS_OUTPUT.PUT_LINE (V_ENAME || ' earns '
|| TO_CHAR(V_SAL)|| ' and joined the organization on '
|| TO_DATE(V_HIREDATE,'DD-Mon-YYYY'));
END IF;


FETCH C_EMP_CUR INTO V_ENAME,V_SAL,V_HIREDATE;
END LOOP;
CLOSE C_EMP_CUR;
END;
/
11. Créez un bloc PL/SQL permettant d'extraire, à partir de la table employees, le nom de
famille et le numéro de département de chaque employé dont la valeur EMPLOYEE_ID est
inférieure à 114. A l'aide des valeurs extraites de la table employees, remplissez deux
tables PL/SQL, la première avec les enregistrements correspondant aux noms de famille
des employés et la deuxième avec leur numéro de département. En utilisant une boucle,
extrayez à partir des tables PL/SQL les informations relatives au nom et au salaire de
chaque employé. Affichez ensuite les résultats dans une fenêtre à l'aide de
DBMS_OUTPUT.PUT_LINE. Procédez de la sorte pour les 15 premiers employés contenus

dans les tables PL/SQL.
DECLARE
TYPE Table_Ename is table of employees.last_name%TYPE
INDEX BY BINARY_INTEGER;
TYPE Table_dept is table of employees.department_id%TYPE
INDEX BY BINARY_INTEGER;
Tename Table_Ename;
Tdept Table_dept;
i BINARY_INTEGER :=0;
CURSOR Namedept IS SELECT last_name,department_id from
employees WHERE employee_id < 115;
TRACK NUMBER := 15;
BEGIN
FOR emprec in Namedept
LOOP
i := i +1;
Tename(i) := emprec.last_name;
Tdept(i) := emprec.department_id;
END LOOP;


FOR i IN 1..TRACK
LOOP
DBMS_OUTPUT.PUT_LINE ('Employee Name: ' ||
Tename(i) || ' Department_id: ' || Tdept(i));
END LOOP;
END;
/
12. a. Créez un bloc PL/SQL qui déclare un curseur nommé C_DATE_CUR. Transmettez un
paramètre de type DATE au curseur et affichez les détails relatifs aux employés
embauchés après cette date.
DEFINE B_HIREDATE = 08-MAR-00

b. Testez le bloc PL/SQL avec les dates d'embauche suivantes : 08-MAR-00,
25-JUN-97, 28-SEP-98 et 07-FEB-99.
DECLARE
CURSOR C_DATE_CURSOR(JOIN_DATE DATE) IS
SELECT employee_id,last_name,hire_date FROM employees
WHERE HIRE_DATE >JOIN_DATE ;
V_EMPNO employees.employee_id%TYPE;
V_ENAME employees.last_name%TYPE;
V_HIREDATE employees.hire_date%TYPE;
V_HDATE employees.hire_date%TYPE := '&B_HIREDATE';
BEGIN
OPEN C_DATE_CURSOR(V_HDATE);
LOOP
FETCH C_DATE_CURSOR INTO V_EMPNO,V_ENAME,V_HIREDATE;
EXIT WHEN C_DATE_CURSOR%NOTFOUND;
DBMS_OUTPUT.PUT_LINE (V_EMPNO || ' ' || V_ENAME || ' '
|| V_HIREDATE);
END LOOP;
END;
/


13. Exécutez le script lab_ap_09_a.sql afin de recréer la table emp. Créez un bloc
PL/SQL permettant d'accorder une promotion aux employés gagnant plus de 3 000, en les
affectant au poste SR CLERK et en augmentant leur salaire de 10 %. Utilisez la table emp
pour cet exercice. Vérifiez les résultats en interrogeant la table emp.
Indice : Utilisez un curseur avec la syntaxe FOR UPDATE et CURRENT OF.
DECLARE
CURSOR C_Senior_Clerk IS
SELECT employee_id,job_id FROM emp
WHERE job_id = 'ST_CLERK' AND salary > 3000
FOR UPDATE OF job_id;
BEGIN
FOR Emrec IN C_Senior_Clerk

LOOP
UPDATE emp
SET job_id = 'SR_CLERK',
salary = 1.1 * salary
WHERE CURRENT OF C_Senior_Clerk;
END LOOP;
COMMIT;
END;
/
SELECT * FROM emp;


14. a. Pour effectuer l'exercice suivant, vous devez créer une table où seront stockés les
résultats. Vous pouvez créer la table analysis vous-même ou exécuter le script
lab_ap_14_a.sql qui le fera à votre place. Créez une table nommée analysis,
qui comporte les trois colonnes suivantes :
Nom de colonne ENAME YEARS SAL
Type de clé
Valeurs
Nulls/uniques
Table de clé
étrangère
Colonne de clé
étrangère
VARCHAR2 Number Number

Type de données
Longueur 20 2 8,2
CREATE TABLE analysis

(ename Varchar2(20),
years Number(2),
sal Number(8,2));
b. Créez un bloc PL/SQL permettant d'alimenter la table analysis avec les

informations contenues dans la table employees. Utilisez une variable de
substitution pour stocker un nom d'employé.
DEFINE B_ENAME = Austin
c. Interrogez la table employees afin de déterminer si l'employé a passé plus de

5 années dans l'organisation. Si son salaire est inférieur à 3500, générez une exception.
Cette dernière doit être traitée à l'aide d'un gestionnaire d'exceptions approprié qui
insère les valeurs suivantes dans la table analysis : nom de l'employé, nombre
d'années dans l'organisation et salaire actuel. Si le salaire de l'employé est supérieur à
3500, affichez le message Not due for a raise dans la fenêtre. Vérifiez les
résultats en interrogeant la table analysis. Testez le bloc PL/SQL avec les cas
suivants :
NOM MESSAGE
Austin Not due for a raise
Nayer Due for a raise
Fripp Not due for a raise
Khoo Due for a raise

Solutions de l'exercice complémentaire 14 (suite)

DECLARE
E_DUE_FOR_RAISE EXCEPTION;
V_HIREDATE EMPLOYEES.HIRE_DATE%TYPE;
V_ENAME EMPLOYEES.LAST_NAME%TYPE := INITCAP( '& B_ENAME');
V_SAL EMPLOYEES.SALARY%TYPE;
V_YEARS NUMBER(2);
BEGIN
SELECT LAST_NAME,SALARY,HIRE_DATE
INTO V_ENAME,V_SAL,V_HIREDATE
FROM employees WHERE last_name = V_ENAME;
V_YEARS := MONTHS_BETWEEN(SYSDATE,V_HIREDATE)/12;

IF V_SAL < 3500 AND V_YEARS > 5 THEN
RAISE E_DUE_FOR_RAISE;
ELSE
DBMS_OUTPUT.PUT_LINE ('Not due for a raise');
END IF;
EXCEPTION
WHEN E_DUE_FOR_RAISE THEN
INSERT INTO ANALYSIS(ENAME,YEARS,SAL)
VALUES (V_ENAME,V_YEARS,V_SAL);
END;
/


D49990FR10 SG

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

D49990FR10 SG

Transféré par

Droits d'auteur :

Formats disponibles

THESE eKIT MATERIALS ARE FOR YOUR USE IN THIS CLASSROOM ONLY.

COPYING eKIT MATERIALS FROM THIS COMPUTER IS STRICTLY PROHIBITED

Oracle University and OMNIDATA. use only

Cette documentation contient des informations qui sont la propriété d'Oracle

Oracle University and OMNIDATA. use only

Lauran Serhal U.S. GOVERNMENT RIGHTS

Oracle University and OMNIDATA. use only

1 Introduction au langage PL/SQL

2 Déclarer des variables PL/SQL

Oracle University and OMNIDATA. use only

3 Ecrire des instructions exécutables

Oracle University and OMNIDATA. use only

5 Ecrire des structures de contrôle

Oracle University and OMNIDATA. use only

7 Utiliser des curseurs explicites

Présentation de l'exercice 7 7-28

8 Traiter les exceptions

Oracle University and OMNIDATA. use only

9 Créer des procedures et des fonctions stockées

Annexe A - Solutions des exercices

Annexe B - Description et données des tables

Annexe C - Utiliser SQL Developer

Annexe D - Utiliser SQL*Plus

Annexe E - Utiliser JDeveloper

Annexe F - Curseurs REF

Solutions des exercices complémentaires

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Oracle University and OMNIDATA. use only

A la fin de ce chapitre, vous pourrez :

Oracle University and OMNIDATA. use only

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 2

A la fin de ce cours, vous pourrez :

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 3

Chapitres étudiés le premier jour :

Oracle University and OMNIDATA. use only

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 4

Chapitres étudiés le deuxième jour :

Oracle University and OMNIDATA. use only

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 5

Schéma Human Resources (HR)

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Description du schéma Human Resources (HR)

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 6

Environnements de développement PL/SQL

Ce cours fournit les outils suivants pour le développement du

Oracle University and OMNIDATA. use only

Environnements de développement PL/SQL

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 7

Coder PL/SQL dans Oracle SQL Developer

• Oracle SQL Developer est un outil graphique gratuit qui

Oracle University and OMNIDATA. use only

Copyright © 2007, Oracle. Tous droits réservés.

Oracle SQL Developer : Présentation

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 8

Exécuter du code PL/SQL dans SQL*Plus

Oracle University and OMNIDATA. use only

Exécuter du code PL/SQL dans SQL*Plus

Oracle Database 11g : Les fondamentaux du langage PL/SQL I - 9

Générer du code PL/SQL dans Oracle JDeveloper