Cours Java PR - Tarik

Université Abdelmalek Essaadi
École Nationale des Sciences Appliquées Al-Hoceima

Site Web : www.ensah.ma
INTRODUCTION AUX
BASES DE DONNEES
Version du 04/01/2022
Préparé par : Pr. Tarik BOUDAA

Département Mathématiques et Informatique
 t.boudaa@uae.ac.ma
Avant-propos
Ce cours a été conçu pour les étudiants débutants de la première année des filières Génie
Informatique et Ingénierie des données de l’Ecole Nationale des Sciences Appliquées d’Al
Hoceima.
Ce document est un support de cours, l'étudiant y trouvera une quantité d'informations
importante lui permettant la plupart du temps de travailler seul.
Il est préparé principalement en utilisant les références citées ci-dessous :
- Laurent Audibert. Bases de données de la modélisation au SQL. Conception des bases
de données, modèle relationnel et algèbre relationnelle, langage SQL, programmation
SQL. Editions Eyrolles.
- Christian Soutou. SQL Pour Oracle. Edition Eyrolles
- Richard Grin. Polycopié du cours. Université de Nice Sophia-Antipolis
- Cyril GRUAU. Polycopié de cours Conception d'une Base de Données
- La documentation officielle d’Oracle :
https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/index.html
Ce document comporte probablement des erreurs : toute suggestion constructive est la

bienvenue à l'adresse t.boudaa@uae.ac.ma.
Table des matières
Avant-propos ......................................................................................................................................... 2
Chapitre 1 : Introduction aux bases de données................................................................................ 7
1. Introduction ................................................................................................................................. 7
2. Qu’est-ce qu’une base de données ? ............................................................................................ 7
2.1. Fichier informatique : .......................................................................................................... 7
2.2. Base de données : ................................................................................................................ 7
2.3. Pourquoi une base de données ? .......................................................................................... 8
2.4. Modèles de base de données................................................................................................ 9
3. Système de gestion de base de données (SGBD) ........................................................................ 9
4. Introduction intuitive à la création des bases de données .......................................................... 10
4.1. Notion de table .................................................................................................................. 10
4.2. Langage SQL (Structured Query Language) .................................................................... 11
4.3. Comment créer les tables réellement dans un SGBD ? ..................................................... 11
Chapitre 2 : Conception d’une base de données ............................................................................... 15
1. Introduction ............................................................................................................................... 15
2. Eléments du modèle Entité/Association (E/A) .......................................................................... 16
2.1. Entité (ou objet) : ............................................................................................................... 16
2.2. type-entité et attributs : ...................................................................................................... 16
2.3. Type de valeur ou domaine d’un attribut........................................................................... 17
2.4. Identifiant ou clé ................................................................................................................ 17
2.5. Association et type-association : ....................................................................................... 17
2.6. Cardinalité d’une association ............................................................................................ 19
2.7. Types d’associations .......................................................................................................... 19
2.8. Règles importantes concernant les éléments du modèle E/A: ........................................... 21
3. Associations plurielles, réflexives et n-aires ............................................................................. 21
3.1. Associations plurielles ....................................................................................................... 21
3.2. Associations réflexives ...................................................................................................... 22
3.3. Associations n-aires ........................................................................................................... 23
4. Notion d’identifiant relatif et d’agrégat ..................................................................................... 26
4.1. Identifiant relatif ................................................................................................................ 26
4.2. Notion d’agrégat : .............................................................................................................. 27
4.3. Décomposition d’une association ternaire :....................................................................... 28
5. Etudes de quelques exemples de ternaires fonctionnellement fausses ...................................... 29
3
Tarik BOUDAA, ENSA Al Hoceima
6. Spécialisation (héritage) ............................................................................................................ 31
Chapitre 3 : Modèle relationnel ......................................................................................................... 32
1. Introduction ............................................................................................................................... 32
2. Éléments du modèle relationnel ................................................................................................ 32
2.1. Attribut et le domaine d’un attribut : ................................................................................. 32
2.2. Relation, schéma de relation, schéma relationnel, et base de données relationnelle ......... 32
2.3. Clé candidate, clé primaire, et clé étrangère ...................................................................... 33
3. Règles de passage du MCD au MLD ........................................................................................ 33
3.1. Règle 1 : Le traitement des entités..................................................................................... 33
3.2. Règle 2 : Association binaire 1,1 ___x,n (avec x=0 ou x =1) ......................................... 33
3.3. Règle 3 : Association binaire 0,1 ____1,1 ......................................................................... 34
3.4. Règle 4 : Association binaire 0,1 -0,1 ............................................................................... 35
3.5. Règle 5 : Association binaire 0,1___x,n (avec x=0 ou x =1) ............................................ 36
3.6. Règle 6 : Association binaire x,n -x,n (avec x=0 ou x=1) ................................................. 36
3.7. Règle 7 : Associations n-aires ........................................................................................... 37
3.8. Règle 8 : Associations réflexives ...................................................................................... 38
3.9. Règle 9 : Cas d’une entité ayant que la clé comme attribut............................................... 38
3.10. Règle 10 : Cas d’un lien identifiant : ............................................................................. 39
3.11. Règle 11 : Cas de l’agrégat :.......................................................................................... 39
3.12. Règle 11 : Cas de la spécialisation (héritage) : .............................................................. 40
4. Normalisation ............................................................................................................................ 41
Chapitre 4 : Création des tables, insertion et modification des données ........................................ 42
1. Langage SQL ............................................................................................................................. 42
2. Création d’une table .................................................................................................................. 42
3. Contraintes d’intégrité : ............................................................................................................. 43
3.1. Définition des contraintes d’intégrité ................................................................................ 43
3.2. Règles relatives aux contraintes ........................................................................................ 44
3.3. Contrainte au niveau colonne : .......................................................................................... 44
3.4. Contrainte au niveau table : ............................................................................................... 45
4. Création une table avec une sous-interrogation......................................................................... 46
5. Casse et commentaires : ............................................................................................................ 46
6. Suppression d’une table avec DROP TABLE : ......................................................................... 46
7. Modifier une table avec ALTER TABLE ................................................................................. 47
7.1. Ajouter, supprimer, désactiver ou renommer une contrainte ............................................ 47
4
7.2. Ajout des colonnes dans une table :................................................................................... 47
7.3. Modifier les colonnes d’une table : ................................................................................... 48
7.4. Supprimer les colonnes d’une table :................................................................................. 48
7.5. Renommer une colonne ..................................................................................................... 48
7.6. Renommer une table .......................................................................................................... 48
8. Type de données Oracle ............................................................................................................ 48
8.1. Type caractères : ................................................................................................................ 48
8.2. Date/Heure......................................................................................................................... 49
8.3. Type numérique ................................................................................................................. 49
9. Insertion d’enregistrements ....................................................................................................... 49
9.1. L’instruction INSERT INTO …VALUES ........................................................................ 49
9.2. Insertion des données par une sélection ............................................................................ 50
10. Modification d’enregistrements............................................................................................. 51
11. Suppression d’enregistrements .............................................................................................. 51
12. Transactions et points de reprise ........................................................................................... 52
Chapitre 5 : Interrogation des données ............................................................................................. 53
1. Syntaxe générale d’une interrogation SQL ............................................................................... 53
1.1. Clause SELECT ................................................................................................................ 53
1.2. Clause FROM .................................................................................................................... 54
1.3. CLAUSE WHERE ............................................................................................................ 54
2. Jointure ...................................................................................................................................... 55
2.1. Jointure naturelle : ............................................................................................................. 56
2.2. Jointures naturelles et la clause WHERE : ........................................................................ 56
2.3. Clause JOIN USING : ....................................................................................................... 56
2.4. Clause ON ......................................................................................................................... 57
2.5. Jointure d'une table avec elle-même .................................................................................. 57
2.6. Jointures impliquant plusieurs tables :............................................................................... 57
2.7. Jointure externes ................................................................................................................ 58
3. CLAUSE ORDER BY .............................................................................................................. 59
4. Utilisation des fonctions prédéfinie ........................................................................................... 60
4.1. Fonctions de groupes : ....................................................................................................... 60
4.2. Clause GROUP BY et HAVING ...................................................................................... 61
4.3. Fonctions monolignes........................................................................................................ 61
5. Opérations ensemblistes ............................................................................................................ 71
5
5.1. Opérateur UNION ............................................................................................................. 71
5.2. Opérateur INTERSECT..................................................................................................... 71
5.3. Opérateur EXCEPT (ou MINUS pour Oracle).................................................................. 72
6. Sous-interrogations .................................................................................................................... 72
6.1. Sous-interrogation à une ligne et une colonne................................................................... 72
6.2. Sous-interrogation ramenant plusieurs lignes.................................................................... 73
6.3. Sous-interrogation synchronisée ....................................................................................... 74
6.4. Sous-interrogation ramenant plusieurs colonnes ............................................................... 74
6.5. Clause EXISTS.................................................................................................................. 75
6.6. Sous-interrogation et valeurs NULL ................................................................................. 75
6
Chapitre 1 : Introduction aux bases
de données
1. Introduction
Aujourd’hui, la disponibilité de systèmes de gestion de base de données fiables permet aux
organisations de toutes tailles de gérer des données efficacement, de déployer des applications utilisant
ces données et de les stocker. Les bases de données sont actuellement au cœur du système d’information
des entreprises.
Les bases de données relationnelles constituent l’objet de ce cours. Ces bases sont conçues suivant
le modèle relationnel, dont les fondations théoriques sont solides, et manipulées en utilisant l’algèbre
relationnelle. Il s’agit, à ce jour, de la méthode la plus courante pour organiser et accéder à des ensembles
de données.
Le présent chapitre a comme objectif d’introduire d’une manière intuitive les notions de base
nécessaires à la création des bases de données sans entrer dans les détails théoriques, qui seront étudiés
dans les chapitres avancés de ce cours.
2. Qu’est-ce qu’une base de données ?

2.1. Fichier informatique :
Un fichier peut être vu au sens commun, comme une collection d'informations numériques réunies
sous un même nom, enregistrées sur un support de stockage permanent, appelé mémoire de masse, tel
qu'un disque dur, un CD-ROM, une mémoire flash ou une bande magnétique.
Techniquement un fichier est une information numérique constituée d'une séquence d'octets, c'est-
à-dire d'une séquence de nombres, permettant des usages divers.
En vue de faciliter leur organisation, les fichiers sont disposés dans des systèmes de fichiers qui
permettent de placer les fichiers dans des emplacements appelés répertoires ou dossiers eux-mêmes
organisés selon le même principe de manière à former une hiérarchie arborescente
2.2. Base de données :

Intuitivement une base de données est un ensemble d’informations, (fichiers), partagé par plusieurs
utilisateurs. Ces informations sont interrogées et mises à jour par l’intermédiaire d’un logiciel.
Exemples :
- L’application e-services de l’ENSAH utilise une base de données pour gérer les
informations des étudiants, les rapports de PFE, les cours, …
- Le catalogue électronique de la bibliothèque de l’ENSAH utilise une base de données pour
gérer les livres, les thèmes, les emprunts,…
Chapitre 1 : Introduction aux bases de données
- Une base de données de gestion de l'activité d'une société de transport, comme la CTM,
pourrait permettre la gestion des réservations, des disponibilités des véhicules en fonction
des voyages à effectuer, des affectations des personnels, …
Plus rigoureusement une base de données est un ensemble structuré de données (1) enregistrées
sur des supports accessibles par l’ordinateur (2) pour satisfaire simultanément plusieurs
utilisateurs (3) de manière sélective (4) en un temps opportun(5).
(1)  Organisation et description de données

(2)  Stockage sur disque
(3)  Partage des données
(4)  Confidentialité
(5)  Performance
2.3. Pourquoi une base de données ?

En d’autres termes, nous allons essayer d’apporter des éléments de réponse à la question :
« Pourquoi dois-je m’embêter avec toute cette théorie et ces connaissances à assimiler sur
les bases de données alors que je sais très bien manipuler un fichier, y stocker des
informations et les y retrouver avec mon langage de programmation favoris ? »
L’utilisation de fichiers classiques pourrait sembler pouvoir apporter une solution au problème de
gestion des données. Mais l’utilisation directe de gros fichiers soulève de gros problèmes :
- Lourdeur d’accès aux données. En pratique, pour chaque accès aux données, même le plus
simple, il faudrait écrire un programme.
- Difficulté de gestion manuelle des fichiers de données.
- Manque de sécurité. Si tout programmeur peut accéder directement aux fichiers, il est
impossible de garantir la sécurité et l’intégrité des données.
- Pas de contrôle de concurrence. Dans un environnement dans lequel plusieurs utilisateurs
accèdent aux mêmes données, des problèmes de concurrence d’accès se posent.
- Problèmes de performance lors d’accès aux gros fichiers de données
- Problèmes de redondance de données : une répétition des données lors de leur insertion
dans les fichiers. Cette redondance est souvent la cause d’anomalies provenant de la
complexité des insertions.
- Incohérence en modification : La redondance de l’information entraîne également des
risques en cas de modification d’une donnée car on oublie fréquemment de modifier toutes
ses occurrences.
- …
Il est donc nécessaire d’avoir recours à un logiciel chargé de gérer les fichiers constituant une base
de données, de prendre en charge les fonctionnalités de protection et de sécurité et de fournir les
différents types d’interfaces nécessaires à l’accès aux données. Ce logiciel très complexe s’appelle le
SGDB, la section suivante est consacrée à la présentation de ce type de logiciel.
8
2.4. Modèles de base de données

Il existe plusieurs modèle pour les bases de données, notamment le modèle objet, objet-relationnel
et le modèle relationnel. Le présent cours ne s’intéresse qu’au modèle relationnel.
Une base de données relationnelle est une base de données structurée suivant les principes de
l’algèbre relationnelle. Le père des bases de données relationnelles est Edgar Frank Codd. Chercheur
chez IBM à la fin des années 1960, il étudiait alors de nouvelles méthodes pour gérer de grandes
quantités de données car les modèles et les logiciels de l’époque ne le satisfaisaient pas. Mathématicien
de formation, il était persuadé qu’il pourrait utiliser des branches spécifiques des mathématiques (la
théorie des ensembles et la logique des prédicats du premier ordre) pour résoudre des difficultés telles
que la redondance des données, l’intégrité des données ou l’indépendance de la structure de la base de
données avec sa mise en œuvre physique. En 1970, Codd (1970) publia un article où il proposait de
stocker des données hétérogènes dans des tables, permettant d’établir des relations entre elles. De nos
jours, ce modèle est extrêmement répandu, mais en 1970, cette idée était considérée comme une curiosité
intellectuelle. On doutait que les tables puissent être jamais gérées de manière efficace par un ordinateur.
Ce scepticisme n’a cependant pas empêché Codd de poursuivre ses recherches. Un premier
prototype de Système de gestion de bases de données relationnelles (SGBDR) a été construit dans les
laboratoires d’IBM. Depuis les années 80, cette technologie a mûri et a été adoptée par l’industrie. En
1987, le langage SQL, qui étend l’algèbre relationnelle, a été standardisé. C’est dans ce type de modèle
que se situe ce cours de base de données.
3. Système de gestion de base de données (SGBD)

