SGBD Oracle

05/11/2020 SGDB ORACLE
ATTA BOSSON VALERE

INGENIEUR DE CONCEPTION EN INFORMATIQUE – INGENIEUR IN
SGDB ORACLE
INTRODUCTION GENERALE SUR LA

BASE DE DONNEES ORACLE
1|SGBD ORACLE
ATTA BOSSON VALERE – INGENIEUR DE CONCEPTION EN INFORMATIQUE – ING IN
SGDB ORACLE
I.1 INTRODUCTION
Pour mieux appréhender une base de données et la maîtriser, il est prépondérant

d’avoir une idée sur la manière donc elle fonctionne, les composants sous -jacents
nécessaires à son fonctionnement et la manière donc ces composants interagissent
entre elles, tous ces éléments décrivent l’architecture d’une base de données et la
connaissance de ces éléments permet de mieux les comprendre. Cet article a donc
pour but de présenter l’architecture d’une base de données Oracle, les éléments qui
la compose et la manière donc elles interagissent entre elles.
I.2 PRESENTATION D’UNE BASE DE DONNEES
Avant de faire une présentation de la base de données Oracle, il me semble judicieux

d’apporter une définition à ce qu’est une base de données. Une base de données est
un ensemble structuré d’éléments d’information agencés sous forme de table, dans
lesquels les données sont organisées selon certains critères en vue de permettre leur
exploitation. Ces données doivent être utilisées par des programmes et par des
utilisateurs différents. Elle permet de mettre les données à disposition des clients
(Utilisateurs ou programmes) pour une consultation, une saisie ou bien une mise à
jour tout en s’assurant des droits d’accès à ces derniers. Une bas e de données peut
être locale c’est-à-dire utilisable sur une machine par un utilisateur ou bien répartie,
c’est-à-dire stocké sur des machines distantes et accessible via un réseau. On
distingue un certain nombre de base de données (hiérarchique, réseau, relationnelle,
objet etc…), mais nous nous attarderons sur les bases de données relationnelles
basées sur l’algèbre relationnelle et les travaux de Edgar Frank Codd qui permet de
modéliser facilement et sans grosse contrainte les systèmes du monde réel et de créer
des bases de données facile à maintenir et à faire évoluer. Mais ce n’est pas l’objectif
de cet article, nous présenterons juste l’architecture d’une base de données Oracle.
I.3 SYSTEME DE GESTION DE BASE DE DONNEES
Un système de gestion de base de données est un système logiciel ou ensemble de

programme qui gère et contrôle les accès à une base de données, assurant ainsi une
interface normalisée entre les applications et les bases de données. Un système de
gestion de bases de données relationnelles (SGBDR) est un système qui va permettre
de gérer le contrôle d’accès à une base de données relationnelle. Les SGBDR peuvent
être soit du type client-serveur, soit de type fichiers partagés mais les plus utilisés à
nos jours sont les SGDBR de type client-serveur. Il existe sur le marché plusieurs
2|SGBD ORACLE
SGDB ORACLE
SGBDR parmi lesquels on peut citer : MySQL server, PostgreSQL, Microsoft SQL
Server, IBM DB2, Sybase, Oracle etc.
I.4 PRESENTATION D’ORACLE DATABASE
Oracle Database est l’un des systèmes de gestion de base de données

relationnelles (SGBDR) le plus populaire et le plus performant du marché. C’est un
moteur de base de données très solide qui permet de gérer de grand volume de
données mais qui peut paraitre difficile d’accès au premier abord. Elle est disponible
sur un grand nombre de plate-forme tel que UNIX, LINUX, WINDOWS et
commercialisé sous trois gammes :
 Edition Entreprise / Enterprise Edition
 Edition standard / Standard Edition
 Edition Personnelle / Personal Edition
Les bases de données Oracle sont organisées sous forme de composants qui
présentent les fonctionnalités suivantes :
 La définition et la manipulation des données
 La cohérence des données
 La confidentialité des données
 L'intégrité des données
 La sauvegarde et la restauration des données
 La gestion des accès concurrents
Outre la base de données, la solution Oracle est un véritable environnement de travail
constitué de nombreux programmes ou logiciels permettant de faire une
administration graphique et de s’interfacer avec des produits divers et d’assistants de
création de base données et de configuration de celle-ci. On peut ainsi classifier les
outils d’Oracle selon diverse catégories :
 Les outils d’administration
 Les outils de développement
 Les outils de communication
 Les outils de génie logiciel
 Les outils d’aide à la prise de décision
I.5 ARCHITECTURE GLOBALE D’UN SERVEUR ORACLE
Une base de données Oracle est constituée d’au moins une base de
données ou Database et une instance ou instance de base de données.
L’instance va s’occuper de gérer la mémoire et les processus tandis que la base de
données quant à elle est composée des fichiers physiques appelés Data files, et peut
être sans conteneur ou avec multiple conteneur. La base de données Oracle utilise
3|SGBD ORACLE
SGDB ORACLE
aussi plusieurs fichiers systèmes de base de données pendant son fonctionnement.

Une instance d’architecture de base de données est composée d’une seule instance et
d’une seule base de données. Ce qui permet d’avoir une relation one -to-one entre la
base de données et l’instance. Plusieurs instances peuvent être installées sur le même
serveur et il existe des instances distinctes pour chaque base de données. Cette
configuration permet d’exécuter différentes versions d’Oracle sur la même machine.
Le Listener c’est le processus serveur de la base de données, il reçoit les requêtes

clientes, établie une connexion avec l’instance de la base de données, puis transmet
la connexion cliente au processus serveur. Le Listener peut s’exécuter localement
sur le serveur de la base de données et à distance.
I.6 STRUCTURE D’UNE INSTANCE DE BASE DE DONNEES ORACLE
Une instance de base de données Oracle est composée d’un ensemble de processus
d’arrière-plan et de structure de mémoire. Les structures principales de mémoire
sont le System Global Area (SGA) et les Program Global Areas (PGAs). Les
processus d’arrière-plan opèrent sur les données (Data files) stockées dans la base de
données et utilisent les structures de mémoire pour accomplir leurs tâches. Les base s
de données existent uniquement en mémoire. Oracle crée également des processus
serveurs pour gérer les connexions de la base de données pour le compte des
programmes clients. Ces types de processus sont aussi appelés des processus de
premier plan.
4|SGBD ORACLE
SGDB ORACLE
I.6.1 System Global Area

Le System Global Area (SGA) est la zone mémoire qui contient les données et les
informations de contrôles pour une instance de base de données Oracle. Tous les
processus serveur d’arrière-plan partagent le SGA, lorsqu’on démarre une instance
de base de données, la taille de la mémoire allouée pour le SGA est affichée. Le SGA
inclut les zones mémoires suivantes :
Share pool : C’est la zone mémoire de partage de requêtes et des dictionnaires de
données, elle est impliquée dans presque toutes les opérations sur la base de données.
Database buffer cache : c’est la zone mémoire qui stocke les copies des blocs de
données lues depuis les data files. Un buffer ou mémoire tampon est une adresse
mémoire principale dans laquelle le gestionnaire de mémoire tampon met en cache
de manière temporaire le bloque de données courant ou temporaire.
Redo log buffer : C’est la zone mémoire qui contient les informations sur les
changements apportés à la base de données. Ces informations sont stockées dans les
entrés redo. Les entrées redo contiennent les informations nécessaires pour rétablir
ou reconstruire (redo) les changements qui ont été apportés sur la base de données
par le langage de manipulation de données (LMD) et le langage de définition des
données (LDD) ou des opérations internes. Les entrées redo sont également utilisées
pour le recouvrement de la base de données.
Large pool : C’est une zone mémoire optionnelle destiné aux allocations des
mémoires plus grande que ce qui est approprié pour le shared pool.
Shared I/O pool (SecureFiles) : c’est une zone mémoire utilisée pour des larges
opérations d’entrées/sorties sur les SecureFile Large Object (LOBs). Les LOBs sont
un ensemble de type de données conçus contenir de grandes quantités de données. Le
SecureFile est un paramètre de stockage LOB qui permet la déduplication, le
chiffrement et la compression.
Java pool : C’est la zone mémoire utilisé par la machine virtuelle Java intégrée.
Cette mémoire peut être utilisée de différentes manières en fonction du mode
d’exécution d’Oracle.
Database smart Flash cache : C’est une mémoire optionnelle qui sert d’extension
au buffer database cache pour les bases de données s’exécutant sur Solaris ou Oracle
Linux.
5|SGBD ORACLE
SGDB ORACLE
I.6.2 Program Global Area (PGA)

C’est la mémoire dédiée (non partageable) pour chaque processus serveur de base de
données, elle contient les données et des informations de contrôles exclusivement
destinées aux processus serveur d’arrière-plan. Oracle database crée des processus
serveurs pour gérer les connexions de la base de données pour le compte des
programmes clients. Dans un environnement de serveur dédié, un PGA est créé pour
chaque processus serveur et processus d’arrière-plan qui sont démarrés, chaque PGA
est composé d’un espace d’empilage et d’un User Global Area (UGA) ou zone
globale d’utilisateur. Le PGA est désalloué lorsque le serveur associé ou le processus
d’arrière-plan qui l’utilise est terminé. Dans un environnement partagé, plusieurs
utilisateurs client partagent le processus serveur, l’UAG est déplacé dans le SGA
laissant le PGA avec un espace d’empilage. Dans une session serveur dédiée, l’UGA
est composé des éléments suivants :
SQL work areas : Ce sont des allocations mémoires privées de la mémoire du PGA
utilisé pour les opérations SQL nécessitant beaucoup de mémoire.
Session memory : C’est une zone de stockage de données de session utilisateur
alloué pour les variables sessions tel que les informations de connexion, et d’autres
informations qui sont requis par la session de la base de données.
Private SQL area : Cette zone contient les informations sur les requêtes SQL
analysées et d’autre information spécifique à la session. Lorsqu’un processus serveur
exécute du code SQL ou PL/SQL, le processus utilise la zone SQL privée pour
stocker les valeurs de variable de liaison.
6|SGBD ORACLE
SGDB ORACLE
I.6.3 Les processus d’arrière-plan / Background Processes

