Cours BD Version2022

Année
Universitaire 2022-2023
Support de cours Bases de Données
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
Chapitre 1 : Introduction aux bases de

données
1
 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
©Sonia LOULOU & Sameh CHAABANE 1

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.
2. Exemple de Base de Données

Un exemple de Base de Données pourrait être celui de l'application de gestion de réservation
dans une compagnie aérienne. Les informations peuvent porter sur :
 les pilotes
 les passagers
 les vols
 les avions
 les horaires
 les bagages
 les réservations
Parmi les liens qui existent entre ces informations, on peut citer celui d’un passager avec ses
réservations. Les traitements possibles sont :
 l'enregistrement d'une réservation,
 le calcul du taux de remplissage des vols,
 l'annulation de réservation, etc.
3. Objectifs des Bases de Données

 Structurer et organiser les données d’un système d’information (ex. gestion de
scolarité)
 Assurer l’indépendance entre les programmes et les données : séparation des
traitements (coté application) de l’implémentation physique des données
(stockage).
 Eliminer la redondance des données.
 Assurer l’intégrité et la cohérence des données : avoir un système fiable de
données.

 L’avantage majeur de l’utilisation des bases de données est la possibilité de

pouvoir être accédées par plusieurs utilisateurs simultanément (en même temps).
4. Caractéristiques des Bases de Données

 Peut être centralisée ou distribuée.
 Doit répondre aux besoins d’une ou de plusieurs applications.
 Doit être interrogeable.
 Peut être utilisée par un groupe d’utilisateurs travaillant en parallèle.
 Doit garantir l’existence de l’information afin de prendre les décisions
stratégiques pour l’organisme.
5. Besoins en Bases de Données

Besoins de description
 Décrire les données de l’application sans faire référence à une solution
informatique particulière  Modélisation Conceptuelle (Modèle
Entité/Association, …).
 Élaborer une description équivalente pour le stockage des données 
Modélisation Physique (Langage de Définition de Données LDD).
Besoin de manipulation et d’interrogation des données
 Pouvoir insérer, modifier et supprimer les données.
 Pouvoir répondre à toute demande d’information portant sur les données
contenues dans la base  Langage de Manipulation de Données LMD.
Besoin d’exactitude / cohérence
 Il faut pouvoir exprimer toutes les règles qui contraignent les valeurs pouvant être
enregistrées de façon à éviter toute erreur qui peut être détectée  Les
Contraintes d’intégrité (CI).
Besoin de fiabilité
 Il ne faut pas que les données soient perdues à cause d’un dysfonctionnement
quelconque.
Besoin de contrôle de concurrence d’accès
 Il ne faut pas qu’une action faite pour un utilisateur soit annulée par l’exécution
simultanée d’une autre action d’un autre utilisateur.
Besoin de confidentialité
 Toute donnée doit être protégée contre l’accès par des utilisateurs non autorisés 
Langage de Contrôle de Données LCD.

6. Définition de Système de Gestion de Bases de

Données
Afin d’assurer les besoins cités antérieurement, la nécessité d’un système de gestion c’est
vite fait ressenti. La gestion d’une base de données se fait grâce à un système appelé SGBD
(Système de Gestion de Bases de Données). C’est un logiciel permettant de définir une
représentation des informations à stocker (via un LDD), d’interroger et de manipuler (insérer,
supprimer, mettre à jour) de grandes quantités de données dont il faut garantir la continuité
(via un LMD) et l’accessibilité de manière concurrente (plusieurs utilisateurs simultanés) et
de contrôler l’accès aux données (via un LCD).
Exemples ORACLE, ACCESS, Sybase, Ingres, Informix, DB2, ORION, etc.
Parmi les fonctionnalités d’un SGBD, on peut citer :
 Le partage de données
 Le contrôle des traitements concurrents (verrouillage)
 La gestion des autorisations d’accès
 La sécurité et les reprises après panne…
7. Cycle de vie d’une Base de Données

Le cycle de vie d’une Base de Données peut être présenté par les quatre phases suivantes :
 Conception de la base (schéma conceptuel)
 Implémentation des données (schéma physique)
 Utilisation (interrogation, mises à jour)
 Maintenance (correction, évolution)

Chapitre 2 : Modélisation des données

« Du modèle Entité-Association au modèle
relationnel »
 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
1.2 Les concepts de base

La représentation du modèle Entité-Association s’appuie sur les concepts suivants :
 « 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.
NomEntitéType
Exemples Etudiant, Commande, Cours, Client.

 Le type propriété intitulé « propriété-type » : c’est une classe de propriétés semblables.
NomPropriétéType

Exemples Age, Ville, QteCde, Date

 Le type association intitulé « association-type »ou « relation-type » : c’est une classe
de relations (ou d’associations) définies sur les mêmes objets-types et ayant toutes les
mêmes propriétés-types.
NomAssociationType
Exemples
Etudier Diriger
Etudiant Cours Employé Employé
Etudiant Etudier Cours
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
N-M 1-N 1-1

0-N, 0-M 0-1, 0-N 0-1, 0-1
Une instance de A peut Une instance de A ne peut
être liée à plusieurs être liée qu’à une seule
instances de B et instance de B et
réciproquement réciproquement
Exemples
Association de type 1-N : Liens hiérarchiques
1 N
Client Passer Commande
Une occurrence de Client permet de déterminer une ou plusieurs occurrences de Commande

et une occurrence de Commande correspond au plus à une occurrence de Client.
Association de type N-M : Liens maillés
N M
Produit Commander Commande
On n'a aucune restriction sur le nombre d'occurrences de Produit et de Commande