L’SGBD (en anglais DBMS pour database management system) est le logiciel qui permet
d’interagir avec une base de données, c’est un Système de Gestion de Base de Données (SGBD). Il
permet à des utilisateurs de créer et maintenir une base de données. Généralement, les activités
supportées sont la définition d'une base de données (spécification des types de données à stocker), la
construction d'une base de données (stockage des données proprement dites) et la manipulation des
données (principalement ajouter, supprimer, retrouver les données).
Figure 1
Plus précisément, les systèmes de gestion de bases de données (SGBD) sont des programmes
permettant à l’utilisateur de créer et de gérer des bases de données. Les SGBD sont des logiciels à usage
général qui assurent les processus de définition, de construction, de manipulation et de partage des bases
de données par et entre les différents utilisateurs et applications.
Exemples de SGBD :
 Oracle est un SGBD relationnel (et relationnel-objet dans ses dernières versions) très
reconnu pour les applications professionnelles.
9
 PostgreSQL est un SGBD relationnel et relationnel-objet très puissant qui offre une
alternative open source aux solutions commerciales comme Oracle ou IBM.
 MySQL est un SGBD relationnel libre (licence GPL et commerciale), simple d'accès et très
utilisé pour la réalisation de sites Web dynamiques.
 Access est un SGBD relationnel Microsoft, qui offre une interface graphique permettant de
concevoir rapidement des applications de petite envergure ou de réaliser des prototypes.
La définition d’une base de données implique une spécification des types de données, des structures
et des contraintes. La construction d’une base de données consiste à enregistrer les données proprement
dites sur un support de stockage contrôlé par le SGBD. La manipulation de la base consiste notamment
à l’interroger afin d’en extraire des informations, à l’actualiser en fonction des modifications du
microcosme considéré et à générer des rapports. Le partage d’une base de données permet à différents
utilisateurs et applications d’y accéder simultanément.
Les SGBD assurent d’autres fonctions importantes, notamment la protection de la base de données
et son entretien à long terme. La protection implique à la fois la protection du système contre les pannes
logicielles et matérielles et la protection sécuritaire contre les accès illicites ou malveillants. Une grande
base de données peut être utilisée de nombreuses années. Le SGBD doit donc être capable d’entretenir
et de faire évoluer ses propres structures dans la durée.
La complexité d’un SGBD tient essentiellement à la diversité des techniques mises en œuvre, à la
multiplicité des composants intervenant dans son architecture, et aux différents types d’utilisateurs
(administrateurs, programmeurs, utilisateurs non informaticiens, ...) qui sont confrontés, à différents
niveaux, au système.
4. Introduction intuitive à la création des bases de données

Cette section de cours a pour objectif de présenter les bases de données d’une manière intuitive et
pragmatique pour permettre à l’étudiant de découvrir d’une manière simple les notions de bases
manipulées dans les bases de données, avant de passer aux formalismes théoriques solides qui
permettent de construire une base de données d’une manière rigoureuse.
4.1. Notion de table

Les bases de données relationnelles utilisent les tables pour enregistrer les données, sous la forme
d'un tableau. Dans ce tableau, les colonnes sont appelées des champs, et les lignes sont appelées des
entrées.
Une table est donc représentée sous la forme d'un tableau ; par exemple, le tableau suivant vous
montre à quoi peut ressembler le contenu d'une table appelée « Etudiants ».
Nom Prénom CNE CIN Age
BOUDAA Tarik 2220121120 R111222 30
EL OUALIDI Mhamed 1120121120 S111222 22
El MORABIT Hanae 1220121120 J111222 21
Chaque champ a un type de données, par exemple les champs Nom, Prénom et CIN sont de type
chaîne de caractères et la colonne Age et CNE peuvent être considérés de type numérique.
Une base de données peut être vue comme un ensemble de table :
10
Figure 2
Pour donner un exemple concret, voici quelques noms de tables que l'on peut être amené à créer
pour les besoins d’une base de données d’un simple site web :
- News_Tab : stocke toutes les actualités qui sont affichées sur le site ;
- Forum_Tab : stocke tous les messages postés sur le forum ;
- Newsletter_Tab : stocke les adresses e-mail de tous les visiteurs inscrits à la newsletter.
4.2. Langage SQL (Structured Query Language)

SQL (sigle de Structured Query Language, en français langage de requête structurée) est un langage
informatique normalisé servant à exploiter des bases de données relationnelles. La partie langage de
manipulation des données de SQL permet de rechercher, d'ajouter, de modifier ou de supprimer des
données dans les bases de données relationnelles.
Outre le langage de manipulation des données, la partie langage de définition des données permet
de créer et de modifier l'organisation des données dans la base de données, la partie langage de contrôle
de transaction permet de commencer et de terminer des transactions, et la partie langage de contrôle des
données permet d'autoriser ou d'interdire l'accès à certaines données à certaines personnes.
Créé en 1974, normalisé depuis 1986, le langage est reconnu par la grande majorité des systèmes de
gestion de bases de données relationnelles du marché.
Le langage SQL sera étudié en détails dans les chapitres avancés de ce cours.
4.3. Comment créer les tables réellement dans un SGBD ?

Pour créer les tables dans un SGBD on utilise le langage SQL, dans cette partie de cours nous
s’intéressons juste à la création de quelques tables simples et à la consultation des données avec des
instructions simples en SQL.
La syntaxe générale pour créer une table est la suivante :
CREATE TABLE nom_de_la_table (
colonne1 type_données,
……
colonneN type_données
)
11
Dans l’ordre SQL précédent, N colonnes ont été définies. Le mot-clé « type_données » sera à
remplacer par un mot-clé pour définir le type de données (INT, DATE, TEXT …). Pour chaque colonne,
il est également possible de définir des options telles que (liste non-exhaustive) :
 NOT NULL : empêche d’enregistrer une valeur nulle pour une colonne.
 DEFAULT : attribuer une valeur par défaut si aucune donnée n’est indiquée pour cette
colonne lors de l’ajout d’une ligne dans la table.
 PRIMARY KEY : indiquer si cette colonne est considérée comme clé primaire pour un
index.
L’utilisation la plus courante de SQL consiste à lire des données issues de la base de données. Cela
s’effectue grâce à la commande SELECT, qui retourne des enregistrements dans un tableau de résultat.
L’utilisation basique de cette commande s’effectue de la manière suivante:
SELECT nom_du_champ1, nom_du_champ2, … , nom_du_champN

FROM nom_du_tableau
Cette requête SQL va sélectionner (SELECT) les champs nom_du_champ1, nom_du_champ2, …

et nom_du_champN provenant (FROM) du tableau appelé « nom_du_tableau ».
Il est possible de retourner automatiquement toutes les colonnes d’un tableau sans avoir à connaître
le nom de toutes les colonnes. Au lieu de lister toutes les colonnes, il faut simplement utiliser le caractère
« * » C’est un joker qui permet de sélectionner toutes les colonnes. Il s’utilise de la manière suivante:
SELECT * FROM nom_du_tableau
Exemple 1 :
Nous voulons ajouter sur le site de l’ENSAH un livre d’or. Un livre d'or est un endroit où les visiteurs
inscrivent des remarques sur ce qu'ils pensent du site.
Un commentaire est composé d'un pseudo, d’un nom, d’un email, d'un message et d'une date. On
considère que toutes ces informations sont obligatoires pour un commentaire.
Question :
a. Donner la structure des tables dont aura besoin le développeur du site pour ajouter un livre
d’or.
b. Ecrire le code SQL permettant de créer ces tables
c. Ecrire le code SQL qui va permettre d’afficher tous les commentaires des visiteurs
Réponses :
Puisque un commentaire est composé d'un pseudo, d’un nom, d’un email, d'un message et d'une
date. Nous aurons besoin d’une seule table ayant la structure ci-dessous :
pseudo nom email message date
12
Nous pouvons choisir, par exemple, comme nom pour cette table « Ensah_Commentaire ».
Ainsi le code SQL pour créer cette table peut être les suivant :
CREATE TABLE Ensah_Commentaire (
pseudo varchar(52) NOT NULL,

nom varchar(52) NOT NULL,
email varchar(52) NOT NULL,
message text NOT NULL,
date DATETIME NOT NULL,
)
Pour afficher tous les commentaires il suffira d’utiliser une requête SQL :
SELECT * FROM Ensah_Commentaire
Exemple 2 :
Une société de construction automobile désire informatiser sa gestion.
- Pour chaque véhicule, on connait le code d’identification, le poids, le nombre de cylindres.
- De nombreux exemplaires de chaque véhicule sont fabriqués. Pour chacun d’entre eux, on
connait la couleur, le numéro de série et l’année de fabrication.
On demande de fournir la structure des tables de la base de données.
Réponses :
Nous pouvons envisager initialement une table pour y stocker les véhicules et une autre pour stocker
les exemplaires, avec les structures décrite ci-dessous :
La table Vehicule_Tab :
id_vehicule Code_identification poids Nombre_cyclindres
1 101201010 300 16
2 529901880 200 8
La table Exemplaire_Vehicule_Tab :
id_ exemplaire couleur num_serie annee_fabrication
1 rouge 01251455114875 2011
2 noir 99999488114811 2012
Le problème avec les choix effectués précédent est qu’il n y a aucune relation entre un exemplaire
et le véhicule. Par exemple, nous nous ne pouvons pas savoir pour un exemplaire quel est son poids, ou
son nombre de cylindres.
13
La solution est d’ajouter une autre colonne dans la table Exemplaire_Vehicule_Tab qui stocke
l’identifiant du véhicule.
id_exemplaire couleur num_serie annee_fabrication vehicule
1 rouge 01251455114875 2011 1
2 noir 99999488114811 2012 2
id_vehicule Code_identification poids Nombre_cyclindres
1 101201010 300 16
2 529901880 200 8
Ainsi pour chaque exemplaire nous pouvons connaitre son véhicule et ainsi connaitre son poids et
son nombre de cylindres.
Nous allons voir un peu plus loin dans ce cours que ce type de colonne s’appelle une clé étrangère.
Exemple 3 :
Supposons maintenant que nous devons créer une base de données d’une grande entreprise de
transport, nous serons amenées par exemple à gérer, entre autres, les choses suivantes : Gestion du
personnel, Gestion des congés et des absences du personnel, Gestion des compétences du personnel,
Gestion véhicules, Gestion de la maintenance, Gestion de voyages, Gestion des réservations, gestion
des réclamations, Gestion financière de l’entreprise…
Essayons d’imaginer maintenant la structure de tous les tables nécessaires pour une telle base de
données en utilisant l’approche simpliste utilisée dans les deux exemples précédents.
Nous pouvons déduire rapidement que cette approche ne pourra pas aboutir facilement et
efficacement à la définition des structures de toutes les tables nécessaires. C’est pour cette raison qu’il
faut une phase de conception et de modélisation avec un modèle plus proche du monde réel avant de
faire le passage à la structure des tables compréhensibles par le SGBD.
Le chapitre suivant est consacré à l’étude du modèle conceptuel permettant d’aboutir à une
conception rigoureuse du modèle de données avant de passer à l’implémentation réelle de la base de
données sous un SGBD.
14
Chapitre 2 : Conception d’une base
de données
1. Introduction
Comme nous l’avons constaté dans l’introduction de ce cours, 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, le modèle entités-associations constitue l’une des premières et des plus
courantes. Ce modèle, permet une description naturelle du monde réel à partir des concepts d’entité et
d’association1. Basé sur la théorie des ensembles et des relations, ce modèle se veut universel et répond
à l’objectif d’indépendance données-programmes. Ce modèle, utilisé pour la phase de conception,
s’inscrit notamment dans le cadre d’une méthode plus générale et très répandue : Merise (Méthode
d’Étude et de Réalisation Informatique pour les Systèmes d’Entreprise).
Merise propose une démarche, dite par niveaux, dans laquelle il s’agit de hiérarchiser les
préoccupations de modélisation qui sont de trois ordres : la conception, l’organisation et la technique.
En effet, pour aborder la modélisation d’un système, il convient de l’analyser en premier lieu de façon
globale et de se concentrer sur sa fonction : c’est-à-dire de s’interroger sur ce qu’il fait avant de définir
comment il le fait. Ces niveaux de modélisation sont organisés dans une double approche
données/traitements. Les trois niveaux de représentation des données, puisque ce sont eux qui nous
intéressent, sont détaillés ci-dessous.
- Niveau conceptuel : le modèle conceptuel des données (MCD) décrit les entités du monde
réel, en termes d’objets, de propriétés et de relations, indépendamment de toute technique
d’organisation et d’implantation des données. Ce modèle se concrétise par un schéma
entités-associations représentant la structure du système d’information, du point de vue des
données.
- Niveau logique : le modèle logique des données (MLD) précise le modèle conceptuel par
des choix organisationnels. Il s’agit d’une transcription (également appelée dérivation) du
MCD dans un formalisme adapté à une implémentation ultérieure, au niveau physique, sous
forme de base de données relationnelle ou réseau, ou autres (cf. section 1.1.2). Les choix
techniques d’implémentation (choix d’un SGBD) ne seront effectués qu’au niveau suivant.
- Niveau physique : le modèle physique des données (MPD) permet d’établir la manière
concrète dont le système sera mis en place (SGBD retenu).
Dans ce cours nous ne nous intéressons à la méthode Merise que dans la perspective de conception d’une
base de données.
Le schéma ci-dessous résume les différentes étapes qui conduisent à l’implémentation d’une base
de données.
Chapitre 2 : Conception d’une base de données
2. Eléments du modèle Entité/Association (E/A)

La représentation du modèle entités-associations s’appuie sur trois concepts de base :
2.1. Entité (ou objet) :

Une entité est un objet, une chose concrète ou abstraite qui peut être reconnue distinctement et qui est
caractérisée par son unicité.
Exemples d’entité :
« Allal El Kadous », Le Cinéma « Mégarama », Le livre « Modélisation des systèmes d’information »,
« Mohamed Bastaoui », le film « Casanegra », «Ecole Nationale des Sciences Appliquées d’Al-
Hoceima » …
2.2. type-entité et attributs :

Un type-entité (ou Classe d’entité) désigne un ensemble d’entités de même nature (qui possèdent les
mêmes propriétés). Les caractéristiques associées à un type-entité sont nommées attributs (ou
propriétés)
Une entité est une valeur particulière d’un type-entité. Une entité est souvent nommée occurrence ou
instance de son type-entité.
Au niveau du type-entité ou du type-association, chaque attribut possède un domaine qui définit
l’ensemble des valeurs possibles qui peuvent être choisies pour lui (entier, chaîne de caractères, booléen,
. . .). Au niveau de l’entité, chaque attribut possède une valeur compatible avec son domaine.
Représentation graphique d’un type-entité :
16
Nom_Type_Entité
attribut 1
attribut 2
…
attribut n
Exemples de type-entité :
Personne, Cinéma, Livre, Acteur, Film, Ecole, etc.
Les attributs du type-entité Personne peuvent êtres par exemples : nom, prénom, date de naissance,
email, …
Exemple de représentation graphique du type-entité Personne :
Personne
nom
prénom
âge
télé
2.3. Type de valeur ou domaine d’un attribut

Le type de valeur ou le domaine d’un attribut est la spécification de toutes les valeurs possibles que peut
prendre un attribut. Au niveau de l’entité, chaque attribut possède une valeur compatible avec son
domaine
Exemples :
- Le type ou domaine de l’attribut « nom » est « chaîne de caractères »