Comme nous l’avons dit plus haut, une instance de base de données oracle est
composée de structure de mémoire et de processus d’arrière-plan, alors les processus
d’arrière-plan font partie de l’instance de base de données oracle et exécutent les
tâches de maintenance requis pour opérer sur la base de données tout en maximisant
les performances pour plusieurs utilisateurs. Chaque processus d’arrière-plan exécute
une seule tâche, mais travaille avec les autres processus. Oracle Database crée
systématiquement les processus d’arrière-plan lorsqu’on lance ou démarre une
instance de base de données. Les processus d’arrière-plan qui sont présents
dépendent des fonctionnalités qui sont en cours d’utilisation dans la base de données.
Lorsqu’on démarre une instance de base de données les processus d’arrière-plan
obligatoires sont automatiquement démarrés, et les processus d’arrière-plans
optionnels peuvent être démarrés plus tard en cas de besoin. Les processus d’arrière -
plan obligatoires sont présents dans toutes les configurations de base de données, ces
processus s’exécutent par défaut dans une instance de base de données en
lecture/écriture exécutée avec un fichier de paramètre d’initialisation configuré de
façon minimal. Une instance de base de données accessible u niquement en lecture
désactive certains de ces processus. Les processus d’arrière-plan obligatoire
comprennent :
Database Writer (DBWn) : Ces processus sont chargés d’écrire les bloques
modifiés de base de données depuis Database buffer cache vers les fich iers de
données (Data files). On peut avoir plusieurs de ce type de processus sur des système s
multitraitement.
LogWriter (LGW) : Est le processus chargé d’écrire le contenu du Redo log buffer
(zone mémoire qui contient les modifications sur la base de don nées) dans le fichier
de journalisation courant (Redo log files). Cette écriture est déclenchée dans par des
évènements tels que commit (validation d’une transaction) et lorsque le Redo log
buffer est plein.
CheckPoint (CKPT) : C’est le processus qui permet de rendre cohérent le fichier de
données et le fichier de contrôle, il enregistre le point de reprise dans l’entête du
fichier de données (data file) et dans l’entête du fichier de contrôle (control file).
System Monitor (SMON) : C’est le processus chargé faire la récupération de
l’instance de base de données après un arrêt anormal (rôle principal), il le fait selon
deux stratégies, en appliquant au fichier de données les modifications non
enregistrées des transactions non validées et en enlevant des fich iers de données les
modifications enregistrées des transactions non validées (Rollback). Il est aussi
chargeé de libérer les segments temporaires inutilisés.
Process Monitor (PMON) : Ce processus est principalement chargé de nettoyer
l’heure de plantage d’un processus utilisateur (Annulation rollback de la transaction
et libération des verrous et des ressources).
7|SGBD ORACLE
SGDB ORACLE
Archiver (ARCn) : Ce sont des processus chargés de l’archivage des fichiers de

journalisation pleins, donc lorsqu’un fichier de journalisation est plein, il est
automatiquement archivé par un processus ARC.
I.6.4 Structure de la base de données

La structure globale de stockage de d’une base de données oracle est composée d’une
structure visible à l’OS et d’une structure invisible à l’OS. La structure visible à l’OS
correspond à la structure physique c’est-à-dire les fichiers systèmes de base de
données qui existent aux niveaux du système d’exploitation et la structure invisible
correspond à la structure logique de la base de données c’est-à-dire les tablespaces.
 Structure physique
Il s’agit des fichiers qui constituent la base de données Oracle, ils sont organisés
comme suit :
 Les fichiers de contrôles / Control files : Ce sont des fichiers qui contiennent
les données sur la base de données elle-même on les appelle les métadonnées.
Ces fichiers sont critique à la base de données, sans eux, il est impossible
d’ouvrir les data files (fichiers de données) pour accéder aux données de la
base de données.
 Data files / Fichiers de données : Ce sont des fichiers qui contiennent les
données de la base de données, en d’autres termes tous les informations
stockées dans la base données sont dans ces fichiers.
 Online redo log files /Fichiers de journalisation : Ce sont des fichiers qui
vont servir au recouvrement de la base de données en cas de crashe de celle-
ci, en effet elles contiennent les données sur les changements apportés à la
base de données. Si la base de données crashe et ne perd pas de fichier de
données, alors l’instance peut recouvrir la base de données avec les
8|SGBD ORACLE
SGDB ORACLE
informations que contiennent ces fichiers. Les redo log files sont multiplexés
pour éviter leur perte.
Il existe d’autres fichiers qui ne font pas partir officiellement de la base de données
mais sont important pour le fonctionnement de la base de données il s’agit de :
 Le fichier de paramètre / Parameters file : Utilisé pour définir comment
l’instance sera configurée à son démarrage.
 Le fichier de mot de passe / Password file : Permet aux utilisateurs de se
connecter à distance sur la base de données et d’effectuer des tâches
d’administrations.
 Archive log files : Ces fichiers contiennent l’historique en cours du redo
générée par l’instance, elles permettent le recouvrement de la base de données.
L’utilisation de ces fichiers avec le backup de la base de données permet de
recouvrer les data files perdues.
 Structure logique
Une base de données Oracle d’un point de vu logique est organisée en Tablespace.
Un Tablespace est un espace logique dans lequel sont stockés les objets de base de
données (table, vue, index, procédure, etc.). Les objets de base de données sont
stockés dans des tablespaces sous forme de segment. Chaque segment contient un ou
plusieurs extents. Un extent est composé de blocks de données contigus, ce qui
signifie que chaque extent ne peut exister que dans un data file. Les blocks de
données sont de petite unité d’entrées/sorties de la base de données. Lorsqu’une base
de données requête un ensemble de data block à partir du système d’exploitation, le
système d’exploitation fait une correspondance avec le block actuel de l’OS. Un
tablespace ne peut appartenir qu’à une et une seule base de données à un moment
donné et est composé d’un ou plusieurs datafiles.
9|SGBD ORACLE
SGDB ORACLE
Conclusion relative à la base de données Oracle

En somme une base de données Oracle c’est deux choses, une base de données et
une instance. L’instance est composée de processus d’arrière-plan tels que PMOM,
LGW, SMON, ARC, etc. et des structures de mémoire dont les principales sont le
SGA et le PGA. La base de données quant à elle possède une structure physique
visible par l’os qui est composée des fichiers systèmes de la base de données et une
structure logique invisible de l’os qui permet de stocker les objets de base de données
d’une manière logique.
10 | S G B D O R A C L E
SGDB ORACLE
SQL : STRUCTURE QUERY LANGUAGE
SGDB ORACLE
II.1 DEFINITIONS
 SQL est un langage pour les BDR.Crééen1970 par IBM.

 Principales caractéristiques de SQL:
 Normalisation: SQL implémente le modèle relationnel.
 Standard: Du fait de cette normalisation, la plupart des éditeurs de SGBDR
intègrent SQL à leurs produits (Oracle, Informix, Sybase, Ingres, MSSQL Server,
DB2, etc.). Ainsi, les données, requêtes et applications sont assez facilement
portables d’une base à une autre.
 Non procédural: SQL est un langage de requêtes qui permet à l’utilisateur de
demander un résultat sans se préoccuper des moyens techniques pour trouver ce
résultat (assertionnel).C’est l’optimiseur du SGBD (composant du moteur) qui se
charge de cette tâche.
 Universel: SQL peut être utilisé à tous les niveaux dans la gestion d’une BDR:
 Langage de Définition de Données LDD,
 Langage de Manipulation de Données LMD,
 Langage de Contrôle de Données LCD
 Langage de définition de données LDD: permet la description de la structure de la

base de données (tables, vues, attributs, index).
 Langage de manipulation de données LMD: permet la manipulation des tables et
des vues avec les quatre commandes: SELECT, INSERT, DELETE, UPDATE.
 Langage de contrôle de données LCD: comprend les primitives de gestion des
transactions: COMMIT, ROLL back et des privilèges d’accès aux données:
GRANT et REVOKE.
II.2 LANGAGE DE DEFINITION DE DONNEES : LDD
 La définition de données dans SQL permet la définition des objets manipulés par le
SGBD.
 Les objets : table, vue, index
 Les commandes du LDD sont:
 CREATE: création des objets.
 ALTER: modification de la structure des objets.
 DROP: suppression des objets.
II.2.1 Syntaxe de Création des tables

Celle-ci consiste à définir son nom, les colonnes qui la composent et leurs types. Elle fait
avec la commande: CREATE TABLE
Syntaxe:
CREATE TABLE nom_table
(col1type[(taille)][defaultValeurParDefaut][null/notnull][contraintedecolonne],
col2type[(taille)][defaultValeurParDefaut][null/notnull][contraintedecolonne],
colntype[(taille)][defaultValeurParDefaut][null/notnull][contraintedecolonne]
[Contrainte de tables]);
SGDB ORACLE
Exemple : Créer la table Produit ayant comme schéma :

Produit (Numprod,Desprod,Couleur,Poids,Qte_stk,Qte_seuil,Prix)
Avec
Numprod:de type numérique de taille 6,
Desprod:de type caractère variable de taille15,
Couleur: de type caractère sur une position,
Poids:de type numérique sur huit positions dont trois chiffres après la virgule,
Qte_stk:de type numérique sur sept positions dont trois chiffres après la virgule,
Qte_seuil:de type numérique sur sept positions dont trois chiffres après la virgule,
Prix:de type numérique sur dix positions dont sept chiffres avant la virgule.
Solution
CREATE TABLE Produit
(Numprod number(6) not null,
Desprodvarchar(15),
Couleur char,
Poids number(8,3),
Qte_stk number(7,3),
Qte_seuil number(7,3),
Prix number(10,3));
II.2.2 Définition des contraintes

