Cours BD Version2022
Cours BD Version2022
Cours BD Version2022
Universitaire 2022-2023
Auditoire :
LMD-L2
Enseignants :
Mme Sameh Chaâbane Ellouze
Mme Sonia Loulou Hadj Kacem
Maîtres Technologues - ISET de Sfax
ISET Sfax
Table des matieres
Chapitre 1: Introduction Aux Bases De Données ..................................... 2
1. Définition de Base de Données ........................................................................... 2
2. Exemple de Base de Données .............................................................................. 2
3. Objectifs de Base de Données ............................................................................. 2
4. Caractéristiques des Bases de Données ............................................................... 3
5. Besoins en Bases de Données .............................................................................. 3
6. Définition de Système de Gestion de Base de Données ....................................... 4
7. Cycle de vie d’une Base de Données .................................................................... 4
Chapitre 2 : Modélisation des données
Du modèle Entité-Association au modèle relationnel .......................... 6
1. Le modèle Entité/Association.............................................................................. 6
1.1 Introduction ............................................................................................... 6
1.2 Les concepts de base ................................................................................. 7
2. Le modèle relationnel ....................................................................................... 12
2.1 Introduction ............................................................................................. 12
2.2 Concepts de base du modèle relationnel ............................................... 13
2.3 Contraintes d'intégrité ............................................................................ 14
3. Les règles de passage du modèle E/A au modèle relationnel ............................. 15
CHAPITRE 3 : Introduction au langage SQL ............................................. 17
1. Introduction ...................................................................................................... 17
2. Emplacement de SQL dans la structuration en couche du SGBD Oracle ............. 18
3. Les objets du langage SQL ................................................................................. 19
3.1 Les tables ................................................................................................ 19
3.2 Les vues .................................................................................................. 19
3.3 Les utilisateurs...................................................................................... 20
3.4 Les accélérateurs .................................................................................. 20
4. Le langage de contrôle de données (LCD) .......................................................... 20
4.1 Création d'utilisateurs......................................................................... 21
4.2 Attribution des droits .......................................................................... 21
4.3 Suppression des droits ........................................................................ 22
4.4 Commit et Rollback .............................................................................. 22
CHAPITRE 4 : LE LANGAGE DE DÉFINITION DE DONNÉES (LDD)...... 25
1. Introduction ...................................................................................................... 25
2. Création de tables ............................................................................................. 25
2.1 Formes de création de tables ............................................................. 25
2.2 Les contraintes d’intégrité ................................................................. 27
3. Modification de la structure d’une table ........................................................... 32
4. Suppression de tables ....................................................................................... 34
5. Changement du nom d’une table ...................................................................... 35
6. Création de synonymes pour une table ............................................................. 35
CHAPITRE 5 : LANGAGE DE MANIPULATION DE DONNÉES (LMD) ... 38
1. Introduction ...................................................................................................... 38
2. Insertion de données ........................................................................................ 38
3. Modification de données .................................................................................. 39
4. Suppression de données ................................................................................... 40
5. Consultation des données ................................................................................. 40
5.1 Recherche simple dans une table...................................................... 40
5.2 Recherche avec qualification ............................................................. 41
5.3 Requêtes imbriquées ........................................................................... 49
5.4 Tri des résultats .................................................................................... 50
5.5 Groupement des données ................................................................... 51
5.6 Les opérateurs ensemblistes ............................................................. 52
5.7 Jointure et produit cartésien ............................................................. 54
6. Manipulation des Données à travers les vues .................................................... 58
6.1 Définition et intérêts d'une vue......................................................... 58
6.2 Création de vues ................................................................................... 58
6.3 Consultation des données d'une vue ................................................ 59
6.4 Insertion dans une vue ........................................................................ 59
6.5 Modification des données d'une vue ................................................ 60
6.6 Suppression de vues ............................................................................ 60
Bibliographie ........................................................................................................... 61
Cours Bases de données
Objectifs
L’objectif du chapitre est de découvrir les concepts de base et d’énumérer les
besoins et l’intérêt de l’utilisation des Bases de Données.
Éléments de contenu
Concept de base de données
Définition
Objectifs
Besoins en bases de données
Définition de Système de Gestion de bases de données
Chapitre 1
Introduction Aux Bases De
Données
1. Définition de Base de Données
Une Base de Données(BD) est un ensemble de données structurées modélisant un univers
précis. Ces données sont enregistrées sur des supports accessibles par l'ordinateur pour
satisfaire simultanément plusieurs utilisateurs de façon sélective et en un temps opportun. En
faite, toute information est enrichie par les liens sémantiques qu’elle a avec les autres. Ces
liens permettent un accès plus facilement à une information à partir d'une autre.
Objectifs
Initier l’apprenant, dans un premier volet, à modéliser les données d’un
système d’information en se basant sur les concepts de base du modèle
Entité/Association et à découvrir les concepts de bases du modèle relationnel.
Dans un deuxième volet, l’apprenant doit pouvoir appliquer les règles de
passage du modèle E/A à un schéma relationnel.
Éléments de contenu
Le Modèle Entité/Association
Introduction
Les concepts de base
Le Modèle relationnel
Introduction
Concepts de base
Contraintes d’intégrité
Les règles de passage du modèle E/A au modèle relationnel
Chapitre 2
Modélisation des données :
Du modèle Entité-Association
au modèle relationnel
1. Le modèle Entité/Association
1.1 Introduction
Il est difficile de modéliser un domaine sous une forme directement utilisable par un SGBD.
Une ou plusieurs modélisations intermédiaires sont donc utiles.
On appelle modèle : une représentation d'un système réel, qu'elle soit mentale ou physique,
exprimée sous forme verbale, graphique ou mathématique.
Le modèle Entité-Association (E/A), appelé aussi Objet-Association ou Objet-Relation,
constitue l’une des premières et des plus courantes modélisations. Ce modèle, présenté par
Chen (1976), permet une description naturelle du monde réel à partir des concepts d’entité et
d’association.
Par analogie à la programmation et l'algorithmique, dont le principe peut être représenté
comme suit :
Enoncé Programmation
Programme codifié
Analyse et
résolution Codification
Algorithme
Dans les bases de données le modèle E/A est comme un algorithme, il intervient dans le
cycle suivant :
Système Hiérarchique
d'information Réel perçu Conception Relationnel
Modèle de données
de l'entreprise Réseau
Modélisation Traduction
Représentation graphique
des données
Diagramme
E/A
« Entité » ou « Objet » :
Exemples L’étudiant Mohamed Salah
Le cours Base de données
La commande N°123
Le client Ali Tounsi
« Association » ou « Relation » entre objets :
Exemples L’étudiant Mohamed salah suit le cours Base de données
La commande N°123 est passée par le client Ali Tounsi
« Propriété » ou « Attribut » observé sur une entité ou sur une association
Exemples L’âge de l’étudiant Mohamed salah est 19 ans
La ville du client Ali tounsi est Sfax
Les exemples déjà cités représentent des occurrences. Les occurrences qui ont en
commun certaines caractéristiques appartiennent à un même type. Un type est une classe
d’occurrences similaires. On distingue :
Le type entité intitulé « entité-type » : c’est une classe d’individus ayant en commun un
même ensemble de propriétés-types.
Représentation graphique
NomEntitéType
NomPropriétéType
NomAssociationType
Exemples
Etudier Diriger
Employé Diriger
L’association-type Diriger est dite réflexive, elle matérialise une relation Employé et elle-
même.
Remarque par abus de langage, on parle d’entité pour désigner une entité-type, d’association
pour désigner une association-type et de propriété pour désigner une propriété-type.
Identifiant d’une entité-type : c’est une propriété-type ou groupe de propriété-types
dont la valeur (valeurs combinées) est Unique pour chaque entité.
Remarques
L’identifiant d’une entité-type doit être placé en tête et souligné dans le diagramme
E/A.
L’identifiant d’une association-type est la concaténation des identifiants des entités-
types qu’elle relie.
Cardinalité d’une association : c’est le nombre maximal de participations d’une
instance (occurrence) de l’entité dans l’association.
Les différents types de cardinalités peuvent êtres résumés par la figure suivante :
A B A B A B
Exemples
Association de type 1-N : Liens hiérarchiques
1 N
Client Passer Commande
N M
Produit Commander Commande
1 1
Commande Facturer Facture
Le lien 1:1, exprime qu'à une occurrence de Commande correspond au plus une occurrence
de Facture et inversement.
Exercice 1
Une entreprise désire automatiser sa gestion commerciale. Pour cela, elle nous invite à
construire le diagramme E/A relatif sachant les règles de gestion suivantes :
- Un client est identifié par un code et caractérisé par un nom, une ville et un numéro
de téléphone.
- Un fournisseur est identifié par un code et caractérisé par un nom, une ville et un
numéro de téléphone.
- Un produit est identifié par un code et caractérisé par un libellé, une quantité en stock
et un prix unitaire.
- Une commande est référencée par un numéro de commande et caractérisée par sa date
de passation.
- Une facture est identifiée par un numéro de facture et caractérisée par sa date de
facturation et son montant.
- Une commande ne peut être facturée qu’une seule fois.
- Une facture ne correspond qu’à une seule commande.
- Un client peut passer plusieurs commandes.
- Une commande peut faire référence à plusieurs produits et un même produit peut être
commandé plusieurs fois avec des quantités différentes.
- Le même produit peut être fournit par plusieurs fournisseurs avec des prix d’achat
différents.
Proposer un modèle E/A traduisant les relations qui existent entre les entités.
Exercice 2
La société est organisée en services. Chaque service a un nom (NomSce) et un numéro
unique (NumSce) et il est dirigé par un employé unique. La date (DateDebDir) à partir de
laquelle l’employé a commencé à diriger le service est comptabilisée.
Un service contrôle un certain nombre de projets, chacun d’entre eux ayant un nom
(NomProj) et un numéro (NumProj)
Chaque employé est caractérisé par son nom (NomEmp), son numéro de sécurité sociale
(NumSSEmp), son adresse (AdrEmp) et sa date de naissance (DateNais). Il est affecté à un
service et peut travailler sur plusieurs projets qui ne sont pas forcément contrôlés par le
même service. Le nombre d’heures hebdomadaires (NbHeurHebd) travaillées par chaque
employé par projet est comptabilisé. Le supérieur hiérarchique immédiat de chaque employé
doit être aussi.
Elaborer le modèle E/A correspondant.
Corrigé exercice 1
Client Fournisseur
CodCl M CodFrs
1
NomCl NomFrs
VilleCl VilleFrs
TelCl TelFrs
Passer Fournir
PrixAchat
N N
1 CodPr
NumCde QteCdee
LibPr
DateCde
QteStock
Facturer
PuPr
1
Facture
NumFact
DateFact
MtFact
Corrigé exercice 2
1 NumSce M NumProj
N
NomSce NomProj
Diriger Travailler
DateDebDir NbrHeurHeb
M
Est_Affecté N
Employé N
1
N NumEmp
NomEmp
Est_Dirigé
AdrEmp
DateNais
2. Le modèle relationnel
2.1 Introduction
Un modèle de données est un ensemble de concepts permettant de décrire la structure d'une
BD, de façon simple et fiable. La plupart des modèles incluent des opérations permettant de
mettre à jour et interroger la base. Il existe plusieurs modèles comme le modèle hiérarchique,
le modèle en réseau et le modèle Objet. Le modèle de données le plus utilisé est le modèle
relationnel.
Ce modèle est apparu en 1970 avec les propositions d’Edgar CODD pour un système de
bases de données, dont le modèle de données serait constitué de relations. Il consiste à
percevoir l'ensemble de données comme des Tables (tableaux à deux dimensions) où
chacune représente une relation, au sens mathématique d'ensemble. L'ensemble des valeurs
des relations représente le contenu de la base de données. Ce contenu peut être modifié en
ajoutant et en supprimant des lignes ou en modifiant leur contenu.
Tuple P1 D1 Q1 C1 P1
(Enregistrement)
P2 D2 Q2 C2 P2
Avec :
NumProd
DesProd
QteStk les attributs de la relation Produit.
QteSeuil
PrixProd
Degré d'une relation : C'est le nombre de colonnes dans une relation (ex. Degré
de Produit= 5).
Cardinalité d'une relation : C'est le nombre de lignes dans une relation (ex.
Cardinalité de Produit= 2)
Schéma d’une relation : Nom de la relation suivi entre parenthèses de la liste des
attributs qui la composent.
Exemple Produit (NumProd, DesProd, QteStk ,QteSeuil , PrixProd)
Schéma d’une BD relationnelle : Une collection des différents schémas des
relations qui composent la base de données.
Clé primaire : Un attribut (ou plusieurs) permettant d'identifier d'une façon
unique un tuple d'une relation.
CI inter-relations (entre les relations de la base) : on les trouve généralement pour les
clés étrangères.
Objectifs
Introduire le langage de requêtes structuré SQL, son historique et ses objets.
La découverte et l’application des commandes de contrôle de données, l’ajout
et la suppression d’utilisateurs de la base de données ainsi que l’attribution
de droits, fera l’objet de la deuxième partie de ce chapitre.
Éléments de contenu
Introduction
Emplacement de SQL dans la structuration en couche du SGBD Oracle
Les objets du langage SQL
Les tables
Les vues
Les utilisateurs
Les accélérateurs
Le langage de contrôle de données (LCD)
Création d'utilisateurs
Attribution des droits
Suppression des droits
Commit et Rollback
CHAPITRE 3
Introduction au langage SQL
1. Introduction
Lors de l'apparition des bases de données relationnelles, IBM et l'université de Berkley ont
intensifié leurs travaux pour expérimenter cette théorie. Le résultat était des prototypes
respectifs de System-r et Ingres. Dans les années 70 et 76 il y a eu apparition des langages
QUEL et SEQUEL implantés respectivement sur Ingres et System-R. SEQUEL a connu des
améliorations pour devenir en 1980 SQL (Structured Query Language) et a été
commercialisé par ORACLE Corporation. SQL a été utilisé en 1981 et 1983 par les SGBD
d'IBM, SQL/DS et DB2.
En 1986, une norme a été adoptée par l'ANSI et englobait la version IBM de SQL, puis a été
adoptée par d'autres organismes de normalisation tels que ISO et X/Open en 1987.
La simplicité du langage SQL, sa richesse en fonctionnalités et sa normalisation sont les
principales raisons de son succès.
SQL (Structured Query Language, traduisez Langage de requêtes structuré) est un langage
de définition de données (LDD, ou en anglais DDL Data Definition Language), un langage
de manipulation de données (LMD, ou en anglais DML, Data Manipulation Language), et
un langage de contrôle de données (LCD, ou en anglais DCL, Data Control Language), pour
les bases de données relationnelles.
Le langage SQL n'est pas sensible à la casse (en anglais case sensitive), cela signifie que l'on
peut aussi bien écrire les instructions en minuscules qu'en majuscule. Toutefois, cette
insensibilité à la casse n'est que partielle dans la mesure où la différenciation entre
minuscules et majuscules existe au niveau des données.
Couche PL/SQL
Couche SQL
Noyau
Dictionnaire de données
Le Dictionnaire de Données (DD): c’est une méta-base qui décrit d’une façon dynamique la
base de données, il permet ainsi de décrire :
Les objets de la base (table, index, cluster,…)
Les utilisateurs ainsi que leurs privilèges et leurs droits d’accès
Les informations relatives à l’activité de la base (connexion aux ressources utilisées,
verrouillage, etc.)
Le DD est un ensemble de vues sur les objets et les éléments de la BD accessibles par les
différents utilisateurs en fonction de leurs droits.
Les tables du DD doivent être les premiers objets créés pour chaque BD, car elles servent à
ranger toutes les informations sur les autres objets qui seront créés par les futurs utilisateurs.
Le DD est créé automatiquement à la création de la BD. Ensuite, quand la BD fonctionne, le
SGBD Oracle tient à jour les tables du DD en fonction des transactions réalisées sur la BD.
La couche SQL (Structured Query Language): elle constitue une interface entre le noyau et
les différents outils d’oracle. Ainsi tout accès à la base est exprimé en langage SQL. Le rôle
de cette couche est d’interpréter les commandes SQL, de faire une vérification syntaxique et
sémantique.
Exemple : Client
1 TRIKI 11, rue jasmins 3000 Sfax 213456
2 SALEM 7, av. farhat 1000 Tunis 754896
3.2 Les vues
Ce sont des tables virtuelles (n’ont pas d’existence physique). La définition d'une vue est
stockée dans le dictionnaire sous forme de requêtes, donc les données sont extraites au
moment de l'exécution de la vue.
Exemple
La vue Clt_Tunis, dérivant de la table Client, ayant ou non la même structure que cette
dernière et ne contenant que les clients de ville de Tunis.
Col 1 Col 2
1 X
5 Y
2 Z
3 X
2 F
4 H
L’index : Col1 sera représenté dans cette table de correspondance
Rang col 1
1 1
3 2
5 2
4 3
6 4
2 5
Les clusters : Ce sont des regroupements physiques de données. Il s'agit de mettre
dans une même page mémoire les données souvent accédées ensembles.
Utilisateuri : est le nom d’un utilisateur (Public pour désigner tous les utilisateurs).
L'option With Grant Option : autorise le nouvel utilisateur à accorder les droits reçus
à un autre utilisateur.
Exemple
L'utilisateur UT4 attribue à l'utilisateur UT5 le droit de sélection et de mise à jour à sa table
Commande
Grant Select, Update
On Commande
To UT5 ;
L'utilisateur UT5 peut créer une table Cde à partir du droit « Select » reçu de UT4 :
Create Table Cde
AS Select * From UT4.Commande ;
4.3 Suppression des droits
La commande qui permet de supprimer un ou plusieurs droits sur un objet est :
Revoke droit1, droit2, ...., droit n
On objet
From Nom_Utilisateur1, Nom_Utilisateur2, ..., Nom_Utilisateurp
Exemple
Revoke All
On Commande
From Public ;
4.4 Commit et Rollback
Syntaxe
Commit [WORK] ;
Cette instruction est utilisée pour faire une validation explicite des modifications effectuées
depuis le dernier COMMIT implicite ou explicite effectué, permettant ainsi de marquer la fin
d’une transaction.
Remarque
La fin normale d'une transaction ou d'une session génère un COMMIT implicite.
Syntaxe
RollBack [WORK]
Cette instruction permet d’annuler une transaction spécifiée par l’utilisateur depuis le début
de la transaction.
Objectifs
Maîtriser les différentes commandes de définition de données. L’apprenant
doit pouvoir créer sa base de données à partir d’un modèle relationnel tout
en prenant en considérations les contraintes d’intégrité nécessaires.
Éléments de contenu
Introduction
Création de tables
Formes de création de tables
Les contraintes d’intégrité
Modification de la structure d’une table
Suppression de tables
Changement du nom d’une table
Création de synonymes pour une table
CHAPITRE 4
LE LANGAGE DE DÉFINITION DE
DONNÉES (LDD)
1. Introduction
Le LDD permet de définir des bases de données et des objets qui les composent : schémas,
tables, synonymes, clusters, vues, ….
La définition d’un objet inclut généralement sa création, sa modification et sa suppression.
Les commandes du langage de définition des données de SQL sont :
Create : création d’objets,
Alter : modification de structures d’objets,
Drop : suppression d’objets.
2. Création de tables
La création d’une table consiste à définir son nom, les colonnes qui la composent, leurs types
et éventuellement les contraintes d’intégrités nécessaires. Elle se fait à l’aide de la
commande Create table.
Le nom de la table doit être unique dans le schéma et ne doit pas être un mot clé SQL.
Oracle dispose de deux formes pour cette commande :
L'option Not Null, placée immédiatement après le type de donnée permet de préciser au
système que la saisie de ce champ est obligatoire. Elle est utilisée implicitement pour les
colonnes clés dans une table.
Pour chaque colonne que l'on crée, il faut préciser le type de données que le champ va
contenir. Exemples de types de données possibles :
2ème forme Création + Insertion : Il est possible de créer une table avec insertion directe de
lignes. Les lignes à insérer sont alors récupérées d'une ou de plusieurs tables et/ou vues
existantes. La syntaxe de cette 2ème forme est la suivante:
Create Table Nom_de_la_table [(Nom_de_colonne1, Nom_de_colonne2, ...,
Nom_de_colonneN )]
As Requête ;
Si la définition des colonnes est omise, Oracle hérite les noms de colonnes de la requête. Il
est possible de définir une table à partir de plusieurs tables sources.
La requête est une opération de sélection qui indique les colonnes sources, les tables
auxquelles elles appartiennent et éventuellement des critères de sélection.
Syntaxe 1
Définition de contraint Unique comme contrainte de table :
Constraint Nom_de_la_contrainte Unique(NomColonne)
Syntaxe 2
Définition de contrainte Unique comme contrainte de colonne : en ajoutant Unique
devant le nom de la colonne.
NomColonneType Unique
Syntaxe 1
Définition de clé primaire comme contrainte de table :
Constraint Nom_de_la_contrainte Primary Key(NomColonne1, NomColonne2, ...)
Syntaxe 2
Définition de la clé primaire comme contrainte de colonne : en ajoutant devant la
colonne clé primaire
NomColonne Type Primary Key,
Remarque
Dans le cas de clé primaire multiple, la clé primaire doit être créée obligatoirement comme
contrainte de table (Syntaxe 1).
Exemple
Améliorons l’exemple de création de la table Produit en ajoutant les contraintes suivantes :
NumProd est la clé primaire de la table.
deux produits différents ne peuvent pas avoir la même désignation.
CREATE TABLE Produit CREATE TABLE Produit
( (
NumProd Number(6) primary key,
NumProd Number(6),
DesProd Varchar2(15) unique,
Couleur Char(1), DesProd Varchar2(15) ,
Poids Number(8,3), Couleur Char(1),
QteStk Number(7,3),
Poids Number(8,3),
QteSeuil Number(7,3),
Prix Number(10,3) QteStk Number(7,3),
); QteSeuil Number(7,3),
Prix Number(10,3),
Constraint UQ_DesProd Unique(DesProd),
Constraint pk_prd Primary Key (NumProd)
);
Syntaxe 1
Définition de clé étrangère comme contrainte de table :
Constraint Nom_de_la_contrainte Foreign Key(NomColonne1, NomColonne2, ...)
References nom_table_étrangère (clé_primaire_table_étrangère)
Syntaxe 2
La clé étrangère est définie comme contrainte de colonne en ajoutant devant la colonne
clé étrangère :
References nom_table_étrangère (clé_primaire_table_étrangère)
Remarque
Il est impossible de créer une clé étrangère si la clé primaire associée n'existe pas.
Exemple
Considérons le schéma suivant :
Magasin (NumMag, Adresse, Surface)
Produit (NumProd, DesProd, Couleur, Poids, QteStk, QteSeuil, Prix,
#CodMag)
La commande de création de la table Magasin étant :
Create Table Magasin
(
NumMag Number(6) primary key,
Adresse Varchar2(30),
Surface Number(7,3)
);
La commande de 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 ,
DesProd Archar2(15),
Couleur Char(1),
Poids Number(8,3),
QteStk Number(7,3),
QteSeuil Number(7,3),
Prix Number(10,3),
CodMag Number(6),
Constraint Fk_Prd Foreign key (CodMag) references Magasin(NumMag)
);
Solution 2 : Clé étrangère comme contrainte de colonne
Create Table Produit
(
NumProd Number(6) Primary key ,
DesProd Varchar2(15),
Couleur Char,
Poids Number(8,3),
QteStk Number(7,3),
QteSeuil Number(7,3),
Prix Number(10,3),
CodMag Number(6) References Magasin (NumMag)
);
Syntaxe 1
Définition de contrainte Check comme contrainte de table :
Constraint Nom_de_la_contrainte Check (NomColonne Condition)
Syntaxe 2
Définition de contrainte Check comme contrainte de colonne en ajoutant devant la
définition de la colonne :
Check (NomColonne 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
Améliorons l’exemple de création de la table Produit en ajoutant les contraintes suivantes :
- le poids d'un produit doit être positif.
- pour un produit, la quantité en stock doit être supérieure ou égale à la quantité
seuil.
- la quantité d'un produit doit être comprise entre 0 et 1000.
- la couleur d'un produit ne peut être que 'R', 'N', 'G' ou 'B'
Create Table Produit
(
NumProd Number(6) Primary key ,
DesProd Varchar2(15),
Couleur Char(1),
Poids Number(8,3) Check (Poids > 0),
QteStk Number(7,3),
QteSeuil Number(7,3),
Prix Number(10,3),
CodMag Number(6) References Magasin(NumMag),
Constraint CK2_Produit Check (QteStk >= QteSeuil ),
Constraint CK3_Produit Check (QteStk Between 0 And 1000),
Constraint CK4_Produit Check (Couleur IN ('R', 'N','G','B'))
);
Remarque
Le mot clé Constraint est utilisé pour attribuer un nom à la contrainte. Si la clause Constraint
n'est pas spécifiée, un nom sera donné arbitrairement par le SGBD. Toutefois, le nom donné
par le SGBD risque fortement de ne pas être compréhensible, et ne sera vraisemblablement
pas compris lorsqu'il y aura une erreur d'intégrité. La stipulation de cette clause est donc
fortement conseillée.
Ajouter les contraintes de vérification pour que le champ QteSeuil soit > 0 et le
champ DesProd soit unique.
Alter Table Produit
ADD (Constraint CK5_Produit Check (QteSeuil > 0),
Constraint UC_Produit Unique (DesProd));
2ème variante Modification de la définition de colonnes existantes.
Les modifications possibles sont : accroître la taille, réduire la taille (seulement si la colonne
ne contient que des valeurs nulles), modifier le type (seulement si la colonne ne contient que
des valeurs nulles) et supprimer l’interdiction de présence de valeurs nulles.
Alter Table Nom_de_la_table
MODIFY (Nom_de_colonne1 Type [(taille)] [NULL | NOT NULL\...],
...
Nom_de_colonneN Type [(taille)] [NULL | NOT NULL\...]);
Exemple1
Modifier le champ Gérant de la table Magasin de manière qu'il devienne caractère
variable de taille 10.
Alter Table Magasin
MODIFY (Gérant varchar2(10));
Exemple2
Modifier la table Produit de manière à ce que la valeur par défaut de QteSeuil soit égale à
10.
Alter Table Produit
MODIFY (QteSeuil Default 10);
3ème variante Suppression de colonnes ou de contraintes existantes.
La suppression de colonnes existantes est possible en utilisant la commande :
ALTER TABLE Nom_de_la_table
DROP (NomColonne1, …, NomColonneN) [Cascade Constraint] ;
Remarque
L'option Cascade Constraint est ajoutée pour pouvoir supprimer toutes contraintes
définie sur des colonnes non supprimées et faisant référence à l’une des colonnes
supprimées.
Exemple
Supprimer les colonnes Gérant et Ville de Magasin
Alter Table Magasin
DROP (Gérant, Ville);
Remarque
Pour retrouver les noms des différentes contraintes avec leurs types, on peut utiliser la
commande suivante :
Select Constraint_Name, Constraint_Type
From User_Constraints
[Where Table_name = 'NOMTABLE'];
Et pour une liste complète d’informations sur les contraintes, on peut taper :
Select*
From User_Constraints
[Where Table_name = 'NOMTABLE'];
Il est à noter pour cette commande, le nom de la table doit être écrit en majuscule.
Exemple 1 Supprimer la contrainte clé étrangère de la table Produit.
Alter Table Produit
DROP Constraint FK_Prd;
Exemple 2 Modifier la table Produit de manière que la couleur soit quelconque.
Alter Table Produit
DROP Constraint CK4_Produit;
4. Suppression de tables
Certaines tables peuvent devenir inutiles dans certains cas et doivent être supprimées.
La suppression se fait par la commande :
Objectifs
Éléments de contenu
Introduction
Insertion de données
Modification de données
Suppression de données
Consultation des données
Recherche simple dans une table
Recherche avec qualification
Requêtes imbriquées
Tri des résultats
Groupement des données
Les opérateurs ensemblistes
L'union
L'intersection
La différence
Jointure et produit cartésien
Le produit cartésien
La jointure
Manipulation des Données à travers les vues
Définition et intérêts d'une vue
Création de vues
Consultation des données d'une vue
Insertion dans une vue
Modification des données d'une vue
Suppression de vues
CHAPITRE 5
LANGAGE DE MANIPULATION
DE DONNÉES (LMD)
1. Introduction
Le LMD est un ensemble de commandes permettant la consultation (Select) et la mise à jour
des données créées par le LDD. La mise à jour englobe l’insertion (Insert) de nouvelles
données, la modification (Update) et la suppression (Delete) de données existantes.
Les requêtes du LMD peuvent être formulées directement en utilisant l’interface SQL*Plus,
ou utilisées dans l’un des outils Oracle tels que SQL*Forms, SQL*ReportWriter. Elles
peuvent être aussi encapsulées dans un bloc PL/SQL ou dans un programme hôte.
2. Insertion de données
L'insertion consiste à ajouter de nouvelles lignes dans une table. Elle peut affecter toutes les
colonnes d'une table ou seulement un sous-ensemble de ces colonnes, les autres prendront
automatiquement des valeurs nulles.
Les valeurs à ajouter lors d'une insertion doivent vérifier les contraintes définies au moment
de la définition des données. Tout tuple ne vérifiant pas les contraintes sera donc rejeté.
Oracle dispose de deux formes pour la commande d'insertion :
1ère forme elle permet d'indiquer dans la commande les valeurs à insérer.
Insert Into Nom_de_la_table [(NomColonne1, NomColonne2, …)]
Values (Valeur1, Valeur2, …);
La spécification des noms des colonnes dans cette requête est obligatoire si on n’a pas de
valeurs pour la totalité des attributs.
Les valeurs des colonnes de type caractère ou chaîne de caractères ou date doivent apparaître
entre apostrophes (' ').
Remarque
Il est possible d'insérer un enregistrement connaissant seulement les valeurs de quelques
colonnes. Pour cela il faut :
Soit indiquer la liste des colonnes à insérer et leurs valeurs respectives.
Soit mettre Null dans la liste des valeurs pour les colonnes vides.
3. Modification de données
L'opération de modification consiste à mettre à jour les données d'une table par de nouvelles
valeurs. Elle se fait à l'aide de la commande Update. La forme de cette commande est la
suivante :
Update Nom_de_la_table
Set NomColonne1 = Valeur1 [, NomColonne2 = Valeur2, …]
[Where Condition] ;
Attribuer au produit n° 1003 le même prix unitaire que le produit ayant le n° 1001.
Update Produit
Set PrixProd = (Select PrixProd from Produit Where NumProd = 1001)
Where NumProd = 1003 ;
4. Suppression de données
La suppression de données consiste à supprimer une ou plusieurs lignes d'une table.
Delete From Nom_de_la_table
[Where Condition] ;
Exemples
Supprimer tous les produits de couleur rouge.
Delete From Produit Where Couleur = 'R';
Supprimer toutes les lignes de la table Produit.
Delete From Produit ;
Exemple
Afficher les numéros et les désignations de tous les produits. Les titres des colonnes à
afficher seront respectivement "Numéro Produit" et "Désignation".
Select NumProd "Numéro Produit", DesProd Désignation From Produit ;
Remarques
Tous les opérateurs spécifiques peuvent être mis sous forme négative en les précédant
par l'opérateur de négation Not : Is Not Null, Not In, Not Between et Not Like.
Si la condition est composée de sous conditions, on fait recours aux opérateurs
logiques And et Or.
Exemples
Lister tous les produits dont la quantité en stock est inférieure à 10.
Select *
From Produit
Where QteStk < 10;
Sélectionner la désignation et le prix unitaire des produits dont le prix unitaire est
compris entre 5 et 10.
Select DesProd, PrixProd
From Produit
Where PrixProd Between 5 and 10;
Sélectionner tous les clients de Sfax et ceux de Tunis.
Select * From Client
Where VilleCl In ('Sfax', 'Tunis'); -- VilleCl=’Sfax’ or VilleCl=’Tunis’
Sélectionner la désignation et le prix unitaire des produits disponibles dont le prix
unitaire est compris entre 5 et 10.
Select DesProd, PrixProd
From Produit
Where QteStk > 0 and PrixProd Between 5 and 10;
Sélectionner les noms des clients qui commencent par la lettre T.
Select NomCl
From Client
Where NomCl Like 'T%';
Sélectionner les noms des clients dont la deuxième lettre est R.
Select NomCl
From Cient
Where NomCl Like '_R%';
Fonctions intégrées
Pour répondre à quelques requêtes SQL on peut faire recourt aux fonctions intégrées du
langage SQL. Parmi ces fonctions, on peut citer les suivantes :
Syntaxe Description
Permet de calculer la valeur absolue de n.
Abs(n)
Syntaxe Description
Syntaxe Description
En supposant qu'un employé est à la retraite à l'âge de 60 ans, afficher les noms et les
prénoms des employés ainsi que les dates prévues pour leurs retraites.
Select Nom, Prenom, Add_Months(DateNais,720) "Retraite"
From Employe;
En supposant qu'un employé est à la retraite après 30 ans de service, afficher les noms
et les prénoms des employés ainsi que les dates prévues pour leurs retraites.
Select Nom, Prenom, Add_Months(DateEmb,360) "Retraite"
From Employe;
En supposant qu'un employé est à la retraite après 30 ans de service ou à l'âge de 60
ans, afficher les noms et prénoms des employés ainsi que les dates prévues pour leurs
retraites.
Select Nom, Prenom, Least(Add_Months(DateNais,720),
Add_Months(DateEmb,360)) Retraite
From Employe;
Afficher le matricule et l'âge en mois de l'employé lors de son embauche.
Select Matricule, Months_Between(DateEmb, DateNais) "Age en mois"
From Employe;
Afficher le matricule et l'âge en années de l'employé lors de son embauche.
Select matricule, Floor(Months_Between(DateEmb,DateNais)/12) "Age en
Années"
From Employe;
Afficher le matricule et le nombre de jours de travail pendant le premier mois
d'embauche de chaque employé.
Select Matricule, Last_Day(DateEmb)-DateEmb + 1 "Nbre Jours de Travail "
From Employe;
Les fonctions de conversion
Syntaxe Description
Exemples
Afficher les employés embauchés pendant l'année en cours.
Select *
From Employe
Where To_Char(DateEmb,'YYYY') = To_Char(Sysdate,'YYYY');
Syntaxe Description
Calcule la moyenne arithmétique des valeurs de la colonne
Avg(NomColonne) spécifiée. Le résultat est la somme des valeurs non NULL
divisée par le nombre de valeurs non NULL.
Count(*) Donne le nombre de tuples trouvés suite à une sélection.
Count (NomColonne) Donne le nombre de valeurs non NULL de la colonne spécifiée.
Calcule la somme des valeurs de la colonne spécifiée suite à
Sum(NomColonne)
une sélection.
Donne la valeur maximale de la colonne indiquée entre
Max(NomColonne)
parenthèses.
Donne la valeur minimale de la colonne indiquée entre
Min(NomColonne)
parenthèses.
Exemples
Donner le nombre de produits de couleur Rouge.
Select count(*) "Nombre Produits Rouges"
From Produit
Where Upper(Couleur)='R';
Afficher la quantité totale en stock des produits de couleur Rouge.
Select Sum(QteStk) "Quantité Totale"
From Produit
Where Upper(Couleur)='R';
Afficher la quantité moyenne en stock des produits de couleur Rouge.
Select Avg(QteStk) "Quantité Moyenne"
From Produit
Where Upper(Couleur)='R';
Afficher les quantités minimale et maximale des produits en stock.
Select Max(QteStk) "Maximum", Min(QteStk) "Minimum"
From Produit;
Autres fonctions
Syntaxe Description
Simule un test de nullité : si le contenu de la
Nvl (NomColonne,Val) colonne est NULL il sera remplacé par Val au
niveau de l’affichage.
Decode(Exp, Val1, Res1, [Val2, Simule un test à choix multiple.
Res2, …, Valn, Resn], Default)
Exemples
Donner la liste des produits (NumProd et PrixProd) en remplaçant tout prix NULL
par 0.
Select NumProd, Nvl(PrixProd,0) Prix
From Produit;
Afficher la liste des produits (NumProd, PrixProd, DesProd) de couleur Rouge en
remplaçant la désignation par ‘***’ pour les produits ayant une quantité en stock =
20.
Select NumProd, PrixProd, Decode(QteStk,20,’***’, DesProd) Désignation
From Produit;
5.3 Requêtes imbriquées
Si la valeur du deuxième opérande est à récupérer de la base de données, on doit faire recours
aux requêtes imbriquées. Ainsi, pour répondre à la requête "Sélectionner tous les produits
dont le prix unitaire est supérieur au prix unitaire d'un produit x se trouvant dans la base",
on peut procéder différemment :
Décomposer l'opération de sélection en deux étapes :
trouver le prix du produit x,
retrouver tous les autres produits dont le prix est supérieur à celui de x.
Utiliser une imbrication de requêtes : remplacer le deuxième opérande par la requête
de sélection du prix du produit x. Cette dernière est appelée sous-requête.
Les différentes utilisations des sous requêtes sont :
Le résultat de la sous-requête est formé d'une seule valeur (c'est surtout le cas des
sous-requêtes utilisant une fonction agrégat dans la clause SELECT)
Exemples
Sélectionner les produits ayant un prix unitaire supérieur au prix unitaire moyen.
Select *
From Produit
Where PrixProd > (Select Avg(PrixProd) From Produit) ;
Trouver la désignation de tous les produits dont le prix unitaire est inférieur à
celui du produit désigné par 'p3'.
Select DesProd From Produit
Where PrixProd <( Select PrixProd From Produit Where Lower(DesProd)
='p3') ;
Le résultat de la sous-requête est formé d'un ensemble de valeurs : dans ce cas, le
résultat de la comparaison (dans la clause Where) peut être considéré comme vrai si :
la condition est vérifiée pour au moins une des valeurs résultantes de la sous-
requête, ou
la condition est vérifiée pour toutes les valeurs.
Syntaxe
Select NomColonne1,…, NomColonneN
From Nom_de_la_table
Where NomColonne {=Any|In|>All|<All|…} (sous-requête) ;
On peut appliquer la négation sur tous les opérateurs ensemblistes mentionnés dans la
requête.
Exemples considérons le schéma de la BD suivante :
Client (CodCl, RaisSoc, AdrCl, VilleCl, TelCl )
Commande ( NumCde, DatCde, MtCde, #CodCl )
LigneCommande (#NumCde, #NumProd, QteCde )
Trouver les produits dont le prix unitaire est supérieur à tous les prix unitaires des
produits en stock à plus de 120 unités.
Select *
From Produit
Where PrixProd > All (Select PrixProd From Produit Where QteStk > 120) ;
Sélectionner les codes des clients qui ont commandé le produit 1001.
Select CodCl
From Commande
Where NumCde In (Select NumCde From LigneCommande
Where NumProd = 1001) ;
5.4 Tri des résultats
Le résultat d'une requête Oracle peut être mis en ordre croissant ou décroissant. On ajoute
alors dans la requête la clause appelée ORDER BY :
Order By NomColonne [Asc | Desc], …
Exemples
Donner la liste des produits par ordre de prix unitaire croissant.
Select *
From Produit
Order By PrixProd;
Donner la désignation, le prix unitaire et la quantité en stock des produits par ordre de
prix unitaire croissant, et pour ceux ayant un même prix par ordre alphabétique.
Select DesProd, PrixProd, QteStk
From Produit
Order By PrixProd, DesProd ;
5.5 Groupement des données
Il est possible d'effectuer dans SQL un groupement ou classification des lignes issues d’une
requête, de façon à ce que chaque groupe créé soit représenté par une seule ligne. Cette
classification permet d’effectuer un calcul (moyenne, somme,...) sur les valeurs du groupe et
retourne un résultat sous la forme d'une ligne par groupe.
Cette classification est possible avec la clause Group By qui doit suivre la clause Where (ou
From si Where est absente) et dont la syntaxe est :
Syntaxe
Group By NomColonne, …
Les colonnes qui figurent dans la clause Select, autres que les fonctions d’agrégats, doivent
obligatoirement être mentionnées dans la clause Group By ; l’inverse n’est pas vrai. Il est
possible de faire un groupement multi-colonnes en mentionnant plusieurs colonnes dans la
clause Group By. Ceci permet d'avoir des sous-groupes à l'intérieur d'un groupe.
Exemples
Trouver la somme des quantités commandées par produit.
Select NumProd, Sum(QteCde) "Qte totale commandée"
From LigneCommande
Group By NumProd ;
Trouver le nombre de commandes par client pour l'année en cours.
Select CodCl, Count(*)
From Commande
Where To_Char(DateCde, 'YYYY')= To_Char(Sysdate, 'YYYY')
Group By CodCl;
Nous pouvons effectuer une sélection des lignes groupées. Cette sélection permet d'éliminer
quelques-uns des groupes ne vérifiant pas une condition donnée et elle s'effectue avec la
clause Having dont la syntaxe est :
Having Condition ;
Remarques
- La condition permet de comparer une valeur du groupe à une constante ou à une
autre valeur résultante d'une sous-requête.
- Il faut bien distinguer la condition de la clause Where qui s'applique sur une ligne
et celle de la clause Having qui s'applique sur un groupe ou à un sous-groupe.
Exemples
Trouver la somme des quantités commandées par produit (n’afficher que ceux ayant
une somme des quantités supérieur à 100).
Select NumProd, Sum(QteCde)
From LigneCommande
Group By NumProd
Having Sum(QteCde)> 100;
Donner les numéros des commandes ayant plus que 10 produits.
Select NumCde
From LigneCommande
Group By NumCde
Having Count(NumProd)> 10;
5.6 Les opérateurs ensemblistes
Ces opérateurs sont l'union, l'intersection et la différence.
a. L'union
Cette opération consiste à faire l'union des résultats de deux requêtes à condition que ces
résultats soient compatibles, c'est à dire qu'ils aient le même nombre de colonnes et les
mêmes types de données pour les colonnes de même position.
Syntaxe
Requête 1
Union
Requête 2 ;
Exemple
Donner les noms des clients dont le code est 100 ou 101 et ceux des clients qui
habitent à 'Sfax'.
Select NomCl
From Client
Where CodCl = 100 Or CodCl = 101
Union
Select NomCl
From Client
Where Upper(VilleCl) = 'SFAX';
b. L'intersection
Cette opération permet d'avoir les lignes communes de deux requêtes. Les résultats doivent
aussi être compatibles.
Syntaxe
Requête 1
Intersect
Requête 2 ;
Exemple
Donner les clients qui habitent à 'Tunis' et qui n’ont pas de numéro de téléphone.
Select *
From Client
Where Upper(VilleCl) = 'TUNIS'
Intersect
Select *
From Client
Where Num Tel is Null;
c. La différence
Cette opération permet d'avoir les lignes qui apparaissent dans le résultat de la 1 ère requête et
non dans le résultat de la 2ème.
Syntaxe
Requête 1
Minus
Requête 2
Exemple
Donner les noms de tous les clients sauf ceux qui habitent à 'Tunis'.
Select NomCl
From Client
Minus
Select NomCl
From Client
Where Upper(VilleCl) = 'TUNIS' ;
a. Le produit cartésien
Le produit cartésien consiste à faire le croisement des données de deux ou plusieurs tables.
Pour construire les n-uplets résultants d’un produit cartésien de deux tables, on combine
chaque n-uplet de la 1ère table avec tous les n-uplets de la 2ème sans aucune contrainte.
Sous SQL, cette opération est effectuée en spécifiant les tables à croiser dans la clause From
et les colonnes résultats dans la clause Select.
Exemple
En se basant sur les deux relations suivantes, le produit cartésien issu est présenté dans le
tableau ci-après.
Client ( CodCl, RaisSoc, AdrCl, VilleCl, TelCl )
Commande ( NumCde, DatCde, MtCde, # CodCl )
Client
Produit Cartésien
NumCde DatCde MtCde CodCl CodCl RaisSoc AdrCl VilleCl TelCl
C10 10/04/2013 123,5 100 100 Iset Route Sfax 74 333444
Sfax Mahdia
C10 10/04/2013 123,5 100 200 Iset Centre Sousse 73 111222
Sousse Sousse
C20 10/05/2013 543,75 200 100 Iset Route Sfax 74 333444
Sfax Mahdia
C20 10/05/2013 543,75 200 200 Iset Centre Sousse 73 111222
Sousse Sousse
C30 10/01/2014 8743,5 200 100 Iset Route Sfax 74 333444
Sfax Mahdia
C30 10/01/2014 8743,5 200 200 Iset Centre Sousse 73 111222
Sousse Sousse
b. La jointure
La jointure simple : permet de faire un rapprochement entre les tables de la jointure par
comparaison des valeurs d'une ou de plusieurs colonnes communes aux tables. C'est un
sous-ensemble du produit cartésien.
Les colonnes utilisées pour la comparaison doivent être exactement de même taille et de
même type. Elles sont appelées colonnes de jointure. Le résultat d'une jointure est une table
dont les colonnes proviennent des tables et les lignes sont constituées des lignes qui vérifient
le critère de comparaison.
Syntaxe
Select NomColonne1, …, NomColonneN
FromTable1 [alias1], table2 [alias2], …
Where Condition ;
Exemple
Si on reprend le même exemple du produit cartésien et on demande l’affichage de
chaque commande avec le client correspondant. On fait recours à la requête suivante :
Select *
From Client Cl, Commande Cd
Where Cl.CodCl= Cd.CodCl;
Le résultat sera le sous-ensemble suivant du produit cartésien.
Application
Donner la liste des commandes en spécifiant pour chacune la raison sociale du client
correspondant.
Select Cd.*, RaisSoc
From Commande Cd, Client Cl
Where Cd.CodCl = Cl.CodCl;
Trouver la raison sociale du client qui a passé la commande N° 11.
Select RaisSoc
From Commande Cd, Client Cl
Where Cd.CodCl= Cl.CodCl
And NumCde = 11;
L'auto-jointure : consiste à faire la jointure d'une table avec elle même; c'est à dire ramener
sur une même ligne des informations provenant de plusieurs lignes de la même table. Pour
cela, il faut créer un synonyme de cette table puis effectuer la jointure de la table avec son
synonyme.
Exemple
Trouver la désignation et le prix unitaire des produits dont le prix est > à celui du
produit désigné par 'p2'.
Sans utilisation d'auto-jointure
Select DesProd , PrixProd
From Produit
Where PrixProd > (Select PrixProd From Prooduit
Where Lower(DesProd) = 'p2' );
Avec l'auto-jointure on aura les deux solutions suivantes
Avec création de synonyme
Create Synonym Prod For Produit ;
Select P.DesProd, P. PrixProd
From Produit P, Prod
Where P. PrixProd > Prod. PrixProd
And Lower (Prod.DesProd) = 'p2';
Avec les alias
Select P1.DesProd, P1. PrixProd
From Produit P1, Produit P2
Where P1. PrixProd > P2. PrixProd
©Sonia LOULOU & Sameh CHAABANE 56
Cours Base de données
Remarque
Dans la condition de la jointure, il faut placer le champ « clé primaire » avant le champ « clé
étrangère » et la post-fixer par le signe + mis entre parenthèses (+).
Exemple
On considère les tables Produit et LigneCommande suivantes :
Produit
LigneCommande
Exemple
Afficher pour chaque produit de la table Produit le nombre de commandes dans
lesquelles il a été commandé.
Select P.NumProd , Count (NumCde)
From Produit P , LigneCommande LC
Where P.NumProd = LC.NumProd (+)
Group by P.NumProd;
P.NumProd Count(NumCde)
100 1
©Sonia LOULOU & Sameh CHAABANE 57
Cours Base de données
800 0
200 2
102 0
Syntaxe
Create View Nom_de_la_Vue [(NomColonne1, …, NomColonneN)]
AS Requête ;
Les vues ainsi crées peuvent être l'objet de nouvelles requêtes en précisant le nom de la vue
au lieu d'un nom de table dans un ordre Select...
Exemple
exécution de la vue par le système. => Elle nous donne toujours les données à jours de la
base de données.
Exemple
Donner le produit ayant le prix unitaire le plus élevé dans la liste des produits de
couleur rouge.
Sans utilisation de vues
Select *
From Produit
Where Prix = (Select Max(Prix) From Produit
And Upper(Couleur) = 'R')
And Upper(Couleur) = 'R';
Avec les vues on aura
Create View ProduitRouge
As Select * From Produit
Where Upper(Couleur) = 'R');
Select *
From ProduitRouge
Where Prix = (Select Max(Prix) From ProduitRouge);
6.4 Insertion dans une vue
L’insertion se fait à l’aide de la commande Insert Into comme pour l’insertion dans une
table, sauf que cette insertion est conditionnée. Elle est permise uniquement dans les cas
suivants :
Les données de la vue viennent d’une seule table.
Il n’y a pas de colonnes virtuelles dans la vue ( Exp. Select 2*5 from … ).
Pas de groupement.
Elle contient la (les) colonne(s) clé de la table.
Remarque cette insertion engendre une insertion dans la base de données.
Bibliographie
[1] Bases de données : Les systèmes et leurs langages. Georges Gardarin Edition Eyrolls
1986.
[2] Bases de données et systèmes relationnels. Claude Delobel, Michel Adiba. Edition Dunod
1982.
[3] Oracle 8, SQL, PLSql, SQL/PLUS. Edition ENI. Méga+ Décembre 1998.
[6] Création de bases de données. Nicolas Larrousse, Collection Synthex, Pearson Education,
2006.