intervenant dans l'association. En effet, un produit peut être commandé dans plusieurs
commandes et dans une commande on peut commander plusieurs produits.
Association de type 1-1 :
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
Commande M Commander N Produit
1 CodPr
NumCde QteCdee
LibPr
DateCde
QteStock
Facturer
PuPr
1
Facture
NumFact
DateFact
MtFact
Remarques Les deux associations fournir et commander sont porteuses de données.

 Corrigé exercice 2
Service 1 Contrôler N Projet
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.

2.2 Concepts de base du modèle relationnel

 Une base de données relationnelle est un ensemble de relations.
 Une relation est une table à deux dimensions :
 Les colonnes : représentent les attributs de la relation
 Les lignes : désignent les tuples de la relation
 Un tuple, nommé aussi n-uplet, est formé de l’ensemble des valeurs de chaque
attribut de la relation
 Chaque attribut appartient à un domaine de valeurs (Entier, Chaîne de caractères,
Réel..).
Exemple Soit la relation Produit composée par les attributs NumProd,
DesProd, QteStk, QteSeuil et PrixProd.
Produit NumProd DesProd QteStk QteSeuil PrixProd
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.

Exemples Produit (NumProd, DesProd, QteStk, QteSeuil, PrixProd)

LigneCommande (NumCde, NumProd, QteCdee)
 Clé étrangère : Soit la relation R1 (A, B, …, S, …). On dit que S est une clé