Clé étrangère (intégrité référentielle):lorsque la clé primaire figure dans une
autre table en tant qu'un attribut non clé. La clé étrangère peut être définie comme
contrainte de table ou comme contrainte de colonne.
Clé étrangère comme contrainte de table selon la syntaxe:
CONSTRAINT nom_contrainte FOREIGNKEY (nom_att)references

nom_table(nom_att);
Clé étrangère comme contrainte de colonne: en ajoutant devant la colonne clé
étrangère references nom_table(nom_att),
Remarque:
Il est impossible de créer une clé étrangère si la clé primaire associée n'existe pas.
Définition des contraintes
Types de CI Oracle:
NULL/NOTNULL: niveau colonne
1. UNIQUE (colonne1 [, colonne2]…)
2. PRIMARYKEY (colonne1 [, colonne2]…)
3. FOREIGNKEY (colonne1 [, colonne2]…)
REFERENCES nom Table

Père(colonne1[,colonne2]…)[ONDELETE{CASCADE|SETNULL}]
4. CHECK {condition}
Les 4 dernières CI sont définissables au niveau colonne ou au niveau table.
SGDB ORACLE
Exemple
Si on considère le schéma suivant:
MAGASIN (Num,Mag,Adresse,Surface)
PRODUIT (NumProd,DesProd,Couleur,Poids,Qte_Stk,#CodMag)
La commande pour la création de la table Magasin étant:

Create Table Magasin
(NumMag number(6) primary Key,
Adresse varchar(30),
Surface number(7,3));
 La commande pour la création de la table Produit peut être écrite de deux façons:
Solution 1: clé étrangère comme contrainte de table CREATE TABLE Produit
(Numprod number(6) primary key,
Desprodvarchar(15),
Couleur char,
Poids number(8,3),
Prix number(10,3),
CodMag number(6),
Constraint FK_Produit Foreing Key (CodMag) references
Magasin(NumMag));
Solution 2: clé étrangère comme contrainte de colonne

Desprodvarchar(15),
Couleur char,
Poids number(8,3),
Prix number(10,3),
CodMag number(6) references Magasin(NumMag));
II.2.3 Contrainte de valeur avec la clause check

Permet de limiter les valeurs possibles pour une colonne en vérifiant une certaine
condition. Le contrôle se fera lors des insertions des données.
Constraint nom_contrainte CHECK (colonne condition)

La condition sur la colonne peut utiliser:
un opérateur de comparaison
la clause between val1 and val2
La clause in (liste de valeurs)
Exemple
SGDB ORACLE
On suppose que le poids d’un produit doit être positif. La commande de création de la
table Produit devient :

Desprodvarchar(15),
Couleur char,
Poids number(8,3),
Prix number(10,3),
CodMag number(6) references Magasin(NumMag),
Constraint Ck1_Produit CHECK (Poids >=0));
II.2.4 Modification de la structure d’une table

 Les trois possibilités de modification de la structure de table sous ORACLE
permettent soit d'ajouter des colonnes, soit de modifier la structure d'une colonne,
soit de supprimer des colonnes existantes.
1ère forme : Ajout de nouvelles colonnes à une table

Syntaxe:
ALTER TABLE nom_table
ADD (col1 type [(taille)] [null / not null] ,
col2 type [(taille)] [null / not null] ,
...
coln type [(taille)] [null / not null] ) ;
Supposons qu'on veut ajouter une colonne type_clt à la table client :

ALTER TABLE CLIENT
ADD type_clt char(3) ;
2ème forme : Modification de la structure d'une colonne existante

Syntaxe:
MODIFY(col1 type [(taille)] [null / not null] ,
col2 type [(taille)] [null / not null] ,
...
coln type [(taille)] [null / not null] ) ;
Pour modifier le nom d'une colonne :

RENAME COLUMN nom_table.ancien_nom TO nom_table.nouveau_nom ;
Exemple:
Supposons qu'on veut changer le type_clt de char(3) en char(5) :
ALTER TABLE CLIENT
MODIFY type_clt char (5) default ‘Monas’;
3èmeforme : Suppression de colonnes existantes
Syntaxe:
SGDB ORACLE

DROP ( col1 , col2 ,…, coln ) ;
Exemple:
Supposons qu'on veut supprimer le champ ville de la table Magasin :
ALTER TABLE Magasin
DROP ville ;
4èmeforme : Ajout d'une contrainte

Syntaxe:
ADD ConstraintDef_de_contrainte ;
Exemple:
Ajouter à la relation Magasin la contrainte suivante: la surface doit être comprise entre 10
et 100 m2
ALTER TABLE Magasin
ADD Constraintck1_magasin check (surface between 10 and 100);
5ème forme : Suppression de contraintes existantes

 Suppression d'une contrainte clé primaire:
On peut effacer une clé primaire. La commande est:
ALTER TABLE nom_table DROP PRIMARY KEY [CASCADE];
Remarque:
 L'option cascade est ajoutée pour pouvoir supprimer une clé primaire référencée.
Exemple:
Supprimer la contrainte clé primaire de la table magasin
ALTER TABLE magasin DROP PRIMARY KEY CASCADE;
 Suppression d'une contrainte autre que la clé primaire:
On peut effacer une clé étrangère. La commande est:
ALTER TABLE nom_table DROP CONSTRAINT nom_contrainte;
Où Le nom de la contrainte c'est celui de la contrainte à supprimer.
Exemple:
Supprimer la contrainte spécifiant les couleurs possibles pour les produits
ALTER TABLE produit DROP CONSTRAINT Ck4_Produit;
Remarque:
Pour retrouver les différentes contraintes avec leurs propriétés, on peut utiliser la
commande suivante :
Select * from user_constraints

[where table_name = 'NOM TABLE' ];
Il est à remarquer que pour cette commande, le nom de la table doit être écrit en majuscule.
Suppression de tables
Syntaxe:
SGDB ORACLE
DROP TABLE nom_table ;

Exemple :
Supposons qu'on veut supprimer la table client_tunis :
DROP TABLE client_tunis ;
Remarque :
Contrainte de suppression de table: permet de supprimer toutes les contraintes d'intégrité
référentielles qui se reflètent aux clés uniques ou primaires de la table à supprimer. La
commande est:
DROP TABLE nom_table CASCADE CONSTRAINTS;
II.3 LANGAGE DE MANIPULATION DE DONNEES : LMD
II.3.1 Les commandes du LMD
 INSERT: ajoute des lignes à une table.

 UPDATE: mettre à jour les colonnes d’une table.
 DELETE: suppression d’un ou de plusieurs enregistrements.
 SELECT: définition de la liste des colonnes que l’on peut obtenir.
Donner la commande permettant de remplir la première ligne de la table produit.
II.3.2 Modification de données

L'opération de modification consiste à mettre à jour les colonnes d'une table par de
nouvelles valeurs.
Syntaxe:
UPDATE nom_table
SETcol1=val1,…,coln=valn
WHERE condition;
SGDB ORACLE
Remarques:
Il n'est pas possible de mettre à jour plus qu'une table à la fois.
La modification des données n’est pas autorisée que si les contraintes sont toujours
valides.
Les valeurs peuvent être des constantes, des expressions, des résultats de sous-requêtes ou
NULL (pour supprimer la valeur initiale du champ).
Si la clause Where n’apparaît pas dans la commande, il s’agit de mettre à jour tous les
enregistrements de la table avec la même valeur.
Exemple
Modifier la désignation du produit numéro 80 en Imprimante
UPDATE Produit
SET DesProd='Imprimante'
WHERE numProd=80;
Majorer de 5% les prix des produits dont le prix est supérieur à 10.
UPDATE Produit
SETPrix=Prix*1.05
WHEREprix>10;
Modifier les quantités de tous les produits aveclavaleur10.

UPDATEproduit
SETQte_stk=10;
II.3.3 Suppression de données

La commande DELETE permet de supprimer un ou plusieurs enregistrements d’une table
tout en gardant la base cohérente. Les enregistrements à supprimer sont spécifiés par la
condition de la clause WHERE.
Syntaxe:
DELETE FROM nom_table
[WHERE condition];
Exemple:
Supprimer tous les Produits de couleurs Blanche
DELETE FROM Produit
Where Couleur = 'B';
Supprimer toutes les lignes de la table Produit
DELETE FROM Produit;
II.3.4 Consultation de données

SQL est basé sur l'utilisation de blocks de qualification dont la structure est composée
principalement de trois éléments:
 SELECT: permet de définir la liste des colonnes que l'on peut obtenir.
 FROM:n'indiquequelesnomsdestablesnécessairespourobtenirlerésultatsouhaité.
 WHERE:définitlaconditionquedoitvérifierunn-
upletdonnépourqu'ilfassepartiedurésultat.
SGDB ORACLE
Syntaxe:
SELECTcol1, col2,…,coln
FROMnom_table
[WHEREcondition];
Remarque
o Si on souhaite avoir toutes les colonnes de la table, on mettra après SELECT *.
o Si on souhaite avoir toutes les lignes de la table, on ne met pas la clause WHERE.
II.3.4.1 Notion d’alias

 Chaque fois qu'une requête d'interrogation est exécutée, les noms des colonnes
définies dans la structure de la table apparaissent comme titres de colonnes. On
peut modifier ces noms de colonnes, à l'affichage uniquement, en ajoutant des
SGDB ORACLE
ALIAS. Si l’alias est composé de plusieurs mots il faut qu’il apparaisse entre
cotes"".
La commande devient:
SELECTcol1[alias1],col2[alias2],…,coln[aliasn]
FROMnom_table
[WHEREcondition];
Exemple
Afficher les numéros et désignations de tous les produits. Les titres des colonnes à
afficher seront respectivement Numéro et Nom Produit
Solution
Select numprod Numéro, desprod "Nomproduit" From Produit;
II.3.4.2 Spécification d’un critère dans une requête