- Le type ou domaine de l’attribut « âge » est un entier
2.4. Identifiant ou clé

Un identifiant (ou clé) d’un type-entité ou d’un type-association est constitué par un ou plusieurs de ses
attributs qui doivent avoir une valeur unique pour chaque entité ou association de ce type.
Exemple :
Le type entité Etudiant peut avoir comme identifiant le CNE. L’identifiant est souligné et se place en
première position dans la liste des attributs :
Etudiant
cne
nom
prénom
âge
télé
2.5. Association et type-association :

Une association (ou une relation) est un lien entre plusieurs entités.
17
Un type-association (ou un type-relation) désigne un ensemble de relations qui possèdent les mêmes
caractéristiques. Le type-association décrit un lien entre plusieurs type-entités. Les associations de ce
type-association lient des entités de ces type-entités.
Une association est souvent nommée occurrence ou instance de son type-association.
Les type-entités intervenant dans un type-association sont appelés les participants de ce type-association.
Exemples :
Un exemple d’association peut être l’achat de l’étudiant Mahmoud un exemplaire du livre «Conception
des bases de données».
Des instances du type-association « Acheter »
Conception des bases de données

Mahmoud KARABILA Oracle Application Web
Majd CHAMI Web 2.0
Mohamed El MAROUANI Java efficace
Naoual MAMOUNI Traitement du signal numérique
Apprentissage automatique
Des instances du type-entité Etudiant Des instances du type-entité Livre
Dans ce cas le type-association pourra être l’achat d’un livre sur un site e-commerce.
La figure suivante montre la représentation graphique d’un exemple de type-association :
Etudiant Livre
nom titre
prénom Acheter
auteur
âge thème
télé
Les type-associations peuvent avoir des attributs comme dans l’exemple présenté par la figure ci-
dessous :
Etudiant
nom Acheter Livre

prénom titre
âge Date d’achat
auteur
télé thème
18
2.6. Cardinalité d’une association

La cardinalité d’une patte reliant un type-association et un type entité précise le nombre de fois minimal
et maximal d’interventions d’une entité du type-entité dans une association du type-association. La
cardinalité minimale doit être inférieure ou égale à la cardinalité maximale.
Exemples :
- Une personne peut être l’auteur de 0 à n livre, mais un livre ne peut être écrit que par une
personne.
- Un étudiant peut emprunter de 0 à n livre, et un livre pourra être emprunté par 0 ou plusieurs
étudiants à des dates différentes.
Cardinalités
Etudiant Livre
nom 0,n Emprunter 0,n titre
prénom auteur
âge Date emprunt
thème
télé
2.7. Types d’associations

2.7.1. Association 1 vers 1
C’est une association ne comportant que des cardinalités maximales de 1sur chacune de ses pattes. Ce
type d’association est binaire (ne peut pas lier plus de deux entités).
2.7.2. Association 1 vers n
Est une association comportant une cardinalité maximale 1 et une cardinalité maximale n. Ce type
d’association est également binaire.
2.7.3. Association n vers n
Est une association ne comportant que des cardinalités maximales de n sur chacune de ses pattes. Ce
type d’association n’est pas forcement binaire.
En principe seule l’association n vers n qui peut avoir des propriétés (attributs) . Dans ce cas on dit qu’il
s’agit d’une association porteuse d’information.
2.7.4. Identifiant d’un type-association
- L’identifiant d’un type-association n vers n est formé par les identifiants des entités qu’il relie.
- L’identifiant d’un type-association 1 vers n est formé par l’identifiant du type-entité participante
ayant la cardinalité maximale 1.
- L’association 1 vers 1 possède deux identifiants candidats issues des deux entités participantes.
Il suffit de choisir un parmi les deux.
- Les identifiants des types-association sont implicites (non indiqués sur l’association).
19
Exemples 1 : association n:n
Imaginons que l’on veuille connaître la quantité d’articles commandés par des clients, nous nous rendons
compte qu’il faut utiliser une nouvelle propriété Quantité. Cette nouvelle propriété dépend de clients,
d’articles ou des deux ? La bonne réponse est que Quantité dépend des deux entités.
Client
Article
Numéro_Client 1,n
Commander 0,n
Nom Numéro_Article
Quantité
prénom Désignation
Code_Postal prix
Ville
Nous pouvons interpréter ce schéma de la façon suivante : Le client X a commandé la quantité Y
d’articles Z. La figure ci-dessous illustre cette situation :
1 Mahmoud KARABILA Quantité=1 1 article1

2 Majd CHAMI 2 article2
3 Mohamed El MAROUANI Quantité=2 3 article3
4 Naoual MAMOUNI 4 article4
Quantité=5
Exemple 2 : fausse modélisation avec l’association n :n

L’exemple ci-dessous traite un cas d’une fausse modélisation avec l’association n :n
Etudiant
Livre
CNE 0,n Emprunter 0,n
Nom ISBN
Prénom dateEmprunt Titre
Age DateRetour Auteur
Ville
Comme nous pouvons voir sur la figure suivante la modélisation précédente ne permet pas d’avoir deux
emprunts à des dates différentes (car l’association à un identifiant implicite formé par le couple
(cne,isbn) ) ce qu’est en contradiction avec les règles de gestion des bibliothèques :
Impossible
!
1 Mahmoud KARABILA dateEmprunt=12/12/2014 5 article1

3 Mohamed El MAROUANI dateEmprunt=10/01/2015 7 article3
20
2.8. Règles importantes concernant les éléments du modèle E/A:

Règle 1 :
Un attribut est une donnée élémentaire, ce qui exclut des données calculées ou dérivées. Autrement
dit, les propriétés résultantes d’un calcul ne doivent pas apparaître dans le modèle conceptuel des
données.
Règle 2 :
Un type-entité et ses attributs doivent être cohérents entre eux (i.e. ne traiter que d’un seul sujet).
Par exemple, si le modèle doit comporter des informations relatives à des livres et à leurs
emprunteurs, ces informations ne doivent pas coexister au sein d’un même type-entité.
Règle 3 :
Chaque type-entité possède au moins un identifiant, éventuellement formé de plusieurs attributs.

Dans la représentation graphique, les attributs qui constituent l’identifiant sont soulignés et placés
en tête.
Toutes les propriétés de l’entité dépendent fonctionnellement de l’identifiant. C’est-à-dire que
connaissant la valeur de l’identifiant, nous connaissons de façon sûre et unique la valeur des
propriétés associées. Si nous recherchons le client numéro 5, nous devons récupérer le nom et le
prénom du client numéro 5 et pas ceux d’une autre personne.
Règle 4 :
Un attribut peut être placé dans un type-association uniquement lorsqu’il dépend de toutes les
entités liées par le type-association
Règle 5 :
L’expression de la cardinalité est obligatoire pour chaque patte d’un type-association.

Les seuls cardinalités admises sont : 0,1 0,n 1,1 1,n n,n
Règle 6 :
Le nom d’une propriété ne doit apparaître qu’une seule fois dans le modèle conceptuel des données.
Si nous établissons une entité Clients et une nommée Prospects, nous ne devons pas retrouver la
propriété Nom dans les deux entités. Il faut préférer la dénomination suivante Nom_client et
Nom_prospect.
3. Associations plurielles, réflexives et n-aires

3.1. Associations plurielles
La figure ci-dessous montre un exemple d’associations plurielles entre un type-entité Personne et
un type-entité Livre.
21
0,1
0,n Livre
Personne Ecrire
titre
idPersonne
auteur
nom
thème
prénom
Emprunter prix
âge
télé 0,n 0,1
La figure ci-dessous montre un exemple d’instance du modèle :
Conception des bases de données

Mahmoud KARABILA
Emprunter
Oracle Application Web
Majd CHAMI Web 2.0
Mohamed El MAROUANI Emprunter Java efficace
Naoual MAMOUNI Traitement du signal numérique
Ecrire Apprentissage automatique
Emprunter
3.2. Associations réflexives

Un type-association est réflexif s’il définit une relation entre un type-entité et lui-même.
Exemple 1 :
0,n
Personne
idPersonne
nom Etre frère
prénom
âge
télé 0,n
Exemple 2 :
Si la relation n’est pas symétrique il faut préciser les rôles sur les pates du type-association.
22
parent
Personne
idPersonne 0,n
nom Etre parent
prénom enfant
âge
0,n
télé
Exemple 3 :
0,n
Employé
idEmployé
nom Diriger
prénom
âge
télé 1,1
3.3. Associations n-aires

Ce type d’association met en relation n type-entités. Même s’il n’y a, en principe, pas de limite sur le
nombre de type-entités liés par ce type-association, dans la pratique on ne va rarement au-delà de trois.
Les associations de degré supérieur à deux sont plus difficiles à manipuler et à interpréter, notamment
au niveau des cardinalités. Si n= 3 on parle d’association ternaires.
Exemple :
Client
Article
NUM_Client 0,n
1,n Commander Num_Article
Nom
Date_Achat
Prénom quantité
Prix
1,n
Date
Date
23
Ci-dessous un exemple d’instance de ce modèle
Quantité=1 Quantité=3
1 Mahmoud KARABILA 9 article1

3 Mohamed El MAROUANI 11 article3
Date
12/01/2015
Date
12/12/2014
Validation d’un type-association ternaire :
On considère le modèle ci-dessous d’un type association ternaire :
Association ternaire valide si « les trois pattes sont à n », ce qui peut s’exprimer également par les règles
suivantes :
où signifie : b ne dépend pas fonctionnellement de a. (Autrement dit : la connaissance de a

ne permet pas de déterminer b)
24
Exemple :
En principe donc, valider cette association ternaire, c’est d’abord vérifier :
- qu’un chantier n’est pas forcément réalisé par une seule entreprise :
NoChantier NoEntreprise
- qu’une entreprise ne réalise pas forcément qu’un seul chantier :
NoEntreprise NoChantier
- qu’il n’y a pas forcément qu’un seul type de travail par chantier :
NoChantier CodeType
- qu’il n’y a pas forcément qu’un seul chantier par type de travail :
CodeType NoChantier
- qu’une entreprise n’est pas forcément spécialisée dans un seul type de travail :
NoEntreprise CodeType
- qu’un type de travail n’est pas forcément confié qu’à une seule entreprise :
CodeType NoEntreprise
- qu’une entreprise ne réalise pas forcément qu’un seul chantier par type de travail :
NoEntreprise, CodeType NoChantier
- qu’une entreprise ne réalise pas forcément qu’un seul type de travail par chantier :
NoEntreprise, NoChantier CodeType
- qu’un type de travail à réaliser pour un chantier n’est pas forcément confié qu’à une seule
entreprise : CodeType, NoChantier NoEntreprise
Bien entendu, ce type de validation est grandement facilité lorsque l’association « porte » une propriété
Dans ce cas l’association ternaire valide si :
(Dépendance fonctionnelle élémentaire)

NoA, NoB, NoC prop
25
(C’est-à-dire le triplet NoA, NoB, NoC permet de terminer prop mais aucun sous ensemble de ce triplet
ne permet de déterminer prop)
Les dépendances fonctionnelles seront étudiées en détail dans le chapitre suivant.
4. Notion d’identifiant relatif et d’agrégat

4.1. Identifiant relatif
Certaines entités ont une existence totalement dépendante d’autres entités. Dans ce cas nous avons
recours à un identifiant relatif.
Un identifiant est qualifié de relatif s’il comporte au moins un attribut lié à un autre type-entité
Exemple 1 :
Nous devons gérer les exemplaires des livres dans une bibliothèque :
Ouvrage
Exemplaire
NUM_ISBN 1,n Posséder (1,1) Num_Exemplaire
Titre
Date_Achat
Nom Auteur
Prix
Prénom Auteur
Nous pouvons considérer qu’une bibliothèque achète plusieurs exemplaires du même livre (6 000
exemplaires). Doit-elle numéroter les exemplaires dans l’ordre séquentiel croisant c’est-à-dire de 1 à 6
000 ou pour chaque ouvrage de 1 au nombre maximal de cet ouvrage présent dans la bibliothèque ?
Il paraît évident que la solution la plus judicieuse est la seconde proposition. Ainsi, la clé d’identification
de l’exemplaire sera la concaténation du Num ISBN et du Num Exemplaire. L’identification d’un
identifiant relatif se traduit par le symbole (R) à côté de la cardinalité ou par les parenthèses sur la
cardinalité : (1,1 )
Pour reconnaître un identifiant relatif, nous pouvons aussi nous poser la question « si je supprime
l’ouvrage X de ma bibliothèque, dois-je supprimer tous les exemplaires ? ». La réponse est bien entendu
oui. Nous pouvons donc dire que l’existence même de l’entité Exemplaire dépend de l’existence de
l’entité Ouvrage (L’entité Exemplaire est dite entité faible).
Une entité faible est une entité dont les occurrences ne peuvent exister que si les occurrences d'une autre
entité existent (contrainte d'identification).
Ainsi, l’identification relative (appelée aussi agrégation) permet de spécifier qu'une entité est nécessaire
pour en identifier une autre. Le type-entité permettant d'identifier est appelée type-entité agrégeant, le
type-entité identifié est appelé type-entité agrégé.
Exemple 2 :
Immeuble
Appartement
idImmeuble 0,n Comporter (1,1)
nomImmeuble numéroApprt
surface
26
Ce modèle permet que plusieurs appartements possèdent le même numéro puisque l’identifiant du type-
entité Appartement n’est plus numéroApprt, mais le couple (nomImmeuble , numéroApprt)
Remarque :
Les identifiants implicites des types associations sont des exemples d’identifiants relatifs.
Règles concernant le lien identifiant :
Un type-entité concerné par au moins deux liens identifiants peut très bien ne pas comporter d’attribut
souligné.
La cardinalité d’un lien identifiant est forcement 1,1 . Pour préciser qu’il s’agit d’un lien identifiant il
faut mettre cette cardinalité entre parenthèses : (1,1) ou utiliser le symbole (R) à côté de la cardinalité.
L’identifiant relatif n’as pas de présentation particulière mais il est reconnaissable par la présence d’un
lien identifiant
4.2. Notion d’agrégat :

L'agrégat, aussi appelé pseudo-entité, est un groupe d'entités qui est associé avec une autre entité.
Un agrégat permet de modéliser une situation où un type-association est à l’origine d’un lien vers un
type-entité.
L’agrégat se présente par un rectangle sur la pseudo-entité (voir exemple).
Exemple :
Situation : Dans l’entreprise X, les représentants vendent des produits dans différentes régions. Mais un
produit pour une région donnée n’est vendu que par un seul représentant.
Le modèle suivant a été proposé pour modéliser la situation précédente
Une instance de l’association vendre peut se présenter ainsi :
27
Analysons ce MCD en posant les questions suivantes :
1) D’après les règles de gestion de l’énoncé, est-il possible que le représentant 3 vende le produit 2
dans la région 5 ?
2) D’après le MCD, le représentant 3 peut vendre le produit 2 dans la région 5 ?
Réponses :
1- NON car un produit pour une région donnée ne peut être vendu que par un seul représentant, or
le couple Région/Produit (5,2) est assuré par le représentant 2
2- Rien ne s’y oppose conceptuellement parlant, car l’identifiant de l’association vendre est le
triplet (N°Rep, N°Region, N° produit) or ( 3, 5, 2) est différent de (2,5,2) alors il n y a aucun
problème.
Conclusion :
Le MCD précédent ne traduit pas correctement la réalité, il faut recourir à la notion d’agrégat qui permet
d’associer une entité à un couple d’entités (associer un représentant à un couple région/produit) :
4.3. Décomposition d’une association ternaire :