étrangère s'il existe une relation R2 ayant pour clé primaire S.
Exemple Magasin (NumMag, AdrMag, SurfMag)
Produit (NumProd, DesProd, QteStk, QteSeuil, PrixProd, #NumMag)

 Si on connaît la clé primaire d'un produit, on dispose des informations concernant
ce produit ainsi que celles du magasin où il est stocké.
2.3 Contraintes d'intégrité

Une contrainte d'Intégrité (CI) est une règle qui doit être vérifiée au moment de la
manipulation des données afin que le résultat soit considéré correct et cohérent. A tout
instant de l'existence d'une BD, on doit pouvoir ajouter, modifier ou supprimer une
contrainte d'intégrité et le SGBD doit être capable de vérifier que la base est toujours
cohérente vis à vis du changement apporté à son environnement ; dans le cas contraire, il
doit rejeter l’intervention en question.
Il existe plusieurs types de contraintes d'intégrité, parmi lesquelles on peut citer :
 Unicité de la clé d’une relation : Le SGBD doit accepter la déclaration d'un attribut ou
d'un groupe d’attributs comme clé primaire (duplication et valeur nulle interdites).
 CI individuelles : il s'agit de contraintes d'intégrité qu'on applique à chaque tuple
individuellement telles que les contraintes de plage de valeurs, la liste des valeurs
possibles, les contraintes entre constituants (attributs)….
Exemple Soit la relation Produit définie précédemment :
Produit (NumProd, DesProd, QteStk, QteSeuil, PrixProd)
 Contrainte de plage de valeurs
0  QteStk  100
 Liste des valeurs possibles
DesProd peut être stylo, cahier ou livre
 Contrainte entre constituants
QteStk  QteSeuil
 CI intra-relation (dans la relation) : il s'agit des contraintes entre les champs d'une
même relation.
Exemple QteStk  2 * Moyenne (QteSeuil)

 CI inter-relations (entre les relations de la base) : on les trouve généralement pour les
clés étrangères.
3. Les règles de passage du modèle E/A au modèle

relationnel
 Règle 1 : Toute entité se transforme en une relation dont l'identifiant sera la clé primaire
et admettant comme attributs les propriétés de l’entité.
 Règle 2 : Toute association de type 1-N se traduit par l'introduction d'une clé étrangère de
l'entité source (côté 1) vers l'entité cible (côté N).
 Règle 3 : Toute association de type N-M se traduit par la création d'une relation dont la
clé primaire sera la concaténation des identifiants des entités participants à cette
association et admettant comme attributs les propriétés portées par l’association.
Exercice :
En appliquant ces règles sur les modèles E/A des deux exercices précédents, donner les
modèles relationnels correspondants.
 Solution : exercice 1
Client (CodCl, NomCl, VilleCl, TelCl)
Produit (CodPr, LibPr, QteStock, PuPr)
Fournisseur (CodFrs, NomFrs, VilleFrs, TelFrs)
Commande (NumCde, DatCde, #CodCl)
Facture (NumFact, DatFact, MtFact, #NumCde)
Commander (NumCde, CodPr, QteCdee)
Fournir (CodFrs, CodPr, PrixAchat)
 Solution : exercice 2
Service (NumSce, NomSce)
Employé (NumEmp, NomEmp, AdrEmp, DateNais, #ResponsableSce, #NumSce)
Projet (NumProj, NomProj, #NumSce)
Diriger (#NumSce, #NumEmp, DateDebDir)
Travailler (#NumEmp, #NumProj, NbrHeurHeb)

Chapitre 3 : INTRODUCTION AU LANGAGE SQL
 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.
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.

2. Emplacement de SQL dans la structuration en couche

du SGBD Oracle
Génie Logiciel (Case

Outils de communication Dictionnary, Case Designer,
(SQL Net, SQL connect) Case Generator)
Couche PL/SQL
Couche SQL
Noyau
Dictionnaire de données
Utilitaire (SQL SBA,

SQL Loader)
Outils de développement (SQL
Plus, SQL Forms, SQL Menu) Outils d’aide à la décision
(Easy SQL, SQL Calc)
Le noyau : il permet la communication avec la base de données et la connexion à d’autres

noyaux dans le cas de base de données réparties.
Un noyau Oracle peut supporter une ou plusieurs BD. Chaque BD possède une instance et
des fichiers physiques. L'instance se compose d'une série de processus agissant en tâche de
fond et d'une réservation de zone mémoire. Chaque BD est repérée par son identificateur
d'instance déclaré dans la variable d'environnement ORACLE_SID.
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.
La couche PL/SQL (Procedure Language extension to SQL) : c’est une extension

procédurale de la couche SQL, elle permet d’utiliser les possibilités des langages
informatiques de 3ème et 4ème génération telles que les structures de contrôle, l’utilisation des
variables et les traitements des erreurs.
3. Les objets du langage SQL

Les objets gérés par SQL sous Oracle sont les tables, les vues, les utilisateurs avec leurs
privilèges d'accès et les accélérateurs. Dans Oracle, l'ensemble de tables et de vues créées par
un utilisateur constituent la base de données. Cependant, tout utilisateur peut accéder à
d'autres tables et vues créées par d'autres utilisateurs s'il a le privilège et l'autorisation de le
faire et en préfixant les noms des tables et des vues par le nom de leurs propriétaires.
3.1 Les tables

Une table est identifiée par un nom unique et un ensemble de valeurs présentées sous forme
de matrice. Elle peut décrire une entité ou une association entre entités.
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.

3.3 Les utilisateurs

Un utilisateur dans ORACLE est défini par son nom (identifiant unique, un mot de passe et
un ensemble de privilèges). Les privilèges permettent de fixer les droits d'utilisation des
objets définis dans la base et d'assurer la confidentialité des données.
3.4 Les accélérateurs

ORACLE dispose de deux mécanismes pour améliorer les performances au niveau des accès
à la BD.
 Les index : Ce sont des tables définissant pour chaque ligne l'adresse physique de la
page où sont stockées les valeurs de cette ligne.
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.
4. Le langage de contrôle de données (LCD)

La sécurité de la base de données peut être classée en deux catégories :
 La sécurité du système : concerne l'accès à la base de données et son utilisation au
niveau système, notamment le nom utilisateur et le mot de passe, l'espace disque
alloué aux utilisateurs, ainsi que les opérations système que les utilisateurs peuvent
effectuer.
 La sécurité de la base de données : concerne la gestion des accès aux objets de base
de données et leur utilisation, ainsi que les actions que les utilisateurs peuvent
effectuer sur les objets.

4.1 Création d'utilisateurs

Syntaxe
Grant [ Connect / , Resource / , DBA ]
To Nom_Utilisateur
Identified By mot_de_passe ;
L'option CONNECT autorise l'utilisateur à :
 se connecter à ORACLE,
 sélectionner, modifier et supprimer les données des tables de la base.
Donc un utilisateur ayant seulement le droit CONNECT ne peut pas créer de tables, ni de
clusters, ni d'index.
L'option RESOURCE ne peut être attribuée que si l'utilisateur a le droit CONNECT. Elle lui
permet de créer des tables, des index, des vues et des groupements (des clusters).
L'option DBA englobe les droits des deux options précédentes et permet en plus de :
 accéder aux données de tous les utilisateurs de la même base,
 créer et de supprimer des utilisateurs et des droits,
 administrer la base (sauvegarder et restaurer des données de la base, contrôler
l'intégrité,...) et
 attribuer ou enlever des privilèges sur les tables, index et clusters à d’autres
utilisateurs.
Remarque pour changer le mot de passe d’un utilisateur, on peut utiliser la commande
suivante :
Alter User Nom_Utilisateur Identified By nouveau_motpasse ;
4.2 Attribution des droits

Toute table, synonyme, index ou cluster n'est initialement accessible que par l'utilisateur qui
l'a créée. Pour partager certains droits avec d'autres utilisateurs, le propriétaire doit utiliser
l'instruction suivante :
Grant droit1, droit2, ...., droit n
On Objet
To Nom_Utilisateur1, Nom_Utilisateur2, ..., Nom_Utilisateurp
[WITH GRANT OPTION]
Avec :
 Droit : peut être Alter, Delete, Index, Insert, Update, Select (All regroupe tous les
droits),
 Objet : est le nom d’une table, d’une vue etc.
 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.

Il existe deux types de ROLLBACK :

 Celui demandé par l'utilisateur qui s'aperçoit d'une anomalie et désire revenir au
dernier état cohérent de la base de données.
 Celui réalisé par le système en cas de panne quelconque.
Le mot WORK est facultatif.

Chapitre 4 : LE LANGAGE DE DÉFINITION DE

DONNÉES(LDD)
 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.
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 :
2.1 Formes de création de tables

1ère forme Création simple : elle permet de définir uniquement la structure de la table.
Create Table Nom_de_la_table
(Nom_de_colonne1 Type [(taille)] [default ValeurParDefaut] [NULL/NOT NULL]
[Contrainte de colonne] […],
Nom_de_colonne2 Type [(taille)] [default ValeurParDefaut ][NULL/NOT NULL]
[Contrainte de colonne],
...
Nom_de_colonneN Type [(taille)] [default ValeurParDefaut ][NULL/NOT NULL]
[Contrainte de colonne],
[Contraintes de table]) ;
La taille indique la taille maximale que peut avoir une colonne.

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 :
Type de donnée Syntaxe Description
Chaîne de caractères de longueur fixe n

Type alphanumérique CHAR(n)
(1<=n<=255)
Chaîne de caractères de longueur variable
Type alphanumérique VARCHAR2(n)
(1<=n<=2000)
Nombre entier ou décimal de 40 positions au
Type numérique NUMBER maximum, de la forme : chiffres de 0 à 9 avec les
signes ‘+’, ‘-‘ et le point décimal ‘.’
Nombre de n chiffres dont [optionnellement après
Type numérique NUMBER (n,[d])
la virgule]
Type horaire DATE Date dont le format standard est DD-MON-YY
… … …
Exemple Créer la table « Produit » ayant comme schéma :
Produit (NumProd, DesProd, Couleur, Poids, QteStk, QteSeuil, PrixProd)
Avec
NumProd : de type numérique de taille 6
DesProd : de type caractère variable de taille 15.
Couleur : de type caractère sur une position
Poids : de type numérique sur huit positions dont trois chiffres après la virgule.
QteStk : de type numérique sur sept positions dont trois chiffres après la virgule.
QteSeuil : de type numérique sur sept positions dont trois chiffres après la virgule.
PrixProd : de type numérique sur dix positions dont sept chiffres avant la virgule.
Create table Produit
(
NumProd Number(6) not null ,
DesProd Varchar2(15),
Couleur Char(1),
Poids Number(8,3),
QteStk Number(7,3),
QteSeuil Number(7,3),
PrixProd Number(10,3)
);
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.
2.2 Les contraintes d’intégrité

Une contrainte d'intégrité est une clause permettant de contraindre la modification de tables,
faite par l'intermédiaire de requêtes utilisateurs, afin que les données saisies dans la base
soient conformes aux données attendues. Ces contraintes peuvent être exprimées tout au long
du cycle de vie de la BD.
On peut utiliser des contraintes pour imposer l’une des règles suivantes :
 Donner une valeur par défaut à un champ (Default),
 Imposer que tout attribut ait une valeur dans la table (Not Null),
 Imposer que la valeur d’un attribut donné soit unique dans la table (Unique),
 Identifier une ou plusieurs colonnes comme étant une clé primaire (Primary Key),
 Imposer que la valeur d’une ou de plusieurs colonnes existe dans une autre table
(Foreign Key), ….
 Imposer que la valeur d’une ou de plusieurs colonnes soit conforme à une
expression donnée (Check).
a. Définir une valeur par défaut : Default

Le langage SQL permet de définir une valeur par défaut, lorsqu'un champ de la base n'est pas
renseigné, grâce à la clause Default.
La clause Default doit être suivie par la valeur à affecter. Cette valeur peut être l’un des types
suivants:
 constante numérique
 constante alphanumérique (chaîne de caractères)
 le mot clé User (nom de l'utilisateur)
 le mot clé Null

 le mot clé Current_Date ou Sysdate(date de saisie)

 le mot clé Current_Time (heure de saisie)
 le mot clé Current_Timestamp (date et heure de saisie)
b. Forcer la saisie d'un champ : Not Null

Le mot clé Not Null permet de spécifier qu’un champ doit être saisi, c’est-à-dire que le
SGBD refusera d’insérer des tuples dont un champ comportant la clause Not Null n’est pas
renseigné
c. Imposer l'unicité d'une valeur : Unique

La clause Unique permet de garantir que toutes les valeurs d'une colonne d'une table seront
différentes.
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
d. Définition de clé primaire : Primary Key

L'ensemble des colonnes faisant partie de la table en cours et permettant de désigner de façon
unique un tuple est appelé clé primaire. Elle est définit grâce à la clause Primary Key suivie
de la liste de colonnes, séparées par des virgules, entre parenthèses. Ces colonnes ne peuvent
alors ni prendre la valeur Null ni avoir simultanément la même combinaison de valeurs.
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),
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)
);
e. Définition de clé étrangère : Foreign Key, References

Lorsqu'une liste de colonnes de la table en cours de définition permet de définir la clé
primaire d'une table étrangère, on parle alors de Clé étrangère.
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),
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
(
Couleur Char,
Poids Number(8,3),
QteStk Number(7,3),
Prix Number(10,3),
CodMag Number(6) References Magasin (NumMag)
);

f. Emettre une condition sur un champ : Check

Il est possible de définir une condition sur un champ grâce à la clause Check() comportant
une expression logique. Si la valeur saisie est différente de Null, le SGBD va effectuer un test
grâce à la condition logique.
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'
(
Couleur Char(1),
Poids Number(8,3) Check (Poids > 0),
QteStk 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'))
);

Cours Base de données
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.
3. Modification de la structure d’une table

Les tables gérées par oracle peuvent avoir une structure dynamique (ajout de nouvelles
colonnes, suppression de colonnes, ajout de contraintes et/ou modification des types de
colonnes déjà existantes).
Ces possibilités de modification de tables se traduisent par trois variantes de la commande
Alter Table.
1ère variante ajout de nouvelles colonnes et/ou des contraintes nécessaires à une table
Alter Table Nom_de_la_table
ADD (NomColonne1 Type [(taille)] [NULL | NOT NULL] …,
...
NomColonneN Type [(taille)] [NULL | NOT NULL] …[,
Constraint Nom_de_la_contrainte ………………………]);
Exemple 1
Ajouter les champs « Gérant » de type caractère variable de taille 20 et « Ville » de type
caractère variable de taille 15 contenant par défaut Sfax à la table magasin.
Alter Table Magasin

ADD (Gérant Varchar2(20), Ville Varchar2(15) Default 'Sfax');
Exemple 2
On suppose que la table Produit a été créée sans clé primaire ni clé étrangère.
 Ajouter la contrainte clé primaire pour le champ NumProd
Alter Table Produit

ADD (Constraint PK_Produit Primary key (NumProd));
 Ajouter la contrainte clé étrangère pour le champ CodMag
Alter Table Produit

ADD(Constraint FK_Produit Foreign Key (CodMag) References
Magasin(NumMag));

 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.
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);

 La suppression d’une contrainte de clé primaire est possible en utilisant la

commande :
ALTER TABLE Nom_de_la_table
DROP Primary Key [Cascade] ;
Remarque
L'option Cascade est ajoutée pour pouvoir supprimer une clé primaire référencée.
Exemple
Supprimer dans l'ordre les clés primaires des tables Magasin et Produit.
Alter Table Magasin
DROP Primary key Cascade;
Alter Table Produit
DROP Primary Key;
 La suppression d’une contrainte autre que la clé primaire :
DROP Constraint Nom_de_la_contrainte ;
Où Le nom de la contrainte est celui de la contrainte à supprimer.
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 :
Drop Table Nom_de_la_table [Cascade Constraints] ;

Le mot clé Cascade Constraints permet de supprimer toutes les contraintes d’intégrité
référentielles qui se reflètent à la clé primaire de la table à supprimer.
La suppression d’une table entraîne la suppression, dans le dictionnaire, de sa définition ainsi
que les synonymes et index correspondants. Dans ce cas il faut redéfinir toutes les vues
créées sur la table supprimée.
Exemple Supprimer dans l'ordre les tables Magasin et Produit.

Drop Table Magasin Cascade Constraints ;
Drop Table Produit;
5. Changement du nom d’une table
On peut renommer une table en utilisant la commande Rename dont la syntaxe est :
Rename Ancien_nom To Nouveau_nom ;
Exemple Modifier le nom de Produit en Article.
Rename Produit To Article ;
6. Création de synonymes pour une table
Il s'agit de faire une copie d’une table avec un nom différent. La création de synonyme se fait
avec la commande :
Create Synonym Nom_synonyme For Nom_table ;
Exemple Créer un synonyme M pour la table Magasin
Create Synonym M For Magasin;
Remarque
La suppression d’un synonyme se fait avec la commande :
Drop Synonym Nom_synonym ;
Exemple Supprimer le synonyme M.
Drop Synonym M;


Chapitre 5 : LE LANGAGE DE MANIPULATION DE

DONNÉES(LMD)
 Objectifs
Maîtriser la manipulation des données en se basant sur les commandes du

langage LMD. L’apprenant doit pouvoir décomposer une requête afin de
présenter les résultats attendus.
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.

Application Considérons la table « Produit » définie précédemment :

 Ajouter un nouveau produit en spécifiant les valeurs de toutes les colonnes.
Insert Into Produit Values (1007, 'chaise', 'B', 25, 15, 2, 45) ;
 Ajouter un nouveau produit sachant uniquement son numéro et son nom.
Insert Into Produit (NumProd, DesProd) Values (1008, 'disquette') ;
2ème forme elle permet de copier des données d'une table vers une autre.
Insert Into Nom_de_la_table [(NomColonne1, NomColonne2, …)]
Requête ;
Exemple soit la table Produit_Rouge qui contient les produits ayant la couleur rouge et
ayant le même schéma que la table Produit. Insérer les produits de couleur rouge dans la
table Produit_Rouge.
Insert Into Produit_Rouge
Select * from Produit Where Couleur='R';
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] ;
Valeuri peut être :

 une expression,
 une constante,
 un résultat provenant d'une clause Select ou
 Null (pour supprimer la valeur initiale du champ).
La clause Where permet de préciser les tuples sur lesquels la mise à jour aura lieu. Si elle est
omise, la mise à jour englobera tous les tuples de la table.
Application Considérons la table Client (CodCl, NomCl, AdrCl,VilleCl, TelCl)
 Modifier l'adresse du client TRIKI qui devient 15, cité des fleurs.
Update Client Set AdrCl = '15, cité des fleurs' Where NomCl = 'TRIKI' ;
 Majorer de 5% les prix unitaires des produits dont le prix est supérieur à 10.
Update Produit Set PrixProd = PrixProd * 1.05 Where PrixProd > 10 ;

 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 ;
5. Consultation des données

Elle se fait à l'aide de la commande Select du LMD. Une commande de sélection est
composée principalement de trois blocs :
 Select : définit la liste des colonnes que l'on veut obtenir.
 From : indique le(s) nom(s) des relations nécessaires pour obtenir le résultat
escompté.
 Where : définit la condition que doit vérifier un n-uplet donné pour qu'il fasse partie
du résultat.
5.1 Recherche simple dans une table

La forme la plus simple d'une requête de consultation consiste à rechercher toutes les lignes
d'une table donnée. La syntaxe correspondante est la suivante :
Select * From Nom_de_la_table ;
Exemple Lister le contenu de la table Produit.
Select * From Produit ;
Si on ne souhaite pas afficher toutes les colonnes de la table, on utilise la projection qui
permet d’extraire des données d’une table tout en conservant que les colonnes souhaitées.
La syntaxe correspondante est la suivante :
Select NomColonne1, …, NomColonneN From Nom_de_la_table ;
Exemple : Lister les numéros et les désignations de tous les produits.

Select NumProd, DesProd From Produit ;

On peut choisir à l'affichage du résultat des noms de colonnes différents de ceux de la table
en utilisant les alias :
Select NomColonne1 [alias1], …, NomColonneN [aliasN] From Nom_de_la_table ;
Si l'alias est composé de plus d'un seul mot, il faut le mettre entre guillemets.
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 ;
5.2 Recherche avec qualification

Dans la plupart des cas, les requêtes de recherche ne portent pas sur la totalité d'une table.
Seules quelques lignes sont à sélectionner selon une certaine condition. Cette condition
s'exprime dans la clause WHERE de qualification qui vient après la clause From et dont la
syntaxe est la suivante :
Select * From Nom_de_la_table
Where Condition ;
La condition est composée généralement de trois termes : (opérande1 opérateur opérande2).
 Opérande1 : un nom de colonne

 Opérateur : un opérateur de comparaison
 Opérande2 : une constante, un nom de colonne ou une liste de valeurs.
En plus des opérateurs de comparaison classiques (=, <> ou !=, <, <=, >, >=), oracle dispose
d'autres opérateurs spécifiques :
Is Null : Teste si le contenu d'une colonne est une valeur nulle.
In (Liste de valeurs) : Teste si le contenu d'une colonne coïncide avec l'une des valeurs
de la liste.
Between V1 And Vv2 : Teste si le contenu d'une colonne est compris entre les valeurs V1
et V2.
Like chaîne_générique : Teste si le contenu d'une colonne ressemble à une chaîne de
caractères obtenue à partir de la chaîne générique. Cette dernière
est une chaîne de caractères dans laquelle il y a l'un des caractères
suivants : % remplace une chaîne de caractères même la chaîne
vide et _ remplace un seul caractère.

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 :
 Les fonctions arithmétiques :
Syntaxe Description
Permet de calculer la valeur absolue de n.
Abs(n)
Permet d'avoir le plus petit entier supérieur ou égal à n.

Ex : Ceil(128.3) retourne 129
Ceil(n)
Ceil(128.8) retourne 129
Permet d'avoir la partie entière de n.
Ex : Floor(128.3) retourne 128
Floor(n)
Floor(128.8) retourne 128
Mod(m,n) Permet d'avoir le reste de la division entière de m par n.
Arrondit la valeur n à m décimal.
Ex : Round(128.3) retourne 128
Round(n,m) Round(128.8) retourne 129
Round(128.177,2) retourne 128.18
Round(128.123,2) retourne 128.12
Power(m,n) Permet d'avoir m à la puissance n.
Sign(n) Retourne –1 si n < 0, 0 si n= 0 et 1 si n>1.
Sqrt(n) Permet d'avoir √x.
Retourne l’argument n tronqué à m décimales. Si m = 0, le
résultat sera de type entier
Ex : Trunc (121.371,1) donne 121.3
Trunc(n,m) Trunc (121.371,2) donne 121.37
Trunc (121.371,-1) donne 120
Trunc (121.371,-2) donne 100
Trunc (121.371,0) donne 121
Exemples:
 Afficher les désignations de tous les produits et leurs prix arrondis en Dinars.
Select DesProd, Round(PrixProd) "Prix en Dt"
From Produit ;
 En supposant que les numéros des produits sont exactement sur quatre positions,
afficher les désignations des produits dont le numéro commence par 1.
Select DesProd
From Produit
Where Trunc(NumProd,-3)=1000;

 Afficher les numéros et les prix des produits majorés en dinars.

Select NumProd, ceil(PrixProd)
From Produit ;
 Afficher la liste des produits dont le prix Appartient à [100,101[.
Select * from Produit
Where Floor(PrixProd) = 100;
 Les fonctions s'appliquant aux chaînes de caractères :
Syntaxe Description
Rtrim (ch) Supprime les espaces à la fin de la chaîne Ltrim

Length(ch) Renvoie la longueur d'une chaîne.
Ajoute n-Length(ch) espaces (si le caractère c n’est pas
spécifié), sinon il s’agit d’ajouter n-Length(ch) fois le
Rpad (ch,n[,c])
caractère c à la fin de la chaîne ch afin d’obtenir n
caractèresLpad
Met en majuscule la première lettre de chaque mot de la
Initcap (ch)
chaîne et en minuscule le reste des caractères.
Donne la position de la mième occurrence de ch2 dans ch1
Instr(ch1,ch2,n,m)
à partir du caractère de position n si elle existe et 0 sinon.
Lower(ch) Transforme la chaîne ch en minuscule  Upper.
Permet d'extraire de ch une sous-chaîne de longueur n à
Substr(ch,m,n)
partir du caractère de position m.
Permet de remplacer dans la chaîne ch tous les caractères
Translate(ch,ch1,ch2) de ch1 par les caractères de même position de ch2 (avec
Length(ch1)=Length(ch2))
Permet de remplacer dans la chaîne ch toutes les
Replace(ch, ch1[,ch2]) occurrences de ch1 par ch2. Si ch2 est non spécifiée, ch1
sera remplacée par un vide.
ch1ch2 Concatène les deux chaînes.
Exemples
Considérons toujours la même structure de la table Produit :
 Afficher les numéros des produits correspondants à des souris.

Select NumProd
From Produit
Where Upper(Ltrim(Rtrim(DesProd))) = 'SOURIS';

 Afficher la liste des produits dont la désignation est composée au maximum de 6

caractères.
Select * From Produit
Where Length(Ltrim(Rtrim (DesProd)))<= 6;
 Afficher les désignations des produits avec seule la première lettre en majuscule.
Select Initcap(Ltrim(DesProd)) Désignation
From Produit;
 Afficher les numéros et les couleurs des produits dont la désignation contient 'er' à
partir de la 6ème position.
Select NumProd, Couleur
From Produit
Where Lower(Substr(Ltrim(DesProd),6,2)) = 'er';
 Afficher toutes les désignations des produits en remplaçant toute 'a' par 'A'.
Select Translate(DesProd,'a','A') Désignation
From Produit;
Ou bien
Select Replace(DesProd,'a','A') Désignation
From Produit;
 Modifier la table produit en remplaçant la désignation 'Scanner' par 'Imprimante'.
Update Produit
Set DesProd = Replace(Lower(DesProd),'scanner','imprimante')
Where Lower(Ltrim(Rtrim(DesProd)))='scanner';
 Modifier la table produit en remplaçant dans la désignation le mot 'Scanner' par
'Imprimante'.
Update Produit
Set DesProd = Replace(Lower(DesProd),'scanner','imprimante')
Where Lower(DesProd) Like '%scanner%';
 Ajouter le champ « Propriete » de type caractère variable sur 4 positions formé des
trois premiers caractères de la désignation concaténés à la couleur.
Alter Table Produit
Add Propriete Varchar(4);
Update produit
Set Propriete = Substr(Ltrim(DesProd),1,3)|| Couleur;
 Afficher les produits dont la désignation contient 'a' ou 'A' en dernière position.
Where Lower(Rtrim(DesProd)) Like '%a' ;

 Afficher les produits dont la désignation commence et se termine par la même lettre.
Where Substr(Lower(Ltrim(DesProd)),1,1)=
Substr(Lower(Rtrim(DesProd)),Length(Ltrim(Rtrim(DesProd))),1);
 Les fonctions s'appliquant aux dates
Syntaxe Description
Add_Months(d,n) Permet d'ajouter n mois à la date d sachant que n est un entier.

Greatest(d1,d2, …) Permet d'avoir la date la plus grande  Least.
Permet d'avoir le nombre de mois qui se trouvent entre la date
Months_Between(d1,d2)
d1 et la date d2. (avec d1 > d2)
Last_Day(d) Permet d'avoir la date du dernier jour du mois de la date d.
Sysdate Renvoi la date système.
Exemples Soit la table Employe (Matricule, Nom, Prenom, DateNais, DateEmb)
 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
To_Char(Date,FormatDate) convertit une date ou un nombre en une

To_Char (Nombre[, Format]) chaîne de caractères selon le format spécifié.
convertit une chaîne de caractères

To_Date(Chaîne, FormatDate)
représentant une date en une date.
convertit une chaîne de caractères
To_Number(Chaîne[, Format]) représentant un nombre en un nombre selon
le format spécifié.
Avec FormatDate peut être :
YYYY Année sans virgule
YY 2 derniers chiffres de l’année
Q Numéro de trimestre de l’année (1 à 4)
WW Numéro de semaine de l’année (1 à 52)
W Numéro de semaine dans le mois
MM Numéro du mois (1 à 12)
DDD Numéro de jour dans l’année (1 à 366)
DD Numéro du jour dans le mois (1 à 31)
D Numéro de jour dans la semaine (1 à 7)
YEAR Année en toute lettre
MON Nom du mois abrégé en toute lettre
MONTH Mois en toutes lettres
DAY Nom du jour sur 9 caractères
DY Nom du jour abrégé en 3 lettres
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');

 Afficher les employés ayant au moins 3 ans d'ancienneté.

Select *
From Employe
Where Months_Between(Sysdate,Date_Emb)/12 >= 3;
 Les fonctions d’agrégats (ou fonctions de groupe)
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
 Afficher la quantité moyenne en stock des produits de couleur Rouge.
Select Avg(QteStk) "Quantité Moyenne"
From Produit
 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], …
La non spécification de l’ordre de tri, implique l’ordre croissant (Asc).

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' ;
5.7 Jointure et produit cartésien

Dans toutes les opérations traitées, on a utilisé une seule table. Les opérations permettant
d'effectuer un rapprochement entre les données, se trouvant dans des tables différentes, sont
le produit cartésien et la jointure.
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
CodCl RaisSoc AdrCl VilleCl TelCl

100 Iset Sfax Route Mahdia Sfax 74 333444
200 Iset Sousse Centre Sousse Sousse 73 111222
Commande
NumCde DatCde MtCde CodCl
C10 10/04/2013 123,5 100
C20 10/05/2013 543,750 200
C30 10/01/2014 8743,5 200
 La requête correspondante pour le produit cartésien est :
Select *
From Client, Commande ;
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
Sousse Sousse
C30 10/01/2014 8743,5 200 100 Iset Route Sfax 74 333444
Sfax Mahdia
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.
NumCde DatCde MtCde CodCl CodCl RaisSoc AdrCl VilleCl TelCl

C10 10/04/2013 123,5 100 100 Iset Route Sfax 74 333444
Sfax Mahdia
0 Sousse Sousse
Sousse Sousse
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
And Lower(P2.DesProd) = 'p2' ;

La jointure externe : Oracle dispose, en plus des opérateurs de jointure classiques, d'une
jointure externe qui permet de ramener :
 les n-uplets ayant des correspondances entre les tables jointes.
 les n-uplets n'ayant pas de correspondance dans la première, la seconde ou toutes les
tables jointes.
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
NumProd DesProd Prix QteStock Couleur

100 Ordinateur 100.275 30 R
800 Disquette 125 24
200 Souris 200.450 12 G
102 Tapis 10 10 R
LigneCommande
NumCde NumProd QteCde

C12 100 3
C30 200 20
C67 200 20
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
800 0
200 2
102 0
6. Manipulation des Données à travers les vues

6.1 Définition et intérêts d'une vue
Les vues sont des tables virtuelles issues de l'assemblage d'autres tables en fonction de
critères. Techniquement les vues sont créées à l'aide d'une requête Select. Elles ne stockent
pas les données qu'elles contiennent mais conservent juste la requête permettant de les créer.
La requête Select qui génère la vue référence une ou plusieurs tables. La vue peut donc être,
par exemple, une jointure entre différentes tables, l'agrégation ou l'extraction de certaines
colonnes d'une table. Elle peut également être créée à partir d'une autre vue.
La vue représente de cette façon une sorte d'intermédiaire entre la base de données et
l'utilisateur. Cela représente de nombreuses conséquences :
 une restriction d'accès à la table pour l'utilisateur, c'est-à-dire une sécurité des
données accrue.
 un regroupement d'informations au sein d'une entité
6.2 Création de vues

La création d'une vue se fait grâce à la clause Create View dont la syntaxe est la suivante :
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
 Créer une vue correspondant aux clients de la ville de Tunis.

Create View V
As Select *
From Client
Where Lower (VilleCl) = 'tunis';
Remarque
La structure de la vue créée sera stockée dans le catalogue (dictionnaire de données) et elle
sera vide au début (ne contient pas de données). A chaque requête de consultation, il y aura

exécution de la vue par le système. => Elle nous donne toujours les données à jours de la
base de données.
6.3 Consultation des données d'une vue

Toutes les requêtes possibles sur les tables sont autorisées sur les vues.
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.

6.5 Modification des données d'une vue

Cette modification se fait à l’aide de la commande Update comme pour une table, sauf aussi
si les mêmes conditions de l’insertion sont vérifiées. Elle engendre aussi une modification
des données dans la base de données.
6.6 Suppression de vues

La suppression d'une vue consiste à supprimer du dictionnaire de données la définition
correspondante. Les données rattachées à la vue ne sont pas supprimées.
Drop View Nom_de_la_Vue ;

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.
[4] Oracle : développement de bases de données. Edition la programmeur 1997.
[5] Introduction aux bases de données relationnelles. Ramon A.Mata-Toledo, Pauline

K.Cushman, EdiScience, Dunod, 2002.
[6] Création de bases de données. Nicolas Larrousse, Collection Synthex, Pearson Education,
2006.

Cours BD Version2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours BD Version2022

Transféré par

Droits d'auteur :

Formats disponibles

Année

Support de cours Bases de Données

Chapitre 1 : Introduction aux bases de

©Sonia LOULOU & Sameh CHAABANE 1

2. Exemple de Base de Données

3. Objectifs des Bases de Données

©Sonia LOULOU & Sameh CHAABANE 2

 L’avantage majeur de l’utilisation des bases de données est la possibilité de

4. Caractéristiques des Bases de Données

5. Besoins en Bases de Données

©Sonia LOULOU & Sameh CHAABANE 3

6. Définition de Système de Gestion de Bases de

7. Cycle de vie d’une Base de Données

©Sonia LOULOU & Sameh CHAABANE 4

Chapitre 2 : Modélisation des données

©Sonia LOULOU & Sameh CHAABANE 5

©Sonia LOULOU & Sameh CHAABANE 6

1.2 Les concepts de base

Exemples Etudiant, Commande, Cours, Client.

©Sonia LOULOU & Sameh CHAABANE 7

Exemples Age, Ville, QteCde, Date

Etudiant Cours Employé Employé

Etudiant Etudier Cours

©Sonia LOULOU & Sameh CHAABANE 8

N-M 1-N 1-1

Une occurrence de Client permet de déterminer une ou plusieurs occurrences de Commande

Association de type N-M : Liens maillés

On n'a aucune restriction sur le nombre d'occurrences de Produit et de Commande

Association de type 1-1 :

©Sonia LOULOU & Sameh CHAABANE 9

©Sonia LOULOU & Sameh CHAABANE 10

Commande M Commander N Produit

Remarques Les deux associations fournir et commander sont porteuses de données.

©Sonia LOULOU & Sameh CHAABANE 11

Service 1 Contrôler N Projet

©Sonia LOULOU & Sameh CHAABANE 12

2.2 Concepts de base du modèle relationnel

Produit NumProd DesProd QteStk QteSeuil PrixProd

©Sonia LOULOU & Sameh CHAABANE 13

Exemples Produit (NumProd, DesProd, QteStk, QteSeuil, PrixProd)

Produit (NumProd, DesProd, QteStk, QteSeuil, PrixProd, #NumMag)

2.3 Contraintes d'intégrité

©Sonia LOULOU & Sameh CHAABANE 14

3. Les règles de passage du modèle E/A au modèle

©Sonia LOULOU & Sameh CHAABANE 15

Chapitre 3 : INTRODUCTION AU LANGAGE SQL

©Sonia LOULOU & Sameh CHAABANE 16

©Sonia LOULOU & Sameh CHAABANE 17

2. Emplacement de SQL dans la structuration en couche

Génie Logiciel (Case

Utilitaire (SQL SBA,

Le noyau : il permet la communication avec la base de données et la connexion à d’autres

©Sonia LOULOU & Sameh CHAABANE 18

La couche PL/SQL (Procedure Language extension to SQL) : c’est une extension

3. Les objets du langage SQL

3.1 Les tables

©Sonia LOULOU & Sameh CHAABANE 19

3.3 Les utilisateurs

3.4 Les accélérateurs

4. Le langage de contrôle de données (LCD)

©Sonia LOULOU & Sameh CHAABANE 20

4.1 Création d'utilisateurs

4.2 Attribution des droits