La condition est composée généralement de trois termes:
 un nom de colonne,
 un opérateur de comparaison,
 et une constante, une colonne, une liste de valeurs, une expression ou une requête.
 En plus des opérateurs classiques de comparaison (=,<>,<,>,>=,<=)ORACLE
dispose d'un certain nombre d'opérateurs spécifiques dont principalement:
 ISNULL: permet de tester si le contenu d'une colonne est une valeur nulle
(indéfinie).
 IN (liste de valeurs):permet de tester si le contenu d'une colonne coïncide avec
l'une des valeurs de la liste.
 BETWEEN V1 and V2:permet de tester si le contenu d'une colonne est compris
entre les valeurs V1 et V2.
 LIKE chaîne générique: permet de tester si le contenu d'une colonne ressemble à
une chaîne de caractères obtenue à partir de la chaîne générique. La chaîne
générique est une chaîne de caractères qui contient l'un des caractères suivants:
 %: remplace une autre chaîne de caractères qui peut être même une chaîne vide.
 _:remplace un seul caractère.
 Si la condition est composée de sous conditions, on fait recours aux opérateurs
logiques AND, OR et la négation NOT(NOT In, NOT Like, NOT Between, Is
NOTLIKE)
II.3.5 Les fonctions intégrées de SQL

Dans les clauses SELECT et WHERE, on peut utiliser des expressions arithmétiques et
des fonctions:
 ABS(n):permet de calculer la valeur absolue de n.
 CEIL(n):permet d'avoir le plus petit entier supérieur ou égal à n.
 Ceil(128.3)retourne129
 Ceil(128.8)retourne129
 FLOOR(n):permet d'avoir la partie entière de n.
 FLOOR(128.3)retourne128
 FLOOR(128.7)retourne128
 MOD(m,n):permet d'avoir le reste de la division entière de m par n.
 ROUND(m,n):arrondit la valeur n à m décimal.
 Round(128.3)retourne128
SGDB ORACLE
 Round(128.8)retourne129
 POWER(m,n):permet d'avoir m puissance n
 SIGN(n):donne –1 si n<0,donne 0 sin=0 et donne 1 si n>1.
 SQRT(n):permet d'avoir √n.
 TRUNC (m,n):permet de tronquer la valeur après m décimales.
Sin est négatif, la valeur de m est tronquée avant le point décimal.
 TRUNC(121.371,1)retourne121.3
 TRUNC(121.371,2)retourne121.37
 TRUNC(121.371,-1) retourne 120
 TRUNC(121.371,-2) retourne 100
II.3.6 Les expressions agrégats (ou fonctions de groupe)

ORACLE dispose d'une fonction appelée fonctions agrégats qui s'appliquent à un
ensemble de données:
 AVG: permet d'avoir la moyenne arithmétique d'un ensemble donné.
 COUNT: permet d'avoir le nombre d'occurrences des enregistrements.
 MAX: permet d'avoir la valeur maximale dans une colonne.
 MIN: permet d'avoir la valeur minimale dans une colonne.
 SUM: permet d'avoir la somme des éléments.
 STDDEV: permet d'avoir l'écart type.
 VARIANCE : permet d'avoir la variance.
Chacune de ces fonctions a comme argument un nom de colonne ou une expression
arithmétique. Elles ignorent les valeurs nulles et par défaut prennent les valeurs multiples
pour des valeurs différentes.
 Pour ne prendre que les valeurs distinctes, il faut ajouter l'opérateur DISTINCT. Et
si l'on veut insister pour prendre toutes les valeurs qui existent, on doit précéder la
colonne ou l'expression par l'opérateur ALL.
 La fonction COUNT peut prendre comme argument le caractère * pour connaître
le nombre de lignes sélectionnées.
Remarque
 On ne peut pas mettre une fonction de groupe après la clause WHERE parce
qu'elle s'agit d'une valeur inconnue.
Les requêtes imbriquées

Les requêtes imbriquées sont des requêtes à l'intérieur d'autres requêtes. Ceci se produit
lorsque la clause WHERE contient elle-même une sous requête.
La sous requête(ou requête/bloc interne):
Peut retourner une seule colonne.
Peut retourner des données: depuis une ou plusieurs lignes.
 La sous requête est typiquement codée comme partie d'un prédicat utilisant=,
lorsqu'elle retourne une seule valeur ou utilisant IN lorsqu'elle retourne plusieurs
valeurs.
SGDB ORACLE
 Requêtes imbriquées simples : la requête interne est indépendante–de la requête

externe–dans le sens où elle est complètement évaluée avant la requête externe qui
utilisera ensuite le résultat.
II.3.7 Les requêtes imbriquées simples

Syntaxe
SELECT col1, col2, …, coln
FROM table-name
WHERE (col1, col2,…, coln) opérateur( SELECT col1, col2, …, coln
FROM table-nameWHERE . . . . .);
Exemple
o Afficher les numéros des produits de même couleur que le produit numéro 100
SELECT numprod
FROM produit
Wherecouleur = (SELECT couleur
FROM produit
WHERE numprod= 100);
Exemple
o Afficher les numéros des produits de même couleur qu’un ordinateur
SELECT numprod
FROM produit
Where couleur IN(SELECT couleur
FROM produit
WHERE upper (ltrim(rtrim(desprod))) = 'ORDINATEUR');
o Afficher les numéros des produits dont la quantité est supérieure à la quantité de
tout produit de couleur rouge
SELECT numprod
FROM produit
Where qte_stk > all(SELECT Qte_stk
FROM produit
WHERE upper(couleur)='R');
ou
SELECT numprod
FROM produit
Where qte_stk > (SELECT MAX(Qte_stk)
FROM produit
WHERE upper(couleur)='R');
II.3.8 Les opérateurs ensemblistes

 Union: Elle permet d'avoir les résultats de la première requête suivis de ceux de la
deuxième requête.
 Intersect: Elle permet d'avoir les lignes communes aux résultats des deux requêtes.
 Minus: Elle permet d'avoir les lignes qui apparaissent dans la première requête et
qui n'apparaissent pas dans la seconde.
Avec l'utilisation de ces opérateurs:
SGDB ORACLE
Les deux SELECT doivent avoir le même nombre de colonnes. Ces colonnes doivent être
de types compatibles.
Les doublons sont automatiquement éliminés: Pas de lignes redondantes dans le résultat.
Les titres des colonnes résultats sont ceux de la première requête.
Exercices et manipulations avec des cas pratiques.
SGDB ORACLE
PL (PROCEDURAL LANGUAGE)/SQL
SGDB ORACLE
III.1 PL/SQL
Le PL de PL/SQL signifie Procedural Language. Il s’agit d’une extension procédurale du

SQL permettant d’effectuer des traitements complexes sur une base de données. Les
possibilités offertes sont les mêmes qu’avec des langages impératifs (instructions en
séquence) classiques.
III.2 BLOCS
Tout code écrit dans un langage procédural est formé de blocs. Chaque bloc comprend une
section de déclaration de variables, et un ensemble d’instructions dans lequel les variables
déclarées sont visibles.
La syntaxe est
DECLARE
/* declaration de variables */
BEGIN
/* instructions a executer */
END;
III.3 AFFICHAGE
Pour afficher le contenu d’une variable, les

procédures DBMS_OUTPUT.PUT() et DBMS_OUTPUT.PUT_LINE() prennent en
argument une valeur à afficher ou une variable dont la valeur est à afficher. Par défaut, les
fonctions d’affichage sont désactivées. Il convient, à moins que vous ne vouliez rien voir
s’afficher, de les activer avec la commande SQL+ SET SERVEROUTPUT ON.
III.4 VARIABLES
Une variable se déclare de la sorte :
nom type [:= initialisation] ;
L’initialisation est optionnelle. Nous utiliserons les mêmes types primitifs que dans les
tables. Par exemple :
SET SERVEROUTPUT ON
SGDB ORACLE
DECLARE
c varchar2(15) := 'Hello World !';
BEGIN
DBMS_OUTPUT.PUT_LINE(c);
END;
/
Les affectations se font avec la syntaxe variable := valeur;
III.5 TRAITEMENTS CONDITIONNELS
Le IF et le CASE fonctionnent de la même façon que dans les autres langages impératifs :
IF /* condition 1 */ THEN
/* instructions 1 */
ELSE
END IF;
voire
IF /* condition 1 */ THEN
ELSIF /* condition 2 */
ELSE
END IF;
SGDB ORACLE
Les conditions sont les mêmes qu’en SQL. Le switch du langage C s’implémente en
PL/SQL de la façon suivante :
CASE /* variable */
WHEN /* valeur 1 */ THEN
WHEN /* valeur 2 */ THEN
...
WHEN /* valeur n */ THEN
/* instructions n */
ELSE
/* instructions par défaut */
END CASE;
III.6 TRAITEMENTS REPETITIFS
LOOP ... END LOOP; permet d’implémenter les boucles
LOOP
/* instructions */
END LOOP;
L’instruction EXIT WHEN permet de quitter une boucle.
LOOP
/* instructions */
EXIT WHEN /* condition */ ;
END LOOP;
La boucle FOR existe aussi en PL/SQL :
FOR /* variable */ IN /* inf */../* sup */ LOOP
SGDB ORACLE
/* instructions */
END LOOP;
Ainsi que la boucle WHILE :
WHILE /* condition */ LOOP

/* instructions */
END LOOP;
Est-il possible, en bidouillant, d’implémenter une boucle DO ... WHILE ?
III.7 TABLEAUX ET STRUCTURES
III.7.1 Tableaux
 Création d’un type tableau
Les types tableau doivent être définis explicitement par une déclaration de la forme
TYPE /* type */ IS VARRAY (/* taille */) OF /* typeElements */;
 type est le nom du type tableau crée par cette instruction

 taille est le nombre maximal d’éléments qu’il est possible de placer dans le tableau.
 Type Elements est le type des éléments qui vont être stockés dans le tableau, il peut
s’agir de n’importe quel type.
Par exemple, créons un type tableau de nombres indicé de 1 à 10, que nous
appelerons numberTab
TYPE numberTab IS VARRAY (10) OF NUMBER;
 Déclaration d’un tableau