Les deux modèles ci-dessous sont équivalents
28
Exemple :
5. Etudes de quelques exemples de ternaires fonctionnellement fausses
Exemple 1 :
29
Illustration :
On suppose que toute entreprise est spécialisée dans un type de travail. Et on considère la modélisation
suivante :
Puisque quel que soit le chantier, le type de travail effectué par une entreprise donnée est le même, alors
NoEntreprise détermine fonctionnellement CodeType. Ainsi les règles d’une bonne ternaire vues
précédemment ne sont pas respectées. Un modèle cohérent peut être le suivant :
Exemple 2 :
30
Illustration :
Si on suppose que « Par chantier, un type de travail est confié à une seule entreprise » le modèle ci-
dessous ne présente pas une bonne ternaire, puisque la connaissance du chantier et du type de travail
détermine l’entreprise.
Un modèle cohérent peut être le suivant :
6. Spécialisation (héritage)
Les occurrences d’un type-entité se caractérisent toutes par un ensemble de propriétés communes.
Cependant, il arrive des cas où les occurrences se distinguent par des propriétés utiles aux unes mais pas
aux autres, ou des associations spécifiques aux unes mais pas aux autres.
Par exemple, si nous modélisions les étudiants et les professeurs par un même type entité « Personne »
nous allons constater qu’ils auront des propriétés en commun comme le nom, prénom, cin,… mais ils
auront des propriétés différentes comme le code national de l’étudiant qu’est propre à un étudiant et le
code PPR qu’est propre aux professeurs. Egalement l’étudiant appartient à une classe, ce qui traduit
donc une association spécifique de l’étudiant avec un autre type-entité « Classe ».
Dans ce contexte on peut utiliser la spécialisation, ainsi, on décompose l'entité Personne en deux "sous-
entités" en plaçant les propriétés communes (nom, prénom) dans une entité générale ou générique
(Personne) et les propriétés spécifiques aux sous-ensembles dans des entités spécialisées ou spécifiques
(les sous-entités Prof et Etudiant par exemple).
Les entités spécifiques héritent de l'identifiant de l'entité générique et de ses propriétés. Il s’agit d’une
association de type hiérarchique de généralisation/spécialisation.
Prof
Personne
Classe code_PPR
ID
code_CNE nom Etudiant
prenom
code_CNE
Appartenir
31
Chapitre 3 : Modèle relationnel
1. Introduction
Dans ce modèle, les données sont représentées par des tables, sans spécification sur la façon dont
les informations sont stockées réellement dans la machine. Les tables constituent donc la structure
logique du modèle relationnel. Au niveau physique, le système est libre d’utiliser n’importe quelle
technique de stockage (fichiers séquentiels, indexage, adressage dispersé, séries de pointeurs,
compression, . . .) dès lors qu’il est possible de relier ces structures à des tables au niveau logique.
Les tables ne représentent donc qu’une abstraction de l’enregistrement physique des données en
mémoire.
De façon informelle, on peut définir le modèle relationnel de la manière suivante :
- les données sont organisées sous forme de tables à deux dimensions, encore appelées relations,
dont les lignes sont appelées n-uplet ou tuple en anglais ;
- les données sont manipulées par des opérateurs de l’algèbre relationnelle ;
- l’état cohérent de la base est défini par un ensemble de contraintes d’intégrité
Ce chapitre couvre les éléments suivants :

- Définition des éléments du modèle relationnel
- Règles de passage du modèle conceptuel de données au modèle relationnel
- Normalisation
- Opérateurs d’algèbre relationnel
2. Éléments du modèle relationnel

2.1. Attribut et le domaine d’un attribut :
Un attribut est un identificateur (un nom) décrivant une information stockée dans une base.
Le domaine d’un attribut est l’ensemble, fini ou infini, de ses valeurs possibles.
2.2. Relation, schéma de relation, schéma relationnel, et base de données relationnelle

Une relation est un sous-ensemble du produit cartésien de n domaines d’attributs (n > 0).
Une relation est représentée sous la forme d’un tableau à deux dimensions dans lequel les n attributs
correspondent aux titres des n colonnes.
Un schéma de relation précise le nom de la relation ainsi que la liste des attributs avec leurs
domaines.
Le tableau ci-dessous montre un exemple de relation et précise son schéma :
CNE Nom Prénom
2520104101 Rabah Amina
2320102222 Karabila Mahmoud
2420104444 Faik Jalal
Une occurrence, ou n-uplets, ou tuples, est une ligne du tableau qui représente la relation
Un schéma relationnel est constitué par l’ensemble des schémas de relation.
Une base de données relationnelle est constituée par l’ensemble des n-uplets des différentes
relations du schéma relationnel.
2.3. Clé candidate, clé primaire, et clé étrangère

Une clé candidate d’une relation est un ensemble minimal des attributs de la relation dont les
valeurs identifient d’une manière sûre une occurrence. La valeur d’une clé candidate est donc distincte
pour toutes les tuples de la relation.
Toute relation a au moins une clé candidate et peut en avoir plusieurs. Ainsi, il ne peut jamais y
avoir deux tuples identiques au sein d’une relation. Les clés candidates d’une relation n’ont pas
forcément le même nombre d’attributs. Une clé candidate peut être formée d’un attribut arbitraire, utilisé
à cette seule fin.
La clé primaire d’une relation est une de ses clés candidates. Pour signaler la clé primaire, ses
attributs sont généralement soulignés.
Une clé étrangère dans une relation est formée d’un ou plusieurs attributs qui constituent une clé
primaire dans une autre relation.
3. Règles de passage du MCD au MLD

3.1. Règle 1 : Le traitement des entités
- Chaque entité du MCD est transformée en table

- Les propriétés de l'entité deviennent les attributs de la table
- L'identifiant de l'entité devient clé primaire
3.2. Règle 2 : Association binaire 1,1 ___x,n (avec x=0 ou x =1)
Entité 2
Entité 1
IdEntite1 x,n association