Dorénavant, le type d’un tableau peut être utilisé au même titre

que NUMBER ou VARCHAR2. Par exemple, déclarons un tableau appelé t de
type numberTab,
SGDB ORACLE
DECLARE
t numberTab;
BEGIN
/* instructions */
END;
/
 Allocation d’un tableau
La création d’un type tableau met à disposition un constructeur du même nom que le type
créé. Cette fonction réserve de l’espace mémoire pour ce tableau et retourne l’adresse
mémoire de la zone réservée, il s’agit d’une sorte de malloc. Si, par exemple, un type
tableau numtab a été crée, la fonction numtab() retourne une tableau vide.
DECLARE
t numberTab;
BEGIN
t := numberTab();
/* utilisation du tableau */
END;
/
Une fois cette allocation faite, il devient presque possible d’utiliser le tableau...
 Dimensionnement d’un tableau
Le tableau retourné par le constructeur est vide. Il convient ensuite de réserver de l’espace
pour stocker les éléments qu’il va contenir. On utilise pour cela la
méthode EXTEND(). EXTEND s’invoque en utilisant la notation pointée. Par exemple,
DECLARE
SGDB ORACLE
t numberTab;
BEGIN
t := numberTab();
t.EXTEND(4);
/* utilisation du tableau */
END;
/
Dans cet exemple, t.EXTEND(4); permet par la suite d’utiliser les éléments du
tableau t(1), t(2), t(3) et t(4). Il n’est pas possible "d’étendre" un tableau à une taille
supérieure à celle spécifiée lors de la création du type tableau associé.
 Utilisation d’un tableau
On accède, en lecture et en écriture, à l’i-ème élément d’une variable tabulaire nommé T

avec l’instruction T (i). Les éléments sont indicés à partir de 1.
Effectuons, par exemple, une permutation circulaire vers la droite des éléments du tableau
t.
DECLARE
t numberTab;
i number;
k number;
BEGIN
t := numberTab();
t.EXTEND(10);
FOR i IN 1..10 LOOP
t(i) := i;
END LOOP;
k := t(10);
FOR i in REVERSE 2..10 LOOP
t(i) := t(i - 1);
END LOOP;
SGDB ORACLE
t(1) := k;
FOR i IN 1..10 LOOP
DBMS_OUTPUT.PUT_LINE(t(i));
END LOOP;
END;
/
III.7.2 Structures
Une structure est un type regroupant plusieurs types. Une variable de type structuré contient
plusieurs variables, ces variables s’appellent aussi des champs.
 Création d’un type structuré
On définit un type structuré de la sorte :
TYPE /* nomType */ IS RECORD

(
/* liste des champs */
);
nomType est le nom du type structuré construit avec la syntaxe précédente. La liste suit la
même syntaxe que la liste des colonnes d’une table dans un CREATE TABLE. Par exemple,
construisons le type point (dans IR2),
TYPE point IS RECORD

(
abscisse NUMBER,
ordonnee NUMBER
);
Notez bien que les types servant à définir un type structuré peuvent être quelconques :
variables scalaires, tableaux, structures, etc.
SGDB ORACLE
 Déclaration d’une variable de type structuré
Point est maintenant un type, il devient donc possible de créer des variables de type point,
la règle est toujours la même pour déclarer des variables en PL/SQL, par exemple
p point;
permet de déclarer une variable p de type point.
Pour accéder à un champ d’une variable de type structuré, en lecture ou en écriture, on

utilise la notation pointée : v.c est le champ appelé c de la variable structuré appelée v. Par
exemple,
DECLARE
TYPE point IS RECORD
(
abscisse NUMBER,
ordonnee NUMBER
);
p point;
BEGIN
p.abscisse := 1;
p.ordonnee := 3;
DBMS_OUTPUT.PUT_LINE('p.abscisse = ' || p.abscisse ||
' and p.ordonnee =' ||p.ordonnee);
END;
/
Le script ci-dessous crée le type point, puis crée une variable t de type point, et enfin affecte
aux champs abscisse et ordonnée du point p les valeurs 1 et 3.
III.8 UTILISATION DU PL/SQL
Ce cours est une introduction aux interactions possibles entre la base de données et les
scripts PL/SQL.
SGDB ORACLE
III.8.1 Affectation
On place dans une variable le résultat d’une requête en utilisant le mot-clé INTO. Les
instructions
SELECT champ_1, ..., champ_n INTO v_1, ..., v_n

FROM ...
affectent aux variables v_1, ..., v_n les valeurs retournées par la requête. Par exemple
DECLARE
num NUMBER;
nom VARCHAR2(30) := 'Poupée Batman' ;
BEGIN
SELECT numprod INTO num
FROM PRODUIT
WHERE nomprod = nom;
DBMS_OUTPUT.PUT_LINE('L''article ' ||
nom || ' a pour numéro ' || num);
END;
/
Prêtez attention au fait que la requête doit retourner une et une seule ligne, sinon, une erreur
se produit à l’exécution.
III.8.2 Tables et structures
Si vous ne tenez pas à vous prendre la tête pour choisir le type de chaque variable,
demandez-vous ce que vous allez mettre dedans ! Si vous tenez à y mettre une valeur qui
se trouve dans une colonne d’une table, il est possible de vous référer directement au type
de cette colonne avec le type nomTable.nomColonne%type. Par exemple,
DECLARE
num PRODUIT.numprod%type;
nom PRODUIT.nomprod%type := 'Poupée Batman' ;
SGDB ORACLE
BEGIN
FROM PRODUIT
END;
/
Pour aller plus loin, il est même possible de déclarer une structure pour représenter une
ligne d’une table, le type porte alors le nom suivant : nomTable%rowtype.
DECLARE
nom PRODUIT.nomprod%type := 'Poupée Batman' ;
ligne PRODUIT%rowtype;
BEGIN
SELECT * INTO ligne
FROM PRODUIT
ligne.nomprod || ' a pour numéro ' || ligne.numprod);
END;
/
III.8.3 Transactions
Un des mécanismes les plus puissants des SGBD récents réside dans le système des
transactions. Une transaction est un ensemble d’opérations “atomiques”, c’est-à-dire
indivisible. Nous considérerons qu’un ensemble d’opérations est indivisible si une
exécution partielle de ces instructions poserait des problèmes d’intégrité dans la base de
données. Par exemple, dans le cas d’une base de données de gestion de comptes en banque,
un virement d’un compte à un autre se fait en deux temps : créditer un compte d’une
somme s, et débiter un autre de la même somme s. Si une erreur survient pendant la
deuxième opération, et que la transaction est interrompue, le virement est incomplet et le
patron va vous assassiner.
SGDB ORACLE
Il convient donc de disposer d’un mécanisme permettant de se protéger de ce genre de

désagrément. Plutôt que se casser la tête à tester les erreurs à chaque étape et à balancer des
instructions permettant de “revenir en arrière”, nous allons utiliser les
instructions COMMIT et ROLLBACK.
Voici le squelette d’un exemple :
/* instructions */
IF /* erreur */ THEN
ROLLBACK;
ELSE
COMMIT;
END;
Le ROLLBACK annule toutes les modifications faites depuis le début de la transaction

(donc depuis le précédent COMMIT), COMMIT les enregistre définitivement dans la base
de données.
La variable d’environnement AUTOCOMMIT, qui peut être positionnée à ON ou

à OFF permet d’activer la gestion des transactions. Si elle est positionnée à ON, chaque
instruction a des répercussions immédiates dans la base, sinon, les modifications ne sont
effectives qu’une fois qu’un COMMIT a été exécuté.
III.9 EXCEPTIONS
Le mécanisme des exceptions est implémenté dans la plupart des langages récent, notament
orientés objet. Cette façon de programmer a quelques avantages immédiats :
 obliger les programmeurs à traiter les erreurs : combien de fois votre prof de C
a hurlé en vous suppliant de vérifier les valeurs retournées par un malloc, ou
un fopen ? La plupart des compilateurs des langages à exceptions (notamment java)
ne compilent que si pour chaque erreur potentielle, vous avez préparé un bloc de
code (éventuellement vide...) pour la traiter. Le but est de vous assurer que vous
n’avez pas oublié d’erreur.
 Rattraper les erreurs en cours d’exécution : Si vous programmez un système de
sécurité de centrale nucléaire ou un pilote automatique pour l’aviation civile, une
erreur de mémoire qui vous afficherait l’écran bleu de windows, ou le message
“Envoyer le rapport d’erreur ?”, ou plus simplement le fameux “Segmentation fault”
produirait un effet des plus mauvais. Certaines erreurs d’éxecution sont rattrapables,
autrement dit, il est possible de résoudre le problème sans interrompre le programme.
 Ecrire le traitement des erreurs à part : Pour des raisons fiabilité, de lisibilité, il
a été considéré que mélanger le code “normal” et le traitement des erreurs était un
SGDB ORACLE
style de programmation perfectible... Dans les langages à exception, les erreurs sont
traitées à part.
III.9.1 Rattraper une exception
Je vous ai menti dans le premier cours, un bloc en PL/SQL à la forme suivante :
DECLARE
/* declarations */
BEGIN
/* instructions */
EXCEPTION
/* traitement des erreurs */
END;
Une exception est une “erreur type”, elle porte un nom, au même titre qu’une variable a une
identificateur, par exemple GLUBARF. Lorsque dans les instructions,
l’erreur GLUBARF se produit, le code du BEGIN s’interrompt et le code de la
section EXCEPTION est lancé. On dit aussi que quand une exception est levée (raised) (on
dit aussi jetée (thrown)), on la rattrape (catch) dans le bloc EXCEPTION. La section
EXCEPTION a la forme suivante :
EXCEPTION
WHEN E1 THEN
/* traitement */
WHEN E2 THEN
/* traitement */
WHEN E3 THEN
/* traitement */
WHEN OTHERS THEN
/* traitement */
END;
On énumère les erreurs les plus pertinentes en utilisant leur nom et en consacrant à chacune
d’elle un traitement particulier pour rattraper (ou propager) l’erreur. Quand un bloc est
traité, les WHEN suivants ne sont pas évalués. OTHERS est l’exception par
SGDB ORACLE
défaut, OTHERS est toujours vérifié, sauf si un cas précédent a été vérifié. Dans l’exemple
suivant :
DECLARE
/* declarations */
BEGIN
/* instructions */
COMMIT;
EXCEPTION
WHEN GLUBARF THEN
ROLLBACK;
DBMS_OUTPUT.PUT_LINE('GLUBARF exception raised!');
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('SQLCODE = ' || SQLCODE);
DBMS_OUTPUT.PUT_LINE('SQLERRM = ' || SQLERRM);
END;
Les deux variables globales SQLCODE et SQLERRM contiennent respectivement le code

d’erreur Oracle et un message d’erreur correspondant à la dernière exception levée. Chaque
exception a donc, en plus d’un nom, un code et un message.
III.9.2 Exceptions prédéfinies
Bon nombre d’exceptions sont prédéfinies par Oracle, par exemple
 NO_DATA_FOUND est levée quand la requête d’une instruction de la

forme SELECT ... INTO ... ne retourne aucune ligne
 TOO_MANY_ROWS est levée quand la requête d’une instruction de la
forme SELECT ... INTO ... retourne plusieurs lignes
 DUP_VAL_ON_INDEX est levée si une insertion (ou une modification) est refusée
à cause d’une contrainte d’unicité.
On peut enrichir notre exemple de la sorte :
DECLARE
num NUMBER;
SGDB ORACLE
nom VARCHAR2(30) := 'Poupée Batman' ;

BEGIN
FROM PRODUIT
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE('Aucun article ne porte le nom '
|| nom);
WHEN TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE('Plusieurs articles portent le
nom '
|| nom);
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Il y a un gros problème...');
END;
/
SELECT numprod INTO num... lève une exception si la requête renvoie un nombre de
lignes différent de 1.
III.9.3 Codes d’erreur
Je vous encore menti, certaines exceptions n’ont pas de nom. Elle ont seulement un code
d’erreur, il est conseillé de se reporter à la documentation pour les obtenir. On les traite de
la façon suivante
EXCEPTION
WHEN OTHERS THEN
IF SQLCODE = CODE1 THEN
/* traitement */
ELSIF SQLCODE = CODE2 THEN
SGDB ORACLE
/* traitement */
ELSE
DBMS_OUTPUT.PUT_LINE('J''vois pas c''que ca
peut etre...');
END;
C’est souvent le cas lors de violation de contraintes.
III.9.4 Déclarer et lancer ses propres exceptions
Exception est un type, on déclare donc les exceptions dans une section DECLARE. Une
exception se lance avec l’instruction RAISE. Par exemple,
DECLARE
GLUBARF EXCEPTION;
BEGIN
RAISE GLUBARF;
EXCEPTION
WHEN GLUBARF THEN
DBMS_OUTPUT.PUT_LINE('glubarf raised.');
END;
/
III.10 SOUS-PROGRAMMES
III.10.1 Procédures
 Syntaxe
On définit une procédure de la sorte
CREATE OR REPLACE PROCEDURE /* nom */ (/* parametres */) IS

/* declaration des variables locales */
BEGIN
SGDB ORACLE
/* instructions */
END;
les paramètres sont une simple liste de couples nom type. Par exemple, la procedure
suivante affiche un compte à rebours.
CREATE OR REPLACE PROCEDURE compteARebours (n

NUMBER) IS
BEGIN
IF n >= 0 THEN
DBMS_OUTPUT.PUT_LINE(n);
compteARebours(n - 1);
END IF;
END;
 Invocation
En PL/SQL, une procédure s’invoque tout simplement avec son nom. Mais sous SQL+, on
doit utiliser le mot-clé CALL. Par exemple, on invoque le compte à rebours sous SQL+ avec
la commande CALL compteARebours(20).
 Passage de paramètres
Oracle permet le passage de paramètres par référence. Il existe trois types de passage de
paramètres :
 IN : passage par valeur

 OUT : aucune valeur passée, sert de valeur de retour
 IN OUT : passage de paramètre par référence
Par défaut, le passage de paramètre se fait de type IN.
CREATE OR REPLACE PROCEDURE incr (val IN OUT NUMBER)

IS
BEGIN
val := val + 1;
SGDB ORACLE
END;
III.10.2 Fonctions
 Syntaxe
On crée une nouvelle fonction de la façon suivante :
CREATE OR REPLACE FUNCTION /* nom */ (/* parametres */)

RETURN /* type
*/ IS
/* declaration des variables locales */
BEGIN
/* instructions */
END;
L’instruction RETURN sert à retourner une valeur. Par exemple,
CREATE OR REPLACE FUNCTION module (a NUMBER, b

NUMBER) RETURN NUMBER IS
BEGIN
IF a < b THEN
RETURN a;
ELSE
RETURN module(a - b, b);
END IF;
END;
 Invocation
Tout comme les procédures, l’invocation des fonctions ne pose aucun problème en PL/SQL,
par contre, sous SQL+, c’est quelque peu particulier. On passe par une pseudo-table
nommée DUAL de la façon suivante :
SGDB ORACLE
SELECT module(21, 12) FROM DUAL;
 Passage de paramètres
Les paramètres sont toujours passés avec le type IN.
III.11 CURSEURS
III.11.1 Introduction
Les instructions de type SELECT ... INTO ... manquent de souplesse, elles ne fontionnent
que sur des requêtes retournant une et une seule valeur. Ne serait-il pas intéressant de
pouvoir placer dans des variables le résultat d’une requête retournant plusieurs lignes ? A
méditer...
III.11.2 Les curseurs
Un curseur est un objet contenant le résultat d’une requête (0, 1 ou plusieurs lignes).
 Déclaration
Un curseur se déclare dans une section DECLARE :
CURSOR /* nomcurseur */ IS /* requête */;
Par exemple, si on tient à récupérer tous les employés de la table EMP, on déclare le curseur
suivant.
CURSOR emp_cur IS
SELECT * FROM EMP;
 Ouverture
Lors de l’ouverture d’un curseur, la requête du curseur est évaluée, et le curseur contient
toutes les données retournées par la requête. On ouvre un curseur dans une section BEGIN :
OPEN /* nomcurseur */;
SGDB ORACLE
Par exemple,
DECLARE
CURSOR emp_cur IS
SELECT * FROM EMP;
BEGIN
OPEN emp_cur;
/* Utilisation du curseur */
END;
 Lecture d’une ligne
Une fois ouvert, le curseur contient toutes les lignes du résultat de la requête On les récupère
une par une en utilisant le mot-clé FETCH :
FETCH /* nom_curseur */ INTO /* liste_variables */;
La liste de variables peut être remplacée par une structure de

type nom_curseur%ROWTYPE. Si la lecture de la ligne échoue, parce qu’il n’y a plus de
ligne à lire, l’attribut %NOTFOUND prend la valeur vrai.
DECLARE
CURSOR emp_cur IS
SELECT * FROM EMP;
ligne emp_cur%rowtype
BEGIN
OPEN emp_cur;
LOOP
FETCH emp_cur INTO ligne;
EXIT WHEN emp_cur%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(ligne.ename);
END LOOP;
/* ... */
SGDB ORACLE
END;
 Fermeture
Après utilisation, il convient de fermer le curseur.
CLOSE /* nomcurseur */;
Complétons notre exemple,
DECLARE
CURSOR emp_cur IS
SELECT * FROM EMP;
ligne emp_cur%rowtype;
BEGIN
OPEN emp_cur;
LOOP
EXIT WHEN emp_cur%NOTFOUND;
END LOOP;
CLOSE emp_cur;
END;
/
Le programme ci-dessus peut aussi s’écrire
DECLARE
CURSOR emp_cur IS
SELECT * FROM EMP;
SGDB ORACLE
BEGIN
OPEN emp_cur;
WHILE emp_cur%FOUND LOOP
END LOOP;
CLOSE emp_cur;
END;
 Boucle FOR
Il existe une boucle FOR se chargeant de l’ouverture, de la lecture des lignes du curseur et
de sa fermeture,
FOR ligne IN emp_cur LOOP

/* Traitement */
END LOOP;
Par exemple,
DECLARE
CURSOR emp_cur IS
SELECT * FROM EMP;
BEGIN
FOR ligne IN emp_cur LOOP
END LOOP;
END;
/
SGDB ORACLE
III.12 CURSEURS PARAMETRES
III.12.1 Introduction
A votre avis, le code suivant est-il valide ?
DECLARE
NUMBER n := 14;
BEGIN
DECLARE
CURSOR C IS
SELECT *
FROM PERSONNE
WHERE numpers >= n;
ROW C%rowType;
BEGIN
FOR ROW IN C LOOP
DBMS_OUTPUT.PUT_LINE(ROW.numpers);
END LOOP;
END;
END;
/
Réponse : non. La requête d’un curseur ne peut pas contenir de variables dont les valeurs
ne sont pas fixées. Pourquoi ? Parce que les valeurs des ces sont susceptibles de changer
entre la déclaration du curseur et son ouverture. Le remède est un curseur paramétré.
III.12.2 Définition
Un curseur paramétré est un curseur dont la requête contient des variables dont les valeurs
ne seront fixées qu’à l’ouverture.
III.12.3 Déclaration
On précise la liste des noms et des type des paramètres entre parenthèses après le nom du
curseur :
SGDB ORACLE
CURSOR /* nom */ ( /* liste des paramètres */ ) IS

/* requête */
Par exemple, créons une requête qui, pour une personne donnée, nous donne la liste des
noms et prénoms de ses enfants :
CURSOR enfants (numparent NUMBER) IS

SELECT *
FROM PERSONNE
WHERE pere = numparent
OR mere = numparent;
III.12.4 Ouverture
On ouvre un curseur paramétré en passant en paramètre les valeurs des variables :
OPEN /* nom */ ( /* liste des paramètres */ )
Par exemple,
OPEN enfants (1);
III.12.5 Lecture d’une ligne, fermeture
La lecture d’une ligne suit les mêmes règles qu’avec un curseur non paramétré.
III.12.6 Boucle Pour
La boucle pour se charge de l’ouverture, il convient donc de placer les paramètres dans
l’entête de la boucle,
FOR /* variable */ IN /* nom */ (/* liste paramètres */) LOOP

/* instructions */
SGDB ORACLE
END LOOP;
Par exemple,
FOR e IN enfants(1) LOOP

DBMS_OUTPUT.PUT_LINE(e.nompers || ' ' || e.prenompers);
END LOOP;
RECAPITULONS
DECLARE
CURSOR parent IS
SELECT *
FROM PERSONNE;
p parent%rowtype;
CURSOR enfants (numparent NUMBER) IS
SELECT *
FROM PERSONNE
WHERE pere = numparent
OR mere = numparent;
e enfants%rowtype;
BEGIN
FOR p IN parent LOOP
DBMS_OUTPUT.PUT_LINE('Les enfants de '|| p.prenom ||
' ' || p.nom || ' sont : ');
FOR e IN enfants(p.numpers) LOOP
DBMS_OUTPUT.PUT_LINE(' * '|| e.prenom
|| ' ' || e.nom );
END LOOP;
END LOOP;
END;
SGDB ORACLE
III.13 Triggers
 Principe
 Classification
 Création
 Accès aux lignes en cours de modification
 Contourner le problème des tables en mutation
III.13.1 Principe
Un trigger est une procédure stockée qui se lance automatiquement lorsqu’un événement se
produit. Par événement, on entend dans ce cours toute modification des données se trouvant
dans les tables. On s’en sert pour contrôler ou appliquer des contraintes qu’il est impossible
de formuler de façon déclarative.
III.13.2 Classification
Type d’événement
Lors de la création d’un trigger, il convient de préciser quel est le type d’événement qui le
déclenche. Nous réaliserons dans ce cours des triggers pour les événements suivants :
 INSERT
 DELETE
 UPDATE
Moment de l’éxecution
On précise aussi si le trigger doit être éxecuté avant (BEFORE) ou après (AFTER)
l’événement.
Evénements non atomiques
Lorsque l’on fait un DELETE ..., il y a une seule instruction, mais plusieurs lignes sont
affectées. Le trigger doit-il être exécuté pour chaque ligne affectée (FOR EACH ROW), ou
seulement une fois pour toute l’instruction (STATEMENT) ?
 un FOR EACH ROW TRIGGER est exécuté à chaque fois qu’une ligne est affectée.
 un STATEMENT TRIGGER est éxecutée à chaque fois qu’une instruction est
lancée.
III.13.3 Création
SGDB ORACLE
Syntaxe
On déclare un trigger avec l’instruction suivante :
CREATE OR REPLACE TRIGGER nomtrigger

[BEFORE | AFTER] [INSERT | DELETE | UPDATE] ON nomtable
[FOR EACH ROW | ]
DECLARE
/* declarations */
BEGIN
/* instructions */
END;
Par exemple,
SQL> CREATE OR REPLACE TRIGGER pasDeDeleteDansClient

2 BEFORE DELETE ON CLIENT
3 BEGIN
4 RAISE_APPLICATION_ERROR(-20555, 'Va te faire ...');
5 END;
6 /
Déclencheur créé.
SQL> SELECT COUNT(*)

2 FROM CLIENT;
COUNT(*)
----------
21
SQL> DELETE FROM CLIENT;

DELETE FROM CLIENT
SGDB ORACLE
*
ERREUR à la ligne 1 :
ORA-20555: Va te faire ...
ORA-06512: à "SCOTT.PASDEDELETEDANSCLIENT", ligne 2
ORA-04088: erreur lors d exécution du déclencheur
'SCOTT.PASDEDELETEDANSCLIENT'
SQL> SELECT COUNT(*)

2 FROM CLIENT;
COUNT(*)
----------
21
L’instruction RAISE_APPLICATION_ERROR(code, message) lève une exception sans

nom portant un code code et un message d’erreur message. Vous remarquez que comme
l’erreur a été levée avant la suppression, les données sont toujours présentes dans la
table CLIENT. Le trigger a contrôlé une règle, et comme elle n’était pas respectée, il a lancé
une erreur.
Combinaisons d’événements
Il est possible, en séparant les types d’événement par le mot-clé OR, de définir un trigger
déclenché par plusieurs événements. Les variables
booléennes INSERTING, UPDATING et DELETING permettent d’identifier l’événement
qui a déclenché le trigger.
CREATE OR REPLACE TRIGGER afficheEvenement

BEFORE INSERT OR UPDATE OR DELETE ON CLIENT
FOR EACH ROW
BEGIN
IF INSERTING THEN
DBMS_OUTPUT.PUT_LINE('Insertion dans CLIENT');
ELSIF UPDATING THEN
SGDB ORACLE
DBMS_OUTPUT.PUT_LINE('Mise a jour dans CLIENT');

ELSE
DBMS_OUTPUT.PUT_LINE('Suppression dans CLIENT');
END IF;
END;
III.13.4 Accès aux lignes en cours de modification
Dans les FOR EACH ROW triggers, il est possible avant la modification de chaque ligne,
de lire l’ancienne ligne et la nouvelle ligne par l’intermédiaire des deux variables
structurées :old et :new. Par exemple le trigger suivant empêche de diminuer un salaire :
CREATE OR REPLACE TRIGGER pasDeBaisseDeSalaire

BEFORE UPDATE ON EMP
FOR EACH ROW
BEGIN
IF (:old.sal > :new.sal) THEN
RAISE_APPLICATION_ERROR(-20567,
'Pas de baisse de salaire !');
END IF;
END;
Tables en mutation
Il est impossible, dans un trigger de type FOR EACH ROW de faire un SELECT sur la table
en cours de modification.
SQL> CREATE OR REPLACE TRIGGER beforeStatement

2 BEFORE UPDATE ON CLIENT
3 DECLARE
4 NB NUMBER;
5 BEGIN
6 SELECT COUNT(*) INTO NB
7 FROM CLIENT;
SGDB ORACLE
8 END;
9 /
SQL>
SQL> CREATE OR REPLACE TRIGGER afterStatement
2 AFTER UPDATE ON CLIENT
3 DECLARE
4 NB NUMBER;
5 BEGIN
7 FROM CLIENT;
8 END;
9 /
SQL>
SQL> UPDATE CLIENT SET nomcli = nomcli;
21 ligne(s) mise(s) à jour.
SQL>
SQL> CREATE OR REPLACE TRIGGER beforeForEachRow
2 BEFORE UPDATE ON CLIENT
3 FOR EACH ROW
4 DECLARE
5 NB NUMBER;
6 BEGIN
8 FROM CLIENT;
SGDB ORACLE
9 END;
10 /
SQL>
UPDATE CLIENT SET nomcli = nomcli
*
ORA-04091: la table SCOTT.CLIENT est en mutation ; le déclencheur
ou la
fonction ne peut la voir
ORA-06512: à "SCOTT.BEFOREFOREACHROW", ligne 4
'SCOTT.BEFOREFOREACHROW'
SQL> DROP TRIGGER beforeForEachRow;
Déclencheur supprimé.
SQL>
SQL>
SQL> CREATE OR REPLACE TRIGGER afterForEachRow
2 AFTER UPDATE ON CLIENT
3 FOR EACH ROW
4 DECLARE
5 NB NUMBER;
6 BEGIN
8 FROM CLIENT;
9 END;
SGDB ORACLE
10 /
SQL>
UPDATE CLIENT SET nomcli = nomcli
*
ORA-04091: la table SCOTT.CLIENT est en mutation ; le déclencheur
ou la
fonction ne peut la voir
ORA-06512: à "SCOTT.AFTERFOREACHROW", ligne 4
'SCOTT.AFTERFOREACHROW'
III.13.5 Contourner le problème des tables en mutation
Il existe plusieurs façons de contourner ce problème :
 Utiliser un STATEMENT trigger. Comme on ne sait pas quelles lignes ont été
modifiées, on est obligé de toutes les traiter. Cette approche présente donc un
inconvénient majeur : elle nous amène à effectuer de nombreux traitements inutiles.
 En ayant des données redondantes. Il suffit que les données servant à la vérification
se trouvent dans une autre table que celle en mutation. Cette méthode a pour
inconvénient la mémoire occupée et la quantité de code à écrire pour maintenir la
cohérence des données. Dans la plupart des cas, cette solution est malgré tout la
meilleure.
Colonnes supplémentaires
Par exemple, si l’on souhaite empêcher un client d’avoir plus de 10 comptes en banque, une
solution est de placer dans la table client une colonne contenant le nombre de comptes.
ALTER TABLE CLIENT ADD nbComptes number;

UPDATE CLIENT SET nbComptes = 0;
SGDB ORACLE
Une fois cette table crée, il convient de s’assurer que les données de la colonne nbComptes
contient toujours les bonnes valeurs. On le fait avec plusieurs sous-programmes :
CREATE OR REPLACE TRIGGER metAJourNbComptes

AFTER INSERT OR UPDATE OR DELETE ON COMPTECLIENT
BEGIN
UPDATE CLIENT SET nbComptes =
(
SELECT COUNT(*)
FROM COMPTECLIENT CC
WHERE CC.numCli = numCli
);
END;
/
CREATE OR REPLACE TRIGGER verifieNbComptes

BEFORE INSERT ON COMPTECLIENT
FOR EACH ROW
DECLARE
nbComptes NUMBER;
BEGIN
SELECT nbComptes INTO nbComptes
FROM CLIENT
WHERE numCli = :new.numcli;
IF (nbComptes >= 10) THEN
'Ce client a deja trop de comptes');
END IF;
END;
/
On peut affiner en remplaçant metAJourNbComptes par plusieurs sous-programmes :
SGDB ORACLE
CREATE OR REPLACE TRIGGER initialiseNbComptes