1,1 IdEntite2
Entité1(IdEntité1, Att1_1, Att2_1)
Att1_1 Att1_2
Entité2(IdEntité2, Att1_2, Att2_2, #IdEntité1)
Att2_1 Att2_2
Avec x=0 ou x=1
Exemple :
Equipe Responsable
IdEquipe 1,1 Diriger 1,n IdResponsable

nom_equipe nom_responsable
33
Responsable (IdResponsable, nom_responsable)

Equipe (IdEquipe, nom_equipe, #idResponsable)
3.3. Règle 3 : Association binaire 0,1 ____1,1

Cette association correspond à une paire de cardinalité 1,1 et 0,1. Dans ce cas, il y a plusieurs
solutions.
Première solution :
Entité 2
Entité 1
IdEntite1 0,1 association

1,1
IdEntite2
Entité1 (IdEntité1, Att1_1, Att2_1)
Att1_1 Att1_2
Entité2(IdEntité2, Att1_2, Att2_2, #IdEntité1)
Att2_1 Att2_2
Deuxième solution :
Une autre solution à proscrire est l'échange des clés primaires entre les 2 entités, ce qui donnerait :
Entité 2
Entité 1
IdEntite1 0,1 association 1,1 IdEntite2

Entité1 (IdEntité1, Att1_1, Att2_1, #IdEntité2)
Att1_1 Att1_2
Att2_2 Entité2(IdEntité2, Att1_2, Att2_2, #IdEntité1)
Att2_1
Exemple 1 : Première solution
PC(numPC, marque_pc)
CD_ROM CD_ROM(numCD, marque_cd, #numPC)
PC
0,1
Avoir numCD
numPC 1,1
marque_pc Marque_cd
Deuxième solution
PC(numPC, marque_pc, #numCD)

CD_ROM(numCD, marque_cd, #numPC)
Dans ce cas la meilleure solution est que la table CD_ROM reçoit comme clé étrangère NumPC. Car un
CD_Rom est affecté à un et un seul PC. Dans la deuxième solution, un PC pouvant ne pas avoir de
CD_Rom, la clé étrangère numCD peut être nulle, ce qu'il faut éviter au maximum (On évite
généralement au maximum qu’une clé étrangère soit nulle).
34
Exemple 2 :
Citoyen
IdCitoyen 0,1 Etre 1,1 Candidat

nom IdCandidat
prénom Parti
Nous allons opter pour la solution 1 car elle permet d’éviter des valeurs nulles pour les clés étrangères,
et elle est suffisante pour matérialiser la relation entre les deux types-entités Citoyen et Candidat :
Citoyen(IdCitoyen, nom,prénom)
Candidat(IdCandidat, Parti, #IdCitoyen)
Dans la relation Candidat, l’attribut IdCitoyen, en plus d’être une clé étrangère, constitue une clé
candidate. On peut donc se passer de la clé IdCandidat.
Une amélioration du schéma relationnel précédent peut donc se présenter ainsi :
Citoyen(IdCitoyen, nom,prénom)
Candidat(#IdCitoyen, Parti)
où IdCitoyen, en plus d’être la clé de la relation Candidat, est une clé étrangère de la relation Citoyen.
3.4. Règle 4 : Association binaire 0,1 -0,1
Entité 2
Entité 1
IdEntite1 0,1 Association IdEntite2
0,1
Att1_2 Entité2(IdEntité2, Att1_2, Att2_2)
Att1_1
Att2_2 Association(#IdEntité1, #IdEntité2)
Att2_1
Exemple :
CD_ROM
PC
PC(numPC, marque_pc)
numPC 0,1 Avoir 0,1 numCD CD_ROM(numCD, marque_cd)
marque_pc Marque_cd
PC_CD (#numCD, #numPC)
35
3.5. Règle 5 : Association binaire 0,1___x,n (avec x=0 ou x =1)
Première solution :
La première solution assimile la cardinalité 0,1 à une cardinalité 1,1 et donc il y a migration de la clé
primaire de la table côté 1,n vers la table côté 0,1 ce qui laisse la possibilité d'une valeur nulle pour la
clé étrangère.
Deuxième solution :
La deuxième condition consiste à créer une table intermédiaire avec une clé primaire composée.
Si la deuxième solution est la meilleure, la première est souvent mise en œuvre dans la mesure où
le cas d’une cardinalité 0 est rare et correspond généralement à une phase transitoire. C'est pour cela que
la solution à 2 tables reste majoritairement utilisée pour des raisons d'allégement du modèle relationnel.
Exemple :
Equipe Responsable
IdEquipe 0,1 Diriger 1,n IdResponsable

Cet exemple illustre le fait qu'une équipe est dirigée par un responsable mais qu'elle peut n'être
dirigée par personne.
Avec la première solution :
Equipe (IdEquipe, nom_equipe, #idResponsable)
Avec la deuxième solution :

Equipe (IdEquipe, nom_equipe,)
Direction (#idEquipe, #idResponsable)
En fait, sur l'exemple ci-dessus, est-il possible qu'une équipe ne soit dirigée par personne ? Oui en
cas de démission du responsable, mais cela est rare et transitoire, d'où la préférence de la première
solution pour ne pas alourdir le modèle relationnel.
3.6. Règle 6 : Association binaire x,n -x,n (avec x=0 ou x=1)

Ce cas regroupe toutes les associations où la cardinalité maximale de part et d'autre est à n, la
cardinalité minimale pouvant être 0 ou 1. Dans ce cas, la règle est simple et consiste à la création d'une
table issue de l'association, cette table recevant comme clé étrangère les clés primaires des 2 autres
tables. La clé primaire de cette table résultant de l'association étant la composition des deux clés
étrangères.
36
Entité 1 Entité 2
IdEntite1 x,n Association x,n IdEntite2
Att1_1 Att1_2
attribut1 Att2_2 Association(#IdEntité1, #IdEntité2,attribut1,
Att2_1
attribut2, …, attribut2,…,attributN)
attributN
Avec x = 0 ou x = 1
Exemple :
Equipe Responsable
IdEquipe 1,n Diriger 1,n IdResponsable

date

Equipe (IdEquipe, nom_equipe,)
Direction (#idEquipe, #idResponsable, date)
3.7. Règle 7 : Associations n-aires

Le traitement de ce type d'association est en fait une généralisation du cas précédent.
La table issue de l'association est composée des identifiants de toutes les entités participant à
l'association comme clé étrangère et comme clé primaire composée. Les propriétés portées par
l'association devenant des attributs de cette table.
Entité 1
Entité 2
IdEntite2 IdEntite1 Entité1(IdEntité1, Att1_1, Att2_1)

Att1_2 Att1_1 Entité2(IdEntité2, Att1_2, Att2_2)
x,n
x,n Att2_1
Att2_2
x,n …
Association Entité N (IdEntitéN, Att1_n, Att2_n)
Attribut_1,…,Attri Association(#IdEntité1,#IdEntité2,…,#IdEntitéN,
but_N attribut_1,..., Attribut_N)
Entité N
IdEntiteN
x,n
x,n Att1_n
Att2_n
Entité 3
IdEntite3
Att1_3
Att2_3
....
37
3.8. Règle 8 : Associations réflexives
Ces associations sont en en fait des associations binaires, leur traitement dépend donc des cardinalités
et elles peuvent donc être traitées par les règles citées précédemment.
Dans le cas des relations réflexives une même propriété va se retrouver deux fois dans la même
relation. Il faut alors donner un nom différent et significatif aux deux attributs correspondants. On a déjà
signalé dans ce cours qu’il faut nommer les branches par des rôles pour pouvoir lire dans le bon sens
l'association. Les rôles aident à nommer les attributs correspondant à l'association.
Exemple 1:
Traduction en modèle relationnel :

PERSONNE (Num_Personne, Nom_Personne)
EPOUSER (#Num_Mari, #Num_Femme, Date_Mariage)
Exemple 2 :
Dans une entreprise, chaque salarié a un seul chef (supérieur hiérarchique direct) sauf le patron, et
chaque chef a au moins un salarié sous ses ordres. Evidemment, certains salariés ne sont chefs de
personnes.

SALARIE(matricule, nom, prénom, fonction,… , #matricule_chef)
3.9. Règle 9 : Cas d’une entité ayant que la clé comme attribut
Les entités n'ayant que leur identifiant comme attribut ne deviennent pas des relations, mais des
attributs dans les autres relations liées.
38
Exemple
Avec ce modèle, on mémorise chaque jour pour chaque ouvrier les pièces qu'il a fabriqué et en
quelle quantité. Quand on passe au modèle relationnel, l'entité DATE FABRICATION ne devient pas
une relation, mais un attribut clé dans la relation FABRIQUE issue de l'association.
FABRIQUE(#code_ouvrier, #référence_pièce, date, quantité).
Fait partie de la clé primaire,

mais n'est pas clé étrangère
3.10. Règle 10 : Cas d’un lien identifiant :
Immeuble
Appartement
Comporter (1,1)
idImmeuble 0,n numéroApprt
nomImmeuble
surface

Appartement (numéroApprt, #idImmeuble, surface)
BATIMENT(idImmeuble, nomImmeuble )
3.11. Règle 11 : Cas de l’agrégat :

On considère l’exemple déjà étudié dans le chapitre précédent :
39
Traduction dans le modèle relationnel :

REGION (N° Region, LibRegion )
PRODUIT (N° Produit, LibelleProduit, PrixProduit )
REPRESENTANT (N° Rep, NomRep )
COUVRIR (N° Region, N° Produit, #N° Rep )
3.12. Règle 11 : Cas de la spécialisation (héritage) :

Il existe plusieurs stratégies pour la traduction de l’héritage, chacune ayant des inconvénients et
des avantages selon les situations. On se limite dans ce cours à un sous-ensemble de ces stratégies.
On considère le MCD suivant :
Personne
ID
nom
adresse
Etudiant Cadre
code_CNE code_PPR
Première solution : Conserver uniquement la super-entité

Personne (ID, nom, adresse, code_CNE, code_PPR, type)
Avec « type » un attribut qui permet de déterminer le type de personne ( 'Etudiant', 'Cadre' ou autre).
Cette solution est utilisable lorsque les spécialisations ne sont pas réellement utilisées.
Elle présente l’inconvénient d’avoir des valeurs null dans les attributs des types entité spéciales (les
entités filles) surtout si les spécialisations ont beaucoup d’attributs ou elles ont des associations
propres avec d’autres types entité.
40
Deuxième solution : Conserver uniquement les spécialisations

Etudiant (ID, nom, adresse, code_CNE)
Cadre (ID, nom, adresse, code_PPR)
Utilisable lorsque la super-entité n’est pas utilisée et elle n’a pas d’associations propres
(Généralisation/spécialisation totale et disjointe).
Troisième solution : Conserver toutes les entités

Choix 1 : utiliser des clés étrangères au niveau des spécialisations
Personne (ID, nom, adresse)

Etudiant (#ID_ETUDIANT, code_CNE)
Cadre (#ID_CADRE, code_PPR)
Avec ID_ CADRE et ID_ETUDIANT deux clés étrangères qui référencent la table Personne.
L’inconvénient de cette stratégie est que pour avoir une information sur une spécialisation (par
exemple le nom d’un étudiant) il faut passer par une jointure avec la table Personne.
Choix 2 : Dupliquer le schéma

Personne (ID, nom, adresse)
Etudiant (#ID_ETUDIANT, nom, adresse , code_CNE)
Cadre (#ID_CADRE, nom, adresse, code_PPR)
Avec ID_ CADRE et ID_ETUDIANT deux clés étrangères qui référencent la table Personne.
L’inconvénient de cette stratégie est que l’information est redondante, et la cohérence est plus
difficile à maintenir.
4. Normalisation
En cours de rédaction
41
Chapitre 4 : Création des tables,
insertion et modification des données
1. Langage SQL
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.
Créé en 1974, normalisé depuis 1986, le langage est reconnu par la grande majorité des systèmes de
gestion de bases de données relationnelles du marché.
Le tableau ci-dessous décrit les différentes instructions SQL classées par catégorie.
Langage de manipulation de données (LMD) SELECT

INSERT
UPDATE
DELETE
MERGE
Langage de définition de données (LDD) CREATE
ALTER
DROP
RENAME
TRUNCATE
COMMENT
Contrôle des transactions COMMIT
ROLLBACK
SAVEPOINT
Langage de contrôle de données (LCD) GRANT
REVOKE
2. Création d’une table

La syntaxe générale de la création des tables se présente comme suivant :
CREATE TABLE [schéma.]nomTable
colonne1 type1 [DEFAULT valeur1] [NOT NULL]
[, colonne2 type2 [DEFAULT valeur2] [NOT NULL] ]
[CONSTRAINT nomContrainte1 typeContrainte1]…
) ;
Chapitre 5 : Interrogation des données
Exemple :
CREATE TABLE tp1db.Compagnie

(
comp CHAR(4),
nrue NUMBER(3),
rue CHAR(20),
ville CHAR(15) DEFAULT 'Al-Hoceima',
nomComp CHAR(15) NOT NULL
);
3. Contraintes d’intégrité :
3.1. Définition des contraintes d’intégrité
Il y a quatre types de contraintes possibles :
- La contrainte UNIQUE impose une valeur distincte au niveau de la table (les valeurs nulles font
exception à moins que NOT NULL soit aussi appliquée sur les colonnes).
CONSTRAINT nomContrainte UNIQUE (colonne1 [,colonne2]…)
- La contrainte PRIMARY KEY déclare la clé primaire de la table. Les colonnes clés primaires ne
peuvent être ni nulles ni identiques.
CONSTRAINT nomContrainte PRIMARY KEY (colonne1 [,colonne2]…)
- La contrainte FOREIGN KEY déclare une clé étrangère entre une table enfant (child) et une table
père (parent). La directive ON DELETE dispose de deux options : CASCADE propagera la
suppression de tous les enregistrements fils rattachés à l’enregistrement père supprimé, SET NULL
positionnera seulement leur clé étrangère à NULL.
CONSTRAINT nomContrainte FOREIGN KEY (colonne1 [,colonne2]…)
REFERENCES [schéma.]nomTablePere (colonne1 [,colonne2]…)
[ON DELETE { CASCADE | SET NULL }]
- La contrainte CHECK impose un domaine de valeurs ou une condition simple ou complexe entre
colonnes :
CONSTRAINT nomContrainte CHECK (condition)
(Exemple : CHECK (note BETWEEN 0 AND 20), CHECK (grade='Ingénieur d’Etat' OR

grade='Ingénieur Principal')).
43
3.2. Règles relatives aux contraintes

- Vous pouvez nommer une contrainte, ou le serveur Oracle génère un nom automatiquement.
- Vous pouvez créer une contrainte à différents instants :
 Lors de la création de la table
 Après la création de la table
- Vous pouvez afficher une contrainte via le dictionnaire de données.
- Il y a deux façons pour définir une contrainte : au niveau colonne ou au niveau table (plus
générale).
3.3. Contrainte au niveau colonne :

Dans ce cas la contrainte est définie directement après la définition de la colonne
La définition des contraintes au niveau colonnes est à utiliser si la contrainte concerne une seule
colonne (celle sur laquelle on définit la contrainte).
Pour définir une contrainte au niveau colonne on utilise la syntaxe suivante :
nom_colonne [CONSTRAINT nom_contrainte] type_contrainte,
Exemple 1:
CREATE TABLE employees(
employee_id NUMBER(6) CONSTRAINT emp_emp_id_pk PRIMARY KEY,
first_name VARCHAR2(20),
);
Exemple 2

employee_id NUMBER(6) CONSTRAINT emp_employee_id PRIMARY KEY,
first_name VARCHAR2(20) ,
last_name VARCHAR2(25) CONSTRAINT emp_last_name_nn NOT NULL,
email VARCHAR2(25)
CONSTRAINT emp_email_nn NOT NULL
CONSTRAINT emp_email_uk UNIQUE,
phone_number VARCHAR2(20),
hire_date DATE CONSTRAINT emp_hire_date_nn NOT NULL,
job_id VARCHAR2(10) CONSTRAINT emp_job_nn NOT NULL,
salary NUMBER(8,2) CONSTRAINT emp_salary_ck CHECK (salary>0),
commission_pct NUMBER(2,2) ,
manager_id NUMBER(6) ,
comp_id CHAR(4) CONSTRAINT emp_comp_fk REFERENCES
companie (comp)
);
44
3.4. Contrainte au niveau table :

Les contraintes au niveau table permettent de définir des contraintes qui font intervenir plusieurs
colonnes. Ainsi, nous ne pouvons pas par exemple utiliser ce type de contrainte pour rendre le couple
(nom, prénom) comme UNIQUE car ici il s'agit d'une contrainte portant sur plusieurs colonnes.
Pour définir une contrainte au niveau table on utilise la syntaxe suivante :
CREATE TABLE nom_table (
nom_colonne1,.., nom_colonneN,
[CONSTRAINT nom_contrainte] type_contrainte (nom_colonne, ...),
Exemple 1:
employee_id NUMBER(6),
first_name VARCHAR2(20),
...
job_id VARCHAR2(10) NOT NULL,
CONSTRAINT emp_emp_id_pk PRIMARY KEY (EMPLOYEE_ID)
);
Exemple 2:
CREATE TABLE Compagnie(
comp CHAR(4),
nrue NUMBER(3),
rue CHAR(20),
ville CHAR(15) DEFAULT 'Paris',
nomComp CHAR(15) NOT NULL,
CONSTRAINT pk_Compagnie PRIMARY KEY(comp)
);
Exemple 3:
CREATE TABLE Pilote(
brevet CHAR(6),
nom CHAR(15),
nbHVol NUMBER(7,2),
compa CHAR(4),
CONSTRAINT pk_Pilote PRIMARY KEY(brevet),
CONSTRAINT nn_nom CHECK (nom IS NOT NULL),
CONSTRAINT ck_nbHVol CHECK (nbHVol BETWEEN 0 AND 20000),
CONSTRAINT un_nom UNIQUE (nom),
CONSTRAINT fk_Pil_compa_Comp FOREIGN KEY (compa)
REFERENCES Compagnie(comp)
);
Remarque :
 Nous pouvons afficher les différentes contraintes appliquées sur une table par :
SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME='nom_table';
45
Par exemple :
SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME='EMPLOYEES'
 Nous pouvons ajouter des contraintes après la création de la table avec l’instruction ALTER
TABLE (voir la suite de ce cours).
4. Création une table avec une sous-interrogation
CREATE TABLE nom_table
[(colonne1, colonne2...)]
AS sous_interogation;
Exemple :
CREATE TABLE Department90
AS
SELECT employee_id, last_name, salary*12 ANNSAL, hire_date
FROM employees
WHERE department_id = 90;
L'exemple de la diapositive ci-dessus crée une table nommée Department90, qui contient les
détails de tous les employés qui travaillent dans le département 90. Notez que les données de la table
Department90 proviennent de la table employees.
Prenez soin d'indiquer un alias de colonne lorsque vous sélectionnez une expression. L'alias
ANNSAL est affecté à l'expression SALARY*12. (Un alias dans ce cas est obligatoire)
5. Casse et commentaires :
Dans toute instruction SQL (déclaration, manipulation, interrogation et contrôle des données), il est
possible d’inclure des retours chariots, des tabulations, espaces et commentaires (sur une ligne
précédée de deux tirets --, sur plusieurs lignes entre /* et */).
De même, la casse n’a pas d’importance au niveau des mots-clés de SQL, des noms de tables,
colonnes, index, etc.
6. Suppression d’une table avec DROP TABLE :

Pour supprimer une table, la syntaxe à utiliser est la suivante :
DROP TABLE nom_table;
Il est impossible de supprimer une table si la table est référencée par une contrainte d'intégrité
référentielle. Une variante Oracle de la commande permet de supprimer les contraintes d'intégrité et
la table :
DROP TABLE nom_table CASCADE CONSTRAINTS
46
7. Modifier une table avec ALTER TABLE

On utilise l'instruction ALTER TABLE pour :
 Ajouter une colonne
 Modifier une colonne existante
 Définir une valeur par défaut pour la nouvelle colonne
 Supprimer une colonne
 Modifier/Supprimer/Ajouter/Désactiver/Activer une contrainte
7.1. Ajouter, supprimer, désactiver ou renommer une contrainte
ALTER TABLE nom_table
DROP CONSTRAINT nom_contrainte
ADD CONSTRAINT nom_contrainte définition_de_la_contrainte
RENAME CONSTRAINT nom_contrainte1 TO nom_contrainte2
MODIFY CONSTRAINT nom_contrainte la_modification
ALTER TABLE EMP

-- Suppression d’une contrainte
DROP CONSTRAINT NOM_UNIQUE
-- Ajout d’une contrainte
ADD CONSTRAINT SAL_MIN CHECK(SAL + NVL(COMM,0) > 1000)
-- Renommer une contrainte
RENAME CONSTRAINT NOM1 TO NOM2
-- Modification d’une contrainte
MODIFY CONSTRAINT SAL_MIN DISABLE
7.2. Ajout des colonnes dans une table :
ADD (col1 type1, col2 type2, ...)
Exemples
ALTER TABLE personne

ADD (
email_valide char(1)
constraint personne_email_valide check(email_valide in ('o', 'n'))
)
47
7.3. Modifier les colonnes d’une table :

Changer le type des colonnes :
MODIFY (col1 type1, col2 type2, ...)
col1, col2... sont les noms des colonnes que l'on veut modifier. type1, type2,... sont les nouveaux types
que l'on désire attribuer aux colonnes.
7.4. Supprimer les colonnes d’une table :
DROP COLUMN col
7.5. Renommer une colonne
RENAME COLUMN ancien_nom TO nouveau_nom
7.6. Renommer une table
ALTER TABLE ancien_nom_table
RENAME TO nouveau_nom_table;
8. Type de données Oracle

On note que ces types de données diffèrent des types du Standard SQL 2
8.1. Type caractères :
48
8.2. Date/Heure
8.3. Type numérique
9. Insertion d’enregistrements
9.1. L’instruction INSERT INTO …VALUES
INSERT INTO [schéma.]nom_table
[(colonne1, colonne2…)]
VALUES (valeur1 | DEFAULT, valeur2 | DEFAULT…);
Exemples
On considère la table Compagnie suivante :
CREATE TABLE Compagnie(

comp CHAR(4),
nrue NUMBER(3),
rue CHAR(20),
ville CHAR(15) DEFAULT 'Paris',
nomComp CHAR(15) NOT NULL,
CONSTRAINT pk_Compagnie PRIMARY KEY(comp)
);
49
- Dans cet exemple, toutes les valeurs sont renseignées dans l’ordre de la structure de la table.
INSERT INTO Compagnie VALUES ('SING', 7, 'Camparols',

'Singapour', 'Singapore AL');
- Dans cet exemple on a utilisé un DEFAULT explicite.
INSERT INTO Compagnie

VALUES ('AC', 124, 'Port Royal', DEFAULT,'Air France');
- Dans cet exemple on a utilisé un NULL explicite
INSERT INTO Compagnie

VALUES ('AN1', NULL, 'Hoche', 'Blagnac','Air France');
- Dans cet exemple on a utilisé un DEFAULT implicite
INSERT INTO Compagnie(comp, nrue, rue, nomComp)

VALUES ('AF', 8, 'Champs Elysées', 'Castanet Air');
- Dans cet exemple on a utilisé un NULL sur nrue implicite
INSERT INTO Compagnie(comp, rue, ville, nomComp)

VALUES ('AN2', 'Foch', 'Blagnac', 'Air Nul2');
- On considère la table Pilote définie ci-dessous.
CREATE TABLE Pilote

(
brevet VARCHAR(6),
nom VARCHAR(20),
dateNaiss DATE,
nbHVol NUMBER(7,2),
dateEmbauche DATE,
compa VARCHAR(4),
CONSTRAINT pk_Pilote PRIMARY KEY(brevet)
);
Dans l’exemple suivant, l’insertion du pilote initialise la date de naissance au 5 février 1965 (à
zéro heure, zéro minute et zéro seconde), ainsi que la date d’embauche à la date (heures, minutes,
secondes) du moment par la fonction SYSDATE.
INSERT INTO Pilote

VALUES ('PL-10', 'Christian Soutou', '05-02-1965', 900,
SYSDATE,'AF');
9.2. Insertion des données par une sélection

On peut utiliser également cette syntaxe pour insérer des données par une sélection
INSERT INTO nom_table (col1,..., coln ) SELECT ...
50
Exemple :
Enregistrer la participation de HAMID au groupe de projet numéro 11 :
INSERT INTO Praticipation (ID_ETUDIANT, CODE_PROJ)

SELECT ID_ETUDIANT, 11 FROM ETUDIANT
WHERE NOME = 'HAMID'
10. Modification d’enregistrements
UPDATE nom_table
SET col1 = exp1, col2 = exp2, ...
WHERE condition
Ou avec une sélection
UPDATE nom_table
SET (col1, col2,...) = (SELECT ...)
WHERE condition
Exemples :
a- Faire passer HMIDA dans le projet numéro 22 :

UPDATE Employee SET ID_PROJET = 22
WHERE NOM = 'HMIDA'
b- Augmenter de 20 % les salaires des commerciaux :
UPDATE Employee
SET SAL = SAL * 0.2+ SAL
WHERE POSTE = 'COMMERCIAL'
c- Donner à RAHMA un salaire de 20 % au-dessus de la moyenne des salaires des
secrétaires :
UPDATE Employee
SET SAL = (SELECT AVG(SAL) * 1.20 FROM Employee
WHERE POSTE = 'SECRETAIRE') WHERE NOM = 'RAHMA'
d- Enlever la commission de SIMO :
UPDATE Employee
SET COMM = NULL
WHERE NOM = 'SIMO'
11. Suppression d’enregistrements

L'ordre DELETE permet de supprimer des lignes d'une table.
DELETE FROM nom_table WHERE condition

Exemple :
DELETE FROM ETUDIANT WHERE nom like 'HAL%';
51
12. Transactions et points de reprise

Une transaction forme un ensemble indivisible d’opérations sur la base de données : il faut effectuer ces
opérations entièrement ou pas du tout, sous peine de laisser la base dans un état incohérent.
Une transaction est terminée :
 soit par une validation qui persiste les modifications,

 soit par une annulation qui remet la base dans son état initial.
Par exemple, une transaction peut transférer une somme d'argent entre deux comptes d'un client d'une
banque. Elle comporte deux ordres : un débit sur un compte et un crédit sur un autre compte. Si un
problème empêche le crédit, le débit doit être annulé.
Dans la norme SQL, une transaction commence au début d'une session de travail ou juste après la fin de
la transaction précédente. Elle se termine par un ordre explicite de validation (commit) ou d'annulation
(rollback).
L'utilisateur peut à tout moment valider (et terminer) la transaction en cours par la commande COMMIT.
Les modifications deviennent alors définitives et visibles à toutes les autres transactions.
L'utilisateur peut annuler (et terminer) la transaction en cours par la commande ROLLBACK. Toutes les
modifications depuis le début de la transaction seront annulées.
On peut désigner des points de reprise dans une transaction :
SAVEPOINT nomPoint
On peut ensuite annuler toutes les modifications effectuées depuis un point de reprise s'il y a eu des
problèmes :
ROLLBACK TO nomPoint
On évite ainsi d'annuler toute la transaction et on peut essayer de pallier le problème au lieu d'annuler la
transaction globale.
52
Ce chapitre présente les techniques d’interrogation des données avec le langage SQL.
Les exemples de code SQL donnée dans cette partie, portent sur le modèle logique présenté ci-dessous :
1. Syntaxe générale d’une interrogation SQL

SELECT ...
FROM ...
WHERE ...
GROUP BY ...
HAVING ...
ORDER BY ...
1.1. Clause SELECT

Cette clause permet d'indiquer quelles colonnes (ou expressions), doivent être sélectionnées par
l'interrogation.
SELECT [DISTINCT] *
ou
SELECT [DISTINCT] exp1 [[AS] nom1 ], exp2 [[AS] nom2 ], .....
exp1, exp2, ... sont des expressions, nom1, nom2, ... sont des noms facultatifs (alias). Chacun de ces
noms est inséré derrière l'expression, séparé de cette dernière par un espace ou par le mot clé AS
(optionnel) ; ils constitueront le titre de la colonne dans l'affichage du résultat de la sélection. Ces noms
ne peuvent pas être utilisés dans les autres clauses (dans la clause where par exemple).
Le mot clé DISTINCT est utilisé pour éliminer les doublons du résultat de l’interrogation.
Exemples :
SELECT * FROM Departement;

SELECT DISTINCT idposte FROM Employe;
SELECT nomemp, salaire + NVL(commission,0) AS Salaire_Total FROM

Employe;
La requête suivante va provoquer une erreur car on utilise le nom Salaire_Total dans la clause where :
SELECT nomemp, salaire + NVL(commission,0) Salaire_Total FROM Employe

WHERE Salaire_Total > 1000
 La fonction prédéfinie NVL (exp1, exp2) permet de remplacer les valeurs null par une chaîne dans
les résultats d'une requête. Si expr1 est null, alors NVL renvoie expr2. Si expr1 n'est pas nul, alors
NVL renvoie expr1.
1.2. Clause FROM

La clause FROM donne la liste des tables participant à l'interrogation. Il est possible de lancer des
interrogations utilisant plusieurs tables à la fois.
FROM table1 [synonyme1 ] , table2 [synonyme2 ] , ...
synonyme1, synonyme2,... sont des synonymes attribués facultativement aux tables (alias de tables). On
utilise cette possibilité pour lever certaines ambiguïtés, quand la même table est utilisée de plusieurs
façons différentes dans une même interrogation.
1.3. CLAUSE WHERE
WHERE expression_logique
Une expression logique simple est la comparaison de deux expressions ou plus au moyen d’opérateurs
logiques :
WHERE exp1 = exp2

WHERE exp1 != exp2
WHERE exp1 < exp2
WHERE exp1 > exp2
WHERE exp1 <= exp2
WHERE exp1 >= exp2
WHERE exp1 BETWEEN exp2 AND exp3
WHERE exp1 LIKE exp2
WHERE exp1 NOT LIKE exp2
WHERE exp1 IN (exp2, exp3,...)
WHERE exp1 NOT IN (exp2, exp3,...)
WHERE exp IS NULL
WHERE exp IS NOT NULL
Opérateurs logiques :
Les opérateurs logiques AND et OR peuvent être utilisés pour combiner plusieurs expressions logiques.
54
L'opérateur NOT placé devant une expression logique inverse son sens.
Exemples
Sélectionner les noms des employés du département 40 ayant un salaire inférieur à 2100 DH.
SELECT nomemp FROM Employe

WHERE dep = 40 AND salaire < 2100
Afficher la liste des noms des employés du département 40 ou 30 dont le salaire est supérieur à 20000
DH et les noms des employés qui ne touchent pas de commission.

WHERE ( (dep =40 OR dep=30 )AND salaire > 20000) OR commission IS
NULL;
2. Jointure
On utilise les jointures pour obtenir des données de plusieurs tables. On distingue entre jointure interne
et externe.
La syntaxe générale d’une jointure est la suivante :
SELECT table1.column, table2.column

FROM table1
[NATURAL JOIN table2] |
[JOIN table2 USING (column_name)] |
[JOIN table2
ON (table1.column_name = table2.column_name)]|
[LEFT|RIGHT|FULL OUTER JOIN table2
ON (table1.column_name = table2.column_name)]|
[CROSS JOIN table2];
Exemples :
Liste des employés avec le nom du département où ils travaillent :
Avec une jointure interne :
SELECT nomemp, nomdep

FROM Employe e JOIN Departement d ON ( e.dep = d.iddep )
Par opposition aux jointures externes, on peut ajouter le mot clé INNER (facultatif) :

FROM Employe e INNER JOIN Departement d ON (e.dep = d.iddep)
La jointure peut aussi être traduite par la clause WHERE : (Cette façon de faire est encore très souvent
utilisée)

FROM Employe e, Departement d
WHERE e.dep = d.iddep
55
2.1. Jointure naturelle :

On peut joindre des tables automatiquement en fonction des colonnes des deux tables dont les types de
données et les noms correspondent. Pour cela il faut utiliser les mots-clés NATURAL JOIN.
Exemple :
Liste des départements et les villes dans ils se trouvent :
SELECT iddep, nomdep, idville, nomville

FROM Departement
NATURAL JOIN Ville;
Remarques :
- La table Ville est jointe à la table Departement par la colonne idville, qui est la seule colonne portant
le même nom dans les deux tables. Si d'autres colonnes communes avaient été présentes, la jointure
les aurait toutes utilisées.
- La jointure naturelle ne peut être effectuée que sur les colonnes qui présentent le même nom et le
même type de données dans les deux tables. Si les colonnes présentent le même nom mais des types
de données différents, la syntaxe NATURAL JOIN provoque une erreur.
- Si on utilise une jointure naturelle, il est interdit de préfixer une colonne utilisée pour la jointure par
un nom de table. La requête suivante provoque une erreur :
SELECT iddep, nomdep, Ville.idville, nomville

FROM Departement
NATURAL JOIN Ville;
2.2. Jointures naturelles et la clause WHERE :

On peut ajouter des restrictions à une jointure en utilisant la clause WHERE. L'exemple qui suit limite
les lignes du résultat à celles dont l'ID de département est égal à 55 ou à 50 :
SELECT iddep, nomdep, idville, nomville

FROM departments
NATURAL JOIN Ville
WHERE iddep IN (55, 50);
2.3. Clause JOIN USING :

Pour obtenir une jointure naturelle sur une partie seulement des colonnes qui ont le même nom, on peut
utiliser la clause JOIN USING (s'il y a plusieurs colonnes, le séparateur de colonnes est la virgule).
SELECT nomdep, nomville

FROM Departement JOIN Ville USING (idville)
Pour différencier les noms de colonne présents dans plusieurs tables on utilise des préfixes qui précisent
le nom de la table.
L'utilisation de préfixes désignant la table améliore les performances et améliore la lisibilité des
interrogations.
Il ne faut pas utiliser d'alias sur les colonnes identifiées dans la clause USING et indiquées ailleurs dans
l'instruction SQL.
56
Exemple :
SELECT d.nomdep, v.nomville, idville

FROM Departement d JOIN Ville v USING (idville)
2.4. Clause ON
Dans le cas général ON pour exprimer une jointure. (Par exemple, si les colonnes de jointure n’ont pas
le même nom ou la condition de jointure n’est pas une égalité).
Exemple :
SELECT e.idemp, e.nomemp, e.dep, d.iddep, d.idville

FROM Employe e JOIN Departement d
ON (e.dep = d.iddep);
Cas d’une Jointure « non équi » :

Les jointures autres que les équi-jointures peuvent être représentées en remplaçant dans la clause ON
ou la clause WHERE le signe « = » par un des opérateurs de comparaison ( < <= > >=), ou encore
BETWEEN et IN.
Exemple :
Liste des employés, avec tous les employés qui gagnent plus :
SELECT emp.nomemp, emp.salaire, empplus.nomemp, empplus.salaire FROM

Employe e
JOIN Employe eplus ON (e.salaire < eplus.salaire) ORDER BY e.salaire
2.5. Jointure d'une table avec elle-même

Il peut être utile de rassembler des informations venant d'une ligne d'une table avec des informations
venant d'une autre ligne de la même table. Dans ce cas il faut renommer au moins l'une des deux tables
en lui donnant un alias, afin de pouvoir préfixer sans ambiguïté chaque nom de colonne.
Exemple
Lister les employés qui ont un supérieur, en indiquant pour chacun le nom de son supérieur :
SELECT e.nomemp "Employé" , s.nomemp "Supérieur"

FROM Employe e
JOIN Employe s on (e.sup = s.idemp)
Ou avec une jointure avec le mot clé WHERE :
SELECT e.nomemp "Employé" , s.nomemp "Supérieur"

FROM Employe e, Employe s
WHERE e.sup = s.idemp
2.6. Jointures impliquant plusieurs tables :

Une jointure peut impliquer plusieurs tables. Exemple :
SELECT idemp, nomville, nomdep

FROM Employe e
57
JOIN Departement d
ON (d.iddep = e.dep )
JOIN Ville v
ON (d.idville = v.idville);
Dans ce cas les jointures sont effectuées de gauche à droite. La première jointure réalisée est donc
Employe JOIN Departement. La première condition de jointure peut référencer les colonnes des tables
Employe et Departement, mais pas celles de la table Ville. La deuxième condition de jointure peut
référencer les colonnes des trois tables.
2.7. Jointure externes

Les jointures externes permettent de renvoyer les enregistrements qui n’ont pas de correspondance
directe.
Département Employé
NOMEMP DEP
IDDEP NOMDEP
Administration 11 Karimi 11
RH 23 Alami 23
IT 111 Ramali 111
Ventes 190 Errifi 11

Moussa 11
Le département 190 ne compte aucun employé
Si on considère la jointure
SELECT idemp, nomemp, nomdep

FROM Departement d
JOIN Employe e
ON (d.iddep = e.dep )
Lorsqu'une ligne ne satisfait pas à une condition de jointure, elle n'apparaît pas dans le résultat de
l'interrogation. Par exemple, l'ID de département 190 n'apparaît pas, car aucun employé avec cet ID de
département n'est enregistré dans la table Employe.
Pour renvoyer l'enregistrement du département ne comportant aucun employé, on peut utiliser une
jointure externe.
SELECT d.depnom, e.nomemp

FROM Departement e LEFT OUTER JOIN Employe e ON e.dept = d.iddep
Il existe trois types de jointure externe :

 LEFT OUTER
 RIGHT OUTER
 FULL OUTER
58
La jointure externe ajoute des lignes fictives dans une des tables pour faire la correspondance avec les
lignes de l'autre table. Dans l'exemple précédent, une ligne fictive (un employé fictif) est ajoutée dans
la table des employés si un département n'a pas d'employé. Cette ligne aura tous ses attributs null, sauf
celui des colonnes de jointure.
LEFT indique que la table dans laquelle on veut afficher toutes les lignes (la table Departement) est à
gauche de LEFT OUTER JOIN. C'est dans l'autre table (celle de droite) dans laquelle on ajoute des
lignes fictives. De même, il existe RIGHT OUTER JOIN qui est utilisé si on veut afficher toutes les
lignes de la table de droite (après le RIGHT OUTER JOIN) et FULL OUTER JOIN si on veut afficher
toutes les lignes des deux tables.
Exemple de jointure LEFT OUTER JOIN

L'interrogation ci-dessous extrait toutes les lignes de la table Employe, qui est la table de gauche, même
s'il n'existe aucune correspondance dans la table Departement.
SELECT e.nomemp, e.dep, d.nomdep

FROM Employe e LEFT OUTER JOIN Departement d
ON (e.dep = d.iddep) ;
Exemple de jointure RIGHT OUTER JOIN
L'interrogation ci-dessous extrait toutes les lignes de la table Departement, qui est la table de droite,
même s'il n'existe aucune correspondance dans la table Employe.

FROM Employe e RIGHT OUTER JOIN Departement d
Exemple de jointure FULL OUTER JOIN
L'interrogation ci-dessous extrait toutes les lignes de la table Employe, même s'il n'existe aucune
correspondance dans la table Departement. Elle extrait également toutes les lignes de la table
Departement, même s'il n'existe aucune correspondance dans la table Employe.

FROM Employe e FULL OUTER JOIN Departement d
3. CLAUSE ORDER BY
Les lignes constituant le résultat d'un SELECT sont obtenues dans un ordre indéterminé. La clause
ORDER BY précise l'ordre dans lequel la liste des lignes sélectionnées sera donnée.
ORDER BY exp1 [DESC], exp2 [DESC], ...
L'option facultative DESC donne un tri par ordre décroissant. Par dé-faut, l'ordre est croissant.
Le tri se fait d'abord selon la première expression, puis les lignes ayant la même valeur pour la première
expression sont triées selon la deuxième, etc. Les valeurs nulles sont toujours en tête quel que soit l'ordre
du tri (ascendant ou descendant).
59
Exemples
Liste des employés et de leur poste, triée par département et dans chaque département par ordre de
salaire décroissant :
SELECT nomemp, idposte FROM Employe ORDER BY dep, Salaire DESC
4. Utilisation des fonctions prédéfinie
4.1. Fonctions de groupes :

Les fonctions de groupes peuvent apparaître dans le Select ou le Having; ce sont les fonctions suivantes
Syntaxe générale :
SELECT [column,] group_function(column), ...
FROM table
[WHERE condition]
[GROUP BY column]
[ORDER BY column];
Remarques :
Les valeurs NULL sont ignorées par les fonctions de groupe. Ainsi, SUM(col) est la somme des valeurs
qui ne sont pas égales à NULL de la colonne 'col'. De même, AVG est la somme des valeurs non NULL
divisée par le nombre de valeurs non NULL.
Il faut remarquer qu'à un niveau de profondeur (relativement aux sous-interrogations), d'un SELECT,
les fonctions de groupe et les colonnes doivent être toutes du même niveau de regroupement. Par
exemple, si on veut le nom et le salaire des employés qui gagnent le plus dans l'entreprise, la requête
suivante provoquera une erreur :
SELECT nomemp, salaire FROM Employe

WHERE salaire = MAX(salaire)
Il faut une sous-interrogation car MAX(salaire) n'est pas au même niveau de regroupement que le
simple salaire:
60
WHERE salaire = (SELECT MAX(salaire) FROM Employe)
4.2. Clause GROUP BY et HAVING

 Clause GROUP BY:
Il est possible de subdiviser la table en groupes, chaque groupe étant l'ensemble des lignes ayant une
valeur commune.
GROUP BY exp1, exp2,...
Groupe en une seule ligne toutes les lignes pour lesquelles exp1, exp2,... ont la même valeur. Cette
clause se place juste après la clause WHERE, ou après la clause FROM si la clause WHERE n'existe
pas.
On peut éliminer des lignes avant que le groupe ne soit formé grâce à la clause WHERE.
Exemple :
Afficher le nombre d’employé par département :
SELECT dep, COUNT(*) FROM Employe GROUP BY dep
Restrictions sur les fonction de groupes :

 Toute colonne ou expression de la liste SELECT qui ne constitue pas une fonction de groupes
doit figurer dans la clause GROUP BY
 On ne peut pas utiliser des fonctions de groupe dans la clause WHERE.
 Vous ne pouvez pas utiliser la clause WHERE pour restreindre des groupes. Utilisez la clause
HAVING pour restreindre des groupes.
 Clause HAVING :
HAVING condition_logique
Sert à préciser quels groupes doivent être sélectionnés. Elle se place après la clause GROUP BY.
La condition logique suit la même syntaxe que celui de la clause WHERE. Cependant, il ne peut porter
que sur des caractéristiques de groupe : fonction de groupe ou expression figurant dans la clause GROUP
BY.
Exemple :
Le numéro et le salaire maximal des départements dont le salaire maximal est supérieur à 10 000
SELECT dep, MAX(salaire)

FROM Employe
GROUP BY dep
HAVING MAX(salaire)>10000 ;
4.3. Fonctions monolignes

Nous allons décrire ci-dessous les principales fonctions disponibles dans Oracle. Il faut remarquer que
ces fonctions ne sont pas standardisées et ne sont pas toutes disponibles dans les autres SGBD. On se
limite à l’étude de quelques fonctions, la description détaillée des fonctions SQL pour Oracle est
disponible ici :
61
https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Functions.html#GUID-
D079EFD3-C683-441F-977E-2C9503089982
4.3.1. La table DUAL

La table DUAL est une table spéciale d'une seule colonne et d'une seule ligne présente par défaut dans
le SGBD Oracle. Elle est utilisée généralement pour sélectionner les pseudo-colonnes telles que
SYSDATE. La table contient une seule colonne de type VARCHAR2(1) appelée DUMMY qui a pour
unique valeur 'X'.
4.3.2. Quelques fonctions arithmétiques
Fonction Description
ABS(n) valeur absolue de n
MOD(n1, n2 ) n1 modulo n2
POWER(n, e) n à la puissance e
ROUND(val, n) Arrondit la valeur val à n chiffres après la virgule ou, si n est
omis, supprime les chiffres après la virgule (si la valeur n est
négative, les nombres à gauche de la virgule sont arrondis).
SIGN(n) -1 si n<0, 0 si n=0, 1 si n>0

SQRT(n) racine carrée de n
TRUNC(val, n) Tronque la valeur val à n chiffres après la virgule ; si la
valeur n est omise, elle prend la valeur zéro par défaut.
MOD(m,n) Renvoie le reste de la division de m par n.
GREATEST(n1, n2,...) maximum de n1, n2,…

LEAST(n1, n2,...) minimum de n1, n2,...
TO_CHAR(n, format ) convertit n en chaîne de caractères (voir 4.10.2)
TO_NUMBER(chaîne ) convertit la chaîne de caractères en numérique
Exemples :
SELECT
GREATEST(120, 151,500,15,78,888,45,87) "La plus grande
valeur",
LEAST(120, 151,500,15,78,888,45,87) "La plus petite
valeur",
SQRT(16) "Racine",
ABS(-3) "valeur absolu",
POWER(2, 3) "Puissance",
sign(-14) "Signe"
FROM DUAL
62
Fonction ROUND
SELECT
ROUND(45.926, 2) "Résultat 1",
ROUND(45.923,2) "Résultat 2",
ROUND(45.923,-1) "Résultat 5"
FROM DUAL
Fonction TRUNC
SELECT
TRUNC (45.923,2) 'Résultat 1',
TRUNC (45.923)'Résultat 2',
TRUNC (45.923,-1) 'Résultat 3',
FROM DUAL;
Fonction MOD
SELECT
MOD (122, 100) "Résultat 1",
MOD (1019, 100) "Résultat 2"
FROM DUAL
63
4.3.3. Quelques fonctions sur chaînes de caractères
Fonction Description
UPPER(chaîne ) Convertit les minuscules en majuscules
LOWER(chaîne ) Convertit les majuscules en minuscules
SUBSTR(ch, pos [,longueur Extrait de la chaîne ch une sous-chaîne de longueur
]) longueur commençant en position pos de la chaîne.
Le paramètre longueur est facultatif : par défaut, la sous-
chaîne va jusqu'à l'extrémité de la chaîne.
si la valeur pos est négative, le décompte commence à
partir de la fin
INITCAP(ch) Convertit la première lettre de chaque mot en majuscules,

LENGTH(ch ) Retourne la longueur de la chaîne ch
CONCAT(ch1, ch2) Concatène le premier caractère avec le deuxième ;
opération identique à celle effectuée par l'opérateur de
concaténation (||).
INSTR(column|expression, Renvoie la position numérique d'une chaîne nommée.
’string’, [,m], [n] ) Vous pouvez également indiquer une position m pour
commencer la recherche, ainsi que l'occurrence n de la
chaîne. La valeur par défaut de m et n est de 1, ce qui
signifie que la recherche commence au début et que la
première occurrence est renvoyée.
TRIM(leading|trailing|both Permet de supprimer les caractères de début ou de fin (ou

, trim_character FROM les deux) d'une chaîne de caractères. Si trim_character ou
trim_source) trim_source est un littéral de type caractère, vous devez
l'inclure entre apostrophes.
Par défaut, TRIM supprime les espaces si le caractère /les
caractères à supprimer n’est (ne sont) pas indiqué (s).
Donc TRIM (ch) supprime les espaces au début et à la
fin de la chaîne de caractères ch
LTRIM(ch, car ) supprime les caractères à l'extrémité gauche de la chaîne

ch tant qu'ils appartiennent à l'ensemble de caractères
car. Si l'ensemble des caractères n'est pas donné, ce sont
les espaces qui sont enlevés.
RTRIM(ch, car ) Comme LTRIM les caractères étant supprimés à
l'extrémité droite de la chaîne ch. Si car n'est pas
donné, ce sont les espaces qui sont enlevés.
REPLACE(text,search_string Recherche une chaîne de caractères dans une expression
, replacement_string) de type texte et, le cas échéant, la remplace par une chaîne
de substitution.
64
Exemples :
Fonction LENGTH:
SELECT LENGTH('boUdaA tArik imzouréN') "Résultat 1",

LENGTH('boUdaA') "Résultat 2",
LENGTH(' boUdaA') "Résultat 3"
FROM DUAL
Fonction UPPER
SELECT
UPPER('boUdaA tArik imzouréN') "Résultat"
FROM DUAL
Fonction LOWER
SELECT
LOWER('boUdaA tArik imzouréN') "Résultat"
FROM DUAL
Fonction INITCAP
SELECT
INITCAP('boUdaA tArik imzourEN') "Résultat"
FROM DUAL
65
Fonction CONCAT
SELECT
CONCAT('boUdaA' , 'tArik imzouréN') "Résultat 1",
CONCAT(CONCAT('boUdaA','Info') , 'tArik imzouréN')
"Résultat 2"
FROM DUAL
Fonction SUBSTR
SELECT
SUBSTR('ABCDEFG',3,4) "Rés 1",
SUBSTR('ABCDEFG',-5,4) "Rés 2",
SUBSTR('ABCDEFG',2) "Rés 3",
SUBSTR('ABCDEFG',3,41) "Rés 4",
SUBSTR('ABCDEFG',-3) "Rés 5"
FROM DUAL
Fonction INSTR
SELECT
INSTR('ABCDEFG' , 'CD') "Rés 1",
INSTR('ABCDEFG' , 'CD' , 4) "Rés 1",
INSTR('ABCDEFG' , 'EF' , 4) "Rés 1",
INSTR('ABCDEFG' , 'E' , 1, 6) "Rés 1",
INSTR('ABCDEFG' , 'B' ,2) "Rés 1"
FROM DUAL
66
Fonctions TRIM , LTRIM , RTRIM
SELECT
' Boudaa ',
TRIM(' Bou daa ') "Rés 1",
TRIM('Bou daa ') "Rés 2",
TRIM(' Bou daa') "Rés 3",
TRIM(' BOUDAA Boudaa') "Rés 4",
LTRIM(' BOUDAA ') "Rés 5",
RTRIM(' BOUDAA ') "Rés 6"
FROM DUAL
SELECT
' Boudaa ',
TRIM('B' from 'BouBdaaB') "Rés 1",
TRIM('B' from 'BouBdaaB ') "Rés 2",
TRIM('B' from ' BouBdaaB') "Rés 3",
TRIM(leading 'B' from 'BouBdaaB') "Rés 4",
TRIM(trailing 'B' from 'BouBdaaB') "Rés 5",
TRIM(both 'B' from 'BouBdaaB') "Rés 6",
TRIM(both from ' BouB daaB ') "Rés 7"
FROM DUAL
67
Fonction REPLACE
SELECT
REPLACE(' I Like Java and Spring Framework. Java is a POO
Language', 'Spring', 'EJB') "Rés 1",
TRIM(REPLACE(REPLACE(' I Like Java and Spring Framework',
'Java', 'JavaScript') , 'Spring','Angular')) "Rés 2",
REPLACE(REPLACE(REPLACE(' I Like Java and Spring
Framework', 'Java', 'JavaScript') , 'Spring','Angular') , '
', '') "Rés 2"
FROM DUAL
4.3.4. Calculs arithmétiques sur des dates

Etant donné que les dates sont stockées dans la base de données sous forme de nombres, vous pouvez
effectuer des calculs sur les dates à l'aide d'opérateurs arithmétiques tels que l'addition et la
soustraction. Vous pouvez additionner et soustraire des constantes numériques ainsi que des dates.
Exemples :
SELECT
SYSDATE "Ajourd'hui",
to_date(SYSDATE, 'DD/MM/RR HH24:MI:SS') -
to_date('30/12/20 00:00:00', 'DD/MM/RR hh24:mi:ss')
"DATE RESULTANTE",
SYSDATE -1 "DATE HIER",
SYSDATE + 1 "DATE DEMAIN",
ROUND((to_date(SYSDATE, 'DD/MM/RR HH24:MI:SS') -
to_date('30/12/20 00:00:00', 'DD/MM/RR hh24:mi:ss')) / 30
) "Nombre de mois"
FROM DUAL
4.3.5. Quelques fonctions sur les dates

 SYSDATE : affiche la date actuelle
 MONTHS_BETWEEN(date1, date2) : calcule le nombre de mois entre date1 et date2. Le
résultat peut être positif ou négatif. Si date1 est postérieure à date2, le résultat est positif ;
68
si date1 est antérieure à date2, le résultat est négatif. La partie non entière du résultat
représente une partie du mois.
 ADD_MONTHS(date, n) : ajoute n mois calendaires à date. La valeur de n doit être un
entier et peut être négative.
 EXTRACT({YEAR | MONTH | DAY |HOUR | MINUTE | SECOND} FROM {d | i})
Extrait une partie donnée d’une date ou d’un intervalle.
 TO_DATE(chaîneCaractères [, format [, 'NLS_DATE_LANGUAGE=Langue']])
Convertit une chaîne en date suivant un certain format dans un certain langage ;
 TO_CHAR(colonneDate [, format [, 'NLS_DATE_LANGUAGE=Langue']]) convertit
une date en chaîne suivant un certain format dans un certain langage ;
MONTHS_BETWEEN et ADD_MONTHS
SELECT
SYSDATE "Ajourd'hui",
MONTHS_BETWEEN (SYSDATE , '30/12/20'),
ADD_MONTHS(SYSDATE , 3)
FROM DUAL
TO_CHAR
SELECT
TO_CHAR(SYSDATE, 'DAY -MONTH - YEAR'),
TO_CHAR(SYSDATE, 'DD/MM/YYYY')
from DUAL;
69
TO_DATE
select TO_DATE('22/10/2020' , 'DD/MM/YYYY' )

AS "Exemple date" from DUAL;
EXTRACT
SELECT EXTRACT(DAY FROM to_date('22/10/20')) "Jour",

EXTRACT(MONTH FROM to_date('22/10/20')) "Mois",
EXTRACT(YEAR FROM to_date('22/10/20')) "Année" FROM
DUAL;
Afficher la date actuelle
SELECT
SYSDATE
FROM DUAL
Un autre exemple, en formatant l’affichage avec TO_CHAR:
SELECT
TO_CHAR(SYSDATE, 'DD/MM/YYYY HH:mm:ss')
FROM DUAL
70
5. Opérations ensemblistes
SELECT
OPERATION_ENSEMBLISTE
SELECT
Avec OPERATION_ENSEMBLISTE est l’une des opérations ensemblistes (Union, intersection,

différence)
La clause ORDER BY peut être utilisée uniquement à la toute fin de l'instruction
Le nom ou l'alias de colonne, lorsqu'il est utilisé dans une clause ORDER BY, doit être présent dans la
première liste SELECT.
Les opérateurs ensemblistes peuvent être utilisés dans les sous-interrogations.
5.1. Opérateur UNION

L'opérateur UNION permet de fusionner deux sélections de tables pour obtenir un ensemble de lignes
égal à la réunion des lignes des deux sélections. Les lignes communes n'apparaîtront qu'une fois. Si on
veut conserver les doublons, on peut utiliser la variante UNION ALL.
Exemples :
Afficher les informations relatives au poste actuel et au poste précédent de tous les employés. Affichez
chaque employé une seule fois.
SELECT idemp,idposte
FROM Employe
UNION
SELECT idemp, idposte
FROM HistoriquePoste;
5.2. Opérateur INTERSECT

L'opérateur INTERSECT permet d'obtenir l'ensemble des lignes communes à deux interrogations.
71
Exemples :
Afficher l’ID d'employé et l'ID de poste des employés dont le poste actuel est le même que celui qu'ils
occupaient avant :
FROM employees
INTERSECT
5.3. Opérateur EXCEPT (ou MINUS pour Oracle)

L'opérateur EXCEPT de SQL2 (ou MINUS pour Oracle) permet d’éliminer d'une sélection les lignes
obtenues dans une deuxième sélection.
Exemple :
Affichez l'ID des employés qui n'ont jamais changé de poste.
FROM employees
MINUS
6. Sous-interrogations
Une caractéristique puissante de SQL est la possibilité qu'une condition employée dans une clause
WHERE (expression à droite d'un opérateur de comparaison) comporte un SELECT emboîté.
Par exemple, la sélection des employés ayant même poste que ELHANI peut s'écrire en joignant la table
EMP avec elle-même :
SELECT e.nomemp
FROM Employe e JOIN Employe em ON e.idposte = em.idposte
WHERE em.nomemp = 'ELHANI'
Mais on peut aussi la formuler au moyen d'une sous-interrogation :

WHERE idposte = (SELECT idposte FROM Employe
WHERE nomemp = 'ELHANI')
Les sections suivantes exposent les divers aspects de ces sous-interrogations.
6.1. Sous-interrogation à une ligne et une colonne

Dans ce cas, le SELECT imbriqué est équivalent à une valeur.
WHERE exp op (SELECT ...)
où op est un des opérateurs : = != < > <= >= et exp est toute expression légale.
72
Exemples
a- Liste des employés travaillant dans le même département que KARABILA :

WHERE dep = (SELECT dep FROM Employe WHERE nomemp = 'KARABILA')
b- Liste des employés du département 10 ayant même poste que quelqu'un du département VENTES
SELECT nomemp, idposte FROM Employe WHERE dep = 10

AND idposte IN (SELECT idposte FROM Employe WHERE dep =
(SELECT iddep FROM Departement WHERE nomdep = 'VENTES')
)
c- Liste des employés ayant même poste que RAHMA ou un salaire supérieur à celui de AMINA :
SELECT nomemp, idposte, salaire FROM Employe

WHERE idposte = (SELECT idposte FROM Employe
WHERE nomemp = 'RAHMA')
OR salaire > (SELECT salaire FROM Employe WHERE nomemp = 'AMINA')
d- Liste des employés travaillant à TANGER et ayant même poste que ELMOUMEN.
SELECT nomemp, idposte

FROM Employe e JOIN Departement d ON (e.dep = d.iddep)
JOIN Ville v ON (v.idville = d.idville)
WHERE nomville = 'TANGER'
AND idposte = (SELECT idposte FROM Employe
WHERE nomemp = 'ELMOUMEN')
Attention : une sous-interrogation à une seule ligne doit ramener une seule ligne ; dans le cas où
plusieurs lignes, ou pas de ligne du tout seraient ramenées, un message d'erreur sera affiché et
l'interrogation sera abandonnée.
6.2. Sous-interrogation ramenant plusieurs lignes

Une sous-interrogation peut ramener plusieurs lignes à condition que l'opérateur de comparaison
admette à sa droite un ensemble de valeurs.
Les opérateurs permettant de comparer une valeur à un ensemble de valeurs sont :
- l'opérateur IN
- les opérateurs obtenus en ajoutant ANY ou ALL à la suite des opérateurs de comparaison classique =, !=, <,
>, <=, >=.
ANY : la comparaison sera vraie si elle est vraie pour au moins un élément de l'ensemble (elle est donc
fausse si l'ensemble est vide).
ALL : la comparaison sera vraie si elle est vraie pour tous les éléments de l'ensemble (elle est vraie si
l'ensemble est vide).
WHERE exp op ANY (SELECT ...)

WHERE exp op ALL (SELECT ...)
WHERE exp IN (SELECT ...)
WHERE exp NOT IN (SELECT ...)
où op est un des opérateurs =, !=, <, >, <=, >=.
73
Exemple
Liste des noms des employés gagnant plus que tous les employés du département 39 :

WHERE salaire > ALL (SELECT salaire FROM Employe WHERE dep=39)
Remarque
L'opérateur IN est équivalent à = ANY, et l'opérateur NOT IN est équivalent à != ALL.
6.3. Sous-interrogation synchronisée
Il est possible de synchroniser une sous-interrogation avec l'interrogation principale.
Exemple
Liste des noms des employés ne travaillant pas dans le même département que leur supérieur.
SELECT nomemp FROM Employe E

WHERE dep != (SELECT dep FROM Employe WHERE idemp = E.sup)
Il a fallu renommer la table Employe de l'interrogation principale pour pouvoir la référencer dans la
sous-interrogation.
6.4. Sous-interrogation ramenant plusieurs colonnes
Il est possible de comparer le résultat d'un SELECT ramenant plusieurs colonnes à une liste de colonnes.
La liste de colonnes figurera entre parenthèses à gauche de l'opérateur de comparaison.
Avec une seule ligne sélectionnée :
WHERE (exp, exp,...) op (SELECT ...)
Avec plusieurs lignes sélectionnées :
WHERE (exp, exp,...) op ANY (SELECT ...)

WHERE (exp, exp,...) op ALL (SELECT ...)
WHERE (exp, exp,...) IN (SELECT ...)
WHERE (exp, exp,...) NOT IN (SELECT ...)
où op est un des opérateurs = ou !=
Les expressions figurant dans la liste entre parenthèses seront comparées à celles qui sont ramenées par
le SELECT.
Exemple :
Les noms des employés ayant même poste et même salaire que MOUSSA :
SELECT nomemp, idposte, salaire FROM Employe WHERE (idposte, salaire)

=
(SELECT idposte, salaire FROM Employe WHERE nomemp = 'MOUSSA')
74
6.5. Clause EXISTS

La clause EXISTS est suivie d'une sous-interrogation entre parenthèses, et prend la valeur TRUE s'il
existe au moins une ligne satisfaisant les conditions de la sous-interrogation.
La valeur FALSE est retournée si aucun enregistrement n’est extrait par la sous-interrogation.
L’opérateur NOT EXISTS retourne la valeur TRUE si aucun enregistrement n’est extrait par la sous-
interrogation.
Cet opérateur est fréquemment utilisé avec des sous-interrogations synchronisées afin de déterminer si
une valeur extraite par l'interrogation externe existe dans l'ensemble de résultats extrait par
l'interrogation interne. Si la sous-interrogation renvoie au moins une ligne, l'opérateur renvoie TRUE.
Si la valeur n'existe pas, il renvoie FALSE. De la même façon, NOT EXISTS détermine si une valeur
extraite par l'interrogation externe ne fait pas partie de l'ensemble de résultats extrait par l'interrogation
interne.
Exemple
Liste le nom des départements qui ont au moins un employé ayant plus de 10.000 comme salaire
SELECT nomdep FROM Departement d

WHERE EXISTS (SELECT idemp FROM Employe
WHERE dep = d.iddep AND salaire > 10000);
Pour chaque ligne de DEPT la sous-interrogation synchronisée est exécutée et si au moins une ligne est
trouvée dans la table EMP, EXISTS prend la valeur vraie et la ligne de DEPT satisfait les critères de
l'interrogation.
Notez que l'interrogation SELECT interne ne doit pas nécessairement renvoyer une valeur spécifique ;
une constante peut donc être sélectionnée. Par exemple nous pouvez exprimer la même requête que celle
précédente par :

WHERE EXISTS (SELECT ‘X’ FROM Employe
Ou

WHERE EXISTS (SELECT NULL FROM Employe
6.6. Sous-interrogation et valeurs NULL

6.6.1. Valeurs NULL et opérateur NOT IN (ou son équivalent <> ALL)
L'opérateur NOT IN renvoie la valeur FALSE si un membre quelconque de l'ensemble est une valeur
NULL.
Par exemple la requête ci-dessous ne retourne aucune valeur, bien que la table DUAL contient des lignes
qui satisfont à la condition WHERE (la table DUAL ne contient qu’une seule valeur qu’est ‘X’):
SELECT * FROM DUAL WHERE dummy not in ('Y','Z', NULL)
75
Par contre, l’instruction suivante affiche la valeur ‘X’ :
SELECT * FROM DUAL WHERE dummy not in ('Y','Z')
Ainsi, chaque fois qu'il est probable que des valeurs NULL font partie de l'ensemble de résultats d'une
sous-interrogation avec NOT IN (ou son équivalent <> ALL), il faut faire attention aux valeurs NULL.
Pour illustrer le problème, on considère la table Employé qui contient les données décrites dans la table
ci-dessous :
On considère l'instruction SQL suivante qui tente d'afficher tous les employés qui n’ont pas de
subordonnés.
SELECT *
FROM Employe emp
WHERE emp.idEmp NOT IN (SELECT mgr.sup FROM Employe mgr);
Cette instruction SQL devrait renvoyer 10 lignes. Or, elle ne renvoie aucune ligne :
76
Ceci est dû au fait que l'une des valeurs renvoyées par l'interrogation interne étant une valeur NULL
(car la première ligne a une valeur NULL pour l’attribut sup), ainsi l'ensemble de l'interrogation ne
renvoie aucune ligne.
Si nous remplaçons la valeur NULL pour l’attribut sup pour l’employé numéro 1, remarquons que les
10 employés sont bien sélectionnés :
Nous pouvons résoudre ce problème en éliminant les valeurs NULL par une condition dans la clause
WHERE :
SELECT *
FROM Employe emp
WHERE emp.idEmp NOT IN (SELECT mgr.sup FROM Employe mgr WHERE
mgr.sup IS NOT NULL);
6.6.2. Valeurs NULL et opérateur IN ( ou son équivalent = ANY)
Dans le cas qu’une valeur NULL est retournée dans l'ensemble de résultats d'une sous interrogation ne
pose pas de problème pour une comparaison avec l'opérateur IN (ou son équivalent = ANY).
Par exemple, l’instruction suivante affiche ‘X’ :

SELECT * FROM DUAL WHERE dummy in ('X','Y', NULL)
Un autre exemple, l’instruction SQL ci-dessous affiche les employés qui ont des personnes sous leur
responsabilité bien qu’il y a une valeur NULL dans la colonne sup de la table Employé.
SELECT *
FROM Employe emp
WHERE emp.idEmp IN (SELECT mgr.sup FROM
Employe mgr);
77
6.6.3. Valeurs NULL et opérateur EXISTS :
On considère la table Employé qui contient les données décrites dans la table ci-dessous :
Si on veut par exemple les employés qui ont la plus grande commission par la requête suivante,
select nomemp from Employe e1 where not exists

(select idemp from Employe where commission > e1.commission)
On aura en plus dans la liste tous les employés qui ont une commission NULL. La figure suivante
illustre le résultat de l’exécution de cette requête :
78

Cours Java PR - Tarik

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 Java PR - Tarik

Transféré par

Droits d'auteur :

Formats disponibles

Université Abdelmalek Essaadi

École Nationale des Sciences Appliquées Al-Hoceima

Préparé par : Pr. Tarik BOUDAA

Ce document comporte probablement des erreurs : toute suggestion constructive est la

2. Qu’est-ce qu’une base de données ?

2.2. Base de données :

(1)  Organisation et description de données

2.3. Pourquoi une base de données ?

2.4. Modèles de base de données

3. Système de gestion de base de données (SGBD)

4. Introduction intuitive à la création des bases de données

4.1. Notion de table

4.2. Langage SQL (Structured Query Language)

4.3. Comment créer les tables réellement dans un SGBD ?

SELECT nom_du_champ1, nom_du_champ2, … , nom_du_champN

Cette requête SQL va sélectionner (SELECT) les champs nom_du_champ1, nom_du_champ2, …

SELECT * FROM nom_du_tableau

CREATE TABLE Ensah_Commentaire (

pseudo varchar(52) NOT NULL,

SELECT * FROM Ensah_Commentaire

1 rouge 01251455114875 2011

2 noir 99999488114811 2012

id_exemplaire couleur num_serie annee_fabrication vehicule

1 rouge 01251455114875 2011 1

2 noir 99999488114811 2012 2

id_vehicule Code_identification poids Nombre_cyclindres

2. Eléments du modèle Entité/Association (E/A)

2.1. Entité (ou objet) :

2.2. type-entité et attributs :

Représentation graphique d’un type-entité :

2.3. Type de valeur ou domaine d’un attribut

- Le type ou domaine de l’attribut « nom » est « chaîne de caractères »

2.4. Identifiant ou clé

2.5. Association et type-association :

Des instances du type-association « Acheter »

Conception des bases de données

Des instances du type-entité Etudiant Des instances du type-entité Livre

nom Acheter Livre

2.6. Cardinalité d’une association

2.7. Types d’associations

Exemples 1 : association n:n

1 Mahmoud KARABILA Quantité=1 1 article1

Exemple 2 : fausse modélisation avec l’association n :n

1 Mahmoud KARABILA dateEmprunt=12/12/2014 5 article1

2.8. Règles importantes concernant les éléments du modèle E/A:

Chaque type-entité possède au moins un identifiant, éventuellement formé de plusieurs attributs.

L’expression de la cardinalité est obligatoire pour chaque patte d’un type-association.

3. Associations plurielles, réflexives et n-aires

La figure ci-dessous montre un exemple d’instance du modèle :

Conception des bases de données

3.2. Associations réflexives

3.3. Associations n-aires

Ci-dessous un exemple d’instance de ce modèle

1 Mahmoud KARABILA 9 article1

Validation d’un type-association ternaire :

On considère le modèle ci-dessous d’un type association ternaire :

où signifie : b ne dépend pas fonctionnellement de a. (Autrement dit : la connaissance de a

En principe donc, valider cette association ternaire, c’est d’abord vérifier :

Dans ce cas l’association ternaire valide si :

(Dépendance fonctionnelle élémentaire)

4. Notion d’identifiant relatif et d’agrégat

4.2. Notion d’agrégat :

L’agrégat se présente par un rectangle sur la pseudo-entité (voir exemple).