BEFORE INSERT ON CLIENT
FOR EACH ROW
BEGIN
:new.nbComptes := 0;
END;
/
CREATE OR REPLACE TRIGGER metAJourNbComptes

AFTER INSERT OR UPDATE OR DELETE ON COMPTECLIENT
FOR EACH ROW
BEGIN
IF DELETING OR UPDATING THEN
UPDATE CLIENT SET nbComptes = nbComptes - 1
WHERE numcli = :old.numcli;
END IF;
IF INSERTING OR UPDATING THEN
UPDATE CLIENT SET nbComptes = nbComptes + 1
WHERE numcli = :new.numcli;
END IF;
END;
/
Tables supplémentaires
Si l’on souhaite par exemple empêcher les circuits dans la table PERSONNE, il est
nécessaire de faire un parcours de graphe. Ce qui nécessite des SELECT dans la table en
cours de mutation. La seule solution est dans ce cas d’avoir une table miroir qui contient les
colonnes clés primaire et étrangères de cette table, et de s’en servir pour détecter les circuits.
CREATE TABLE MIRRORPERSONNE

(
numpers NUMBER PRIMARY KEY,
SGDB ORACLE
pere NUMBER,
mere NUMBER
);
Nous allons ensuite procéder de même, en répercutant chaque opération

de PERSONNE sur MIRRORPERSONNE.
CREATE OR REPLACE TRIGGER miseAJourMirrorPersonne

BEFORE UPDATE OR INSERT OR DELETE ON PERSONNE
FOR EACH ROW
BEGIN
IF DELETING OR UPDATING THEN
DELETE FROM MIRRORPERSONNE
WHERE numpers = :old.numpers;
END IF;
IF INSERTING OR UPDATING THEN
INSERT INTO MIRRORPERSONNE VALUES
(:new.numpers, :new.pere, :new.mere);
END IF;
END;
/
Une fois cela fait, il suffit de rechercher si une personne insérée est une descendante d’elle
même dans MIRRORPERSONNE.
CREATE OR REPLACE FUNCTION trouveCircuit(current NUMBER,

toFind NUMBER)
RETURN BOOLEAN IS
numPere NUMBER;
numMere NUMBER;
BEGIN
IF (current IS NULL) THEN
SGDB ORACLE
RETURN FALSE;
END IF;
SELECT pere, mere INTO numPere, numMere
FROM MIRRORPERSONNE
WHERE numPers = current;
RETURN (numPere = toFind OR numMere = toFind OR
trouveCircuit(numPere, toFind) OR
trouveCircuit(numMere, toFind));
END;
/
CREATE OR REPLACE TRIGGER verifieCircuit

AFTER UPDATE OR INSERT ON PERSONNE
FOR EACH ROW
BEGIN
IF (trouveCircuit(:new.numPers, :new.numPers)) THEN
'Circuit dans l''arbre généalogique.');
END IF;
END;
/
III.14 Packages
 Principe
 Spécification
 Corps
III.14.1 Principe
Un package est un ensemble de sous-programmes et de variables formé par
 Une spécification : déclaration de variables et de sous-programmes

 Un corps : implémentation des sous-programmes
Tout ce qui se trouve dans la spécification doit se trouver dans le corps, mais la réciproque
est fausse. Un package satisfait les points suivants :
SGDB ORACLE
 encapsulation : certains traitements sont masqués, seule la spécification du package

est visible. Cela a pour avantage de simplifier la tâche de celui qui va utiliser le
package.
 modularité : il est possible de développer séparément les diverses parties de
l’application. le développement devient ainsi un assemblage de package.
Ces deux aspects fournissent une souplesse certaine au niveau du développement : il est
possible de modifier le corps d’un package sans changer sa spécification, donc sans modifier
le fonctionnement de l’application.
III.14.2 Spécification
La syntaxe permettant de créer l’entête est la suivante :
CREATE OR REPLACE PACKAGE nompackage IS

/*
declarations
*/
END nomPackage;
/
Par exemple,
CREATE OR REPLACE PACKAGE compteur IS

procedure reset;
function nextValue return number;
END compteur;
/
III.14.3 Corps
La syntaxe permettant de créer le corps est la suivante :
CREATE OR REPLACE PACKAGE BODY nompackage IS

/*
SGDB ORACLE
implementation
*/
END nomPackage;
/
Par exemple,
CREATE OR REPLACE PACKAGE BODY compteur IS

cpt NUMBER := 0;
PROCEDURE reset IS
BEGIN
cpt := 0;
END;
FUNCTION nextValue RETURN NUMBER IS

BEGIN
cpt := cpt + 1;
RETURN cpt - 1;
END;
END compteur;
/
On peut utiliser un package depuis n’importe quel script PL/SQL :
DECLARE
nb NUMBER;
BEGIN
FOR nb IN 4..20 LOOP
DBMS_OUTPUT.PUT_LINE(COMPTEUR.nextValue());
END LOOP;
SGDB ORACLE
COMPTEUR.RESET();
FOR nb IN REVERSE 0..10 LOOP
DBMS_OUTPUT.PUT_LINE(COMPTEUR.nextValue());
END LOOP;
END;
/
 SEANCE DE TRAVAUX PRATIQUES

Cette séance va permettre de concevoir et création d’une base de données pour la
gestion d’une école. Ces éléments ci-dessous seront prioritaires dans la séance :
 Création de la base de données
 Insertion et manipulation des objets dans la base
 Création de procédures diverses
 Création de triggers pour la protection de données dans la base.
 BIBLIOGRAPHIE
 Oracle Database concepts 11g Release 2 (11.2) E40540, May 2015
 Administration des bases de données sous Oracle, Fabien De Marchi,
Université de Lyon
 https://slideplayer.fr/slide/500424/
 http://cours.singaomara.com/BDOracle.html
 https://www.supinfo.com/articles/

SGBD Oracle

Transféré par

Informations du document

Description :

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

SGBD Oracle

Titre original :

Transféré par

Description :

Droits d'auteur :

05/11/2020 SGDB ORACLE

ATTA BOSSON VALERE

INTRODUCTION GENERALE SUR LA

Pour mieux appréhender une base de données et la maîtriser, il est prépondérant

I.2 PRESENTATION D’UNE BASE DE DONNEES

Avant de faire une présentation de la base de données Oracle, il me semble judicieux

I.3 SYSTEME DE GESTION DE BASE DE DONNEES

Un système de gestion de base de données est un système logiciel ou ensemble de

I.4 PRESENTATION D’ORACLE DATABASE

Oracle Database est l’un des systèmes de gestion de base de données

I.5 ARCHITECTURE GLOBALE D’UN SERVEUR ORACLE

aussi plusieurs fichiers systèmes de base de données pendant son fonctionnement.

Le Listener c’est le processus serveur de la base de données, il reçoit les requêtes

I.6 STRUCTURE D’UNE INSTANCE DE BASE DE DONNEES ORACLE

I.6.1 System Global Area

I.6.2 Program Global Area (PGA)

I.6.3 Les processus d’arrière-plan / Background Processes

Archiver (ARCn) : Ce sont des processus chargés de l’archivage des fichiers de

I.6.4 Structure de la base de données

Conclusion relative à la base de données Oracle

SQL : STRUCTURE QUERY LANGUAGE

 SQL est un langage pour les BDR.Crééen1970 par IBM.

 Langage de définition de données LDD: permet la description de la structure de la

II.2 LANGAGE DE DEFINITION DE DONNEES : LDD

II.2.1 Syntaxe de Création des tables

Exemple : Créer la table Produit ayant comme schéma :

II.2.2 Définition des contraintes

CONSTRAINT nom_contrainte FOREIGNKEY (nom_att)references

REFERENCES nom Table

La commande pour la création de la table Magasin étant:

Solution 2: clé étrangère comme contrainte de colonne

II.2.3 Contrainte de valeur avec la clause check

Constraint nom_contrainte CHECK (colonne condition)

CREATE TABLE Produit

II.2.4 Modification de la structure d’une table

1ère forme : Ajout de nouvelles colonnes à une table

Supposons qu'on veut ajouter une colonne type_clt à la table client :

2ème forme : Modification de la structure d'une colonne existante

Pour modifier le nom d'une colonne :

ALTER TABLE nom_table

4èmeforme : Ajout d'une contrainte

5ème forme : Suppression de contraintes existantes

Select * from user_constraints

DROP TABLE nom_table ;

II.3 LANGAGE DE MANIPULATION DE DONNEES : LMD

II.3.1 Les commandes du LMD

 INSERT: ajoute des lignes à une table.

Donner la commande permettant de remplir la première ligne de la table produit.

II.3.2 Modification de données

Modifier les quantités de tous les produits aveclavaleur10.

II.3.3 Suppression de données

II.3.4 Consultation de données

II.3.4.1 Notion d’alias

II.3.4.2 Spécification d’un critère dans une requête

II.3.5 Les fonctions intégrées de SQL

II.3.6 Les expressions agrégats (ou fonctions de groupe)

Les requêtes imbriquées

 Requêtes imbriquées simples : la requête interne est indépendante–de la requête

II.3.7 Les requêtes imbriquées simples

II.3.8 Les opérateurs ensemblistes

Exercices et manipulations avec des cas pratiques.

Le PL de PL/SQL signifie Procedural Language. Il s’agit d’une extension procédurale du

FOR /* variable / IN / inf /../ sup */ LOOP

TYPE /* type / IS VARRAY (/ taille /) OF / typeElements */;

CREATE OR REPLACE PROCEDURE /* nom / (/ parametres */) IS

CREATE OR REPLACE FUNCTION /* nom / (/ parametres */)

CURSOR /* nomcurseur / IS / requête */;

FETCH /* nom_curseur / INTO / liste_variables */;