Le Modèle Relationnel

 Le modèle relationnel est basé sur une

collection de principes tirés de la théorie des
ensembles. Il a été initié par Dr CODD en
1970 et a été utilisé à partir des années 1980.
 Le succès du modèle relationnel est dû à :
• sa simplicité pour l’utilisateur : une BD est
vue comme un ensemble de tables,
• Son bon fondement théorique
Concepts du Modèle Relationnel
Le modèle relationnel représente la base de
données par les concepts suivants:
• Les domaines
• Les relations
• Les contraintes d’intégrité
Définition: Un domaine est un ensemble de
valeurs atomiques.
On distingue:
– Les domaines prédéfinis:
• Chaînes de caractères
• Nombres entier
• Booléens
• …
– Les domaines définis:
• en énumérant les valeurs.
• en spécifiant la formule que doit vérifier chaque valeur.
Définition: Une relation R est un sous-ensemble
du produit cartésien de n domaines D1, … , Dn :
R  D1 …  Dn .

Une relation peut être représenté simplement

sous la forme d’une table.

Elle est formée d’un ensemble d’attributs qu’on

nomme des colonnes.
Définition: Le schéma d’une relation est
simplement le nom de la relation suivi de la liste
des attributs associés à leurs domaines:
R(A1:D1, A2:D2, …, An:Dn)
Où les Ai sont les noms des attributs et les Di les
domaines.
L’arité d’une relation est le nombre de ses
attributs.
Définition: Une instance d’une relation R se
définit comme un sous-ensemble du produit
cartésien des domaines des attributs de R.

Définition: n-uplet (tuple en aglais) est une liste

de n valeurs (v1, …, vn) où chaque vi est une
valeur d’un attribut Ai.
Autrement dit un tuple est une ligne dans la
représentation tabulaire d’une relation.
 Nom de la Nom Domaine
relation d’attribut

Personne(nom: chaîne, âge: entier, genre:{“masculin”, “féminin”})

Schéma Nom Age Sexe

de la Rachidi 32 masculin tuple
relation
Essami 25 Féminin

Valeur
Le schéma d’une base de données relationnel est
l'ensemble des schémas des relations qui la
composent.
Valeurs Null : Dans certains cas la valeur d’un
attribut peut être inconnue ou inexistante, elle est
représenté par une valeur Null. La valeur Null (à
ne pas confondre avec 0) correspond à une
cellule vide dans une table.
Exemple: La date du début du mois hégire
prochain est inconnue aujourd’hui.
Clé Primaire
La clé d’une relation est le plus petit sous-
ensemble des attributs qui permet d’identifier
chaque ligne de manière unique.
Etudiant (CNE, Nom, Prénom)
Clé Etrangère
Un attribut A1 d’une relation R1 est une clé
étrangère de R1 s’il existe une relation R2
possédant une clé primaire K et que A1 a pour
domaine l’ensemble des valeurs de K.
On dit que A1 réfère à la relation R2
Contraintes d’intégrité
Le modèle relationnel impose les contraintes
structurelles suivantes:
• INTÉGRITÉ DE DOMAINE
• INTÉGRITÉ DE CLÉ
• INTÉGRITÉ RÉFÉRENCIELLE
INTÉGRITÉ DE DOMAINE
Les valeurs d'une colonne de relation doivent
appartenir au domaine correspondant.
INTÉGRITÉ DE CLÉ
Les valeurs de clés primaires doivent être :
• uniques
• non NULL
INTÉGRITÉ RÉFÉRENCIELLE
Les valeurs de clés étrangères sont soit 'Null' ou
des valeurs de la clé primaire auxquelles elles
font référence
Passage du modèle EA au modèle relationnel
1. Toute Entité devient une relation dont la clé
primaire est l'identifiant de l'Entité.
2. Une association binaire de fonctionnalité 1:n
disparaît, au profit d’une clé étrangère dans la
relation du côté de cardinalités 0,1 ou 1,1 qui
référence la clé primaire de l’autre table.
3. Une association binaire de fonctionnalité 1:1
disparaît, au profit d’une clé étrangère dans la
relation du côté de cardinalités 1,1.
4. Une association binaire de type n :m ou non
binaire devient une relation supplémentaire dont
la clé primaire est composée des clés étrangères.
Langage de Définition des Données
Le LDD permet de spécifier le schéma d’une
base de données relationnelle. Il correspond à
une partie de la norme SQL (structured query
language).
La définition du schéma d’une BDD se compose
de:
• la description des tables et de leur contenu
• La description des contraintes qui portent sur
les données de la base.
Création de la base de données
Plusieurs SGBDR offrent des interfaces
graphiques conviviales pour la création des bases
de données. Cependant dans plusieurs cas on a
besoin d’utiliser les instructions SQL.
Pour créer une base de données l’instruction est
la suivante:
CREATE DATABASE nomBDD;
Types SQL
Comme on l’a déjà vu, les attributs appartiennent
à des domaines qui indiquent les types de
données.
SQL propose un ensemble de types:
• Caractères fixes
CHAR(l) permet de stocker une chaîne de
caractères de longueur fixe égale à l , maximum
de 2000 Caractères.
• Caractères variables
VARCHAR(l) : permet de stocker une chaîne de
caractères de longueur variable ≤ l , maximum
de 4000 caractères.
• Entiers relatifs
Type Taille
INTEGER 4 octets
SMALLINT 2 octets
BIGINT 8 octets

• Flottants
Type Description Taille
FLOAT Flottants simple précision 4 octets
DOUBLE PRECISION Flottants double précision 8 octets
REAL Flottants simple précision 4 octets
• Date
DATE stocke les informations jour, mois et
année.
TIME stocke les informations heure, minute et
seconde.
DATETIME permet de combiner une date et un
horaire.
Création de Tables
La clause de création de table est:
CREATE TABLE nomTable (champ1 TypeChamp,
champ2 TypeChamp,…, champn
TypeChamp);
Exemple:
CREATE TABLE Etudiant (nom VARCHAR(20),
Prenom VARCHAR(20),
Adresse VARCHAR(100)
Niveau INTEGER)
Contraintes
Le contenu des tables doit respecter des contraintes
pour assurer l’intégrité de la base. Les contraintes
d’intégrité doivent être spécifiées lors de la création
de la table.
1. Si un attribut doit toujours avoir une valeur:
CREATE TABLE T1 ( C1 typeC NOT NULL);
2. Une clé est un ou plusieurs attributs qui
identifient de manière unique un tuple:
CREATE TABLE T1 ( C1 typeC1,
C2 typeC2,
C3 typeC3,
PRIMARY KEY (C1, C2));
Exemples:
• Déclaration de PK par contrainte de colonne
CREATE TABLE ETUDIANT
(CNE CHAR(10) PRIMARY KEY,
nom CHAR(20) NOT NULL,
prenom CHAR(20) NOT NULL,
adresse CHAR(4));
• Déclaration de PK par contrainte de table
CREATE TABLE appartement
(numAppart INTEGER,
Bloc INTEGER,
nbrChambres INTEGER,
PRIMARY KEY (numAppart, Bloc));
3. Si un attribut ou plusieurs à la fois
n’admettent pas de doublons:
CREATE TABLE T1 ( C1 typeC,
C2 typeC,
C3 typeC,
UNIQUE (C2,C3))
4. Si un attribut est clé étrangère qui fait
référence à un tuple d’une autre table
CREATE TABLE T1 ( C1 typeC,
C2 typeC,
C3 typeC,
FOREIGN KEY (C2) REFERENCES T2 )
une clé étrangère ne peut pas faire référence à la clé
primaire d’une autre table qui n’existe ou dont la clause
de création vient après. Parce que les clauses SQL sont
exécutés séquentiellement.
Exemple:
• CREATE TABLE option(
codeOpt INTEGER PRIMARY KEY,
nomOpt VARCHAR(20));
• CREATE TABLE etudiant(
CNE VARCHAR(10) PRIMARY KEY,
nom VARCHAR(20),
prenom VARCHAR(20),
codeOpt INTEGER,
FOREIGN KEY (codeOpt) REFERENCES option);
5. Lors de la destruction (la modification) d’une
ligne de la table référencée on peut soit remettre
à NULL soit appliquer la même modification:
CREATE TABLE T2 ( C1 typeC,
C2 typeC,
C3 typeC,
FOREIGN KEY (C2) REFERENCES T1
ON DELETE CASCADE
ON UPDATE CASCADE
ON DELETE NULL
ON UPDATE NULL)
Modification du schéma de la BDD
La création du schéma de la BDD est une étape
parmi d’autres dans le cycle de vie de la BDD.
On peut à tout moment être amené à ajouter de
nouvelles tables, à ajouter des attributs ou en
modifier la définition. La forme générale de la
clause qui permet de modifier une table est:
ALTER TABLE nomTable ACTION description
Le paramètre ACTION est à remplacer par l’une
des actions possibles ADD, MODIFY, DROP ou
CHANGE. description est la commande de
modification associé à ACTION.
Lors de la modification d’une table il faut
s’assurer que cette modification est compatible
avec le contenu de la table. Il faut respecter le
type de données, la taille de données, les
contraintes d’intégrité.
Modification des attributs
• Ajout d’un nouveau attribut
ALTER TABLE etudiant ADD niveau INTEGER;
Si la table etudiant contient des données la
colonne niveau contiendra des valeurs NULL
pour chaque ligne de données préexistante.
• Modifier un attribut
ALTER TABLE Notes MODIFY valNote FLOAT;
• Renommer un attribut
ALTER TABLE etudiant CHANGE Niveau Niv int;
• Supprimer un attribut
ALTER TABLE etudiant DROP Niveau;
Langage de manupilation des
données (SQL)
SQL est un langage qui permet d’interroger une
base de données sans se soucier de la représentation
interne (physique) des données, de leur localisation,
des chemins d’accès ou des algorithmes
nécessaires.
Il peut être utilisé d’une manière interactive via un
interpréteur ou être associé à un langage de
programmation. Ceci évite la manipulation explicite
des données comme avec un langage de
programmation classique.
Requêtes SQL
• Requête Sélection
La syntaxe de la requête de sélection est la
suivante:
SELECT attributs désirés
FROM une ou plusieurs tables
WHERE condition (sur les tuples de la
table)
Exemple :
SELECT codeN, valNote, CNE FROM Notes
WHERE (valNote>=14);
ou
SELECT * FROM Notes WHERE (valNote>=14);
Le * remplace tous les attributs de la relation Notes.
Renommage:
Les noms des attributs sont par défaut ceux
indiqués dans la clause SELECT, même quand il
y a des expressions complexes. Pour renommer
les attributs, on utilise le mot-clé AS.
SELECT valNote AS note, CNE AS
Code_National FROM Notes WHERE
(valNote>=14);
Concaténation:
Les attributs d’une relation peuvent être concaténés
à d’autres champs ou à des chaînes de caractères.
SELECT
CONCAT( nom, ' ', prenom) AS
nom_Complet,
ville
FROM
etudiants;
Calcul:
La clause SELECT permet aussi de créer des
attributs calculés grâce à des expressions.
SELECT CodeCommande,
CodeProduit,
prixUnitaire*Quantite AS Prix,
FROM detailCommande;
SQL est muni d’un ensemble de fonctions
mathématiques qu’on peut utiliser pour effectuer
certains calculs. Exemples:
• Valeur absolue ABS( Expression)
• Racine carée SQRT(Expression)
Trier:
Les valeurs des attributs de la relation résultante
d’une requête peuvent être triées en utilisant le
mot-clé ORDER BY:
SELECT *
FROM Notes
ORDER BY valNotes;
Enlever les doublons:
Le résultat d’une requête peut contenir des
doublons qu’on peut enlever grâce au mot-clé
DISTINCT.

SELECT DISTINCT nom

FROM Etudiant;
La clause WHERE
Dans la clause WHERE, on spécifie une condition
booléenne portant sur les attributs des relations du
FROM. On utilise pour cela les opérateurs logiques
AND, OR, NOT et les parenthèses pour changer
l’ordre de priorité des opérateurs booléens. En plus
des opérateurs de logiques, des opérateurs de
comparaison sont utilisés ( <, <=, =, >, >=, < >).
SQL est muni d’un ensemble d’attributs qui
permettent de faciliter l’écriture des conditions.
• BETWEEN peut être utiliser pour vérifier si
une valeur de colonne est entre deux valeurs.
• IN permet de vérifier si une valeur correspond
à une de celles spécifiée dans une liste.
• LIKE permet de comparer une valeur à une
chaine de caractère.
Exemples:
• SELECT nom, prenom FROM client WHERE
(age BETWEEN 32 AND 50);

• SELECT nom, prenom FROM client WHERE

prenom IN (‘Ali', ‘Mohammed', ‘Said');

• SELECT nom, prenom FROM client WHERE

prenom LIKE ‘abd%’;
Requêtes sur plusieurs tables
Quand on précise plusieurs tables dans la clause
FROM, on obtient le produit cartésien des tables.
Ce produit cartésien offre en général peu
d'intérêt.
Ce qui est normalement souhaité, c'est de joindre
les informations de diverses tables, en
« recollant » les lignes des tables suivant les
valeurs qu'elles ont dans certaines colonnes.
La jointure
La jointure est une des opérations les plus utiles
puisqu’elle permet d’exprimer des requêtes
portant sur des données réparties dans plusieurs
tables.
La syntaxe pour exprimer des jointures avec
SQL est une extension directe de la requête
sélection: on donne la liste des tables concernées
dans la clause FROM, et on exprime les critères
de rapprochement entre ces tables dans la clause
WHERE.
Soit la requête suivante
SELECT nomRealisateur, titreFilm
FROM Realisateur, Film;
Cette requête ne possède pas de critère de jointure entre
une table et l'autre. Dans ce cas, le compilateur SQL
calcule le produit cartésien des deux ensembles.
Il faut donc définir un critère de jointure pour avoir les
réalisateurs et les films correspondants. Dans le cas
présent, ce critère est la correspondance entre les colonnes
contenant la référence de la clé du réalisateur (numReali).
SELECT nomRealisateur, titreFilm
FROM Realisateur, Film
WHERE Realisateur.numReali = Film.numReali;
Cette écriture peut être simplifié en utilisant
l'opérateur NATURAL JOIN qui permet d'éviter
de préciser les attributs concernées par la
jointure à condition que les attributs aient le
même nom dans les deux relations.
SELECT nomRealisateur, titreFilm
FROM Realisateur NATURAL JOIN Film;
Si les noms des attributs objet de la jointure sont
différents on doit les préciser sans utiliser la
clause WHERE. En effet:
• les jointures faites dans la clause WHERE ne
permettent pas de faire la distinction entre ce
qui relève du filtrage et ce qui relève de la
jointure.
• L'optimisation d'exécution de la requête est
maximale du fait de l'utilisation du JOIN.
Donc lorsque les attributs de jointure sont
différents on utilise une jointure interne:

SELECT nomRealisateur, titreFilm

FROM Realisateur INNER JOIN Film ON
Realisateur.numReali=Film.codeReali;

le mot-clé INNER est facultatif. On peut utiliser

JOIN seul.
Si on souhaite sélectionner parmi les tuples
résultat de la jointure quelques un qui vérifient
une condition on doit donc ajouter la clause
WHERE.

SELECT nomRealisateur, titreFilm

FROM Realisateur INNER JOIN Film ON
numReali=codeReali
WHERE nomReali=‘ELAKKAD’;
Les jointures externes sont extrêmement
pratiques pour rapatrier le maximum
d'informations disponible. La relation résultante
de cette jointure comporte même les tuples pour
lesquels la valeur de l’attribut de jonction n’a
aucune valeur correspondante dans la deuxième
relation. (par exemple la valeur de la clé primaire
existe alors que la clé étrangère correspondante
est absente c.à.d. sa valeur est NULL).
SELECT nomRealisateur, titreFilm
FROM Realisateur LEFT OUTER JOIN Film
ON numReali=codeReali ;
La jointure externe ajoute des lignes fictives
dans une des tables pour faire la correspondance
avec les lignes de l'autre table. Dans cet exemple
une ligne fictive est ajoutée dans la table des film
si un réalisateur ne correspond à aucun film. On
peut écrire aussi:
SELECT nomRealisateur, titreFilm
FROM Film RIGHT OUTER JOIN Realisateur
ON numReali=codeReali ;
RIGHT indique que la table dans laquelle on
veut afficher toutes les lignes est à droite de
RIGHT OUTER JOIN. C'est dans l'autre table
(celle de gauche) où on ajoute des lignes fictives.

De même, pour LEFT OUTER JOIN qui est

utilisé si on veut afficher toutes les lignes de
la table de gauche et FULL OUTER JOIN si on
veut afficher toutes les lignes des deux tables.
Requêtes imbriquées
Appelées aussi sous-requêtes, il s’agit d’exprimer
des condition sur des relations c.à.d. que la partie qui
suit la clause WHERE contient une requête SELECT.
Par exemple, la sélection des noms des étudiants qui
sont inscrits dans la même filière que l’étudiant
numéro 214 peut être formulée au moyen d'une sous-
requête:
SELECT nomEtudiant FROM Etudiant
WHERE codeEtudiant = (SELECT codeEtudiant
FROM Etudiant
WHERE prenomEtudiant = ‘mustapha’);
Insertion:
L’insertion s’effectue avec la commande INSERT
dont la syntaxe est la suivante :
INSERT INTO T1 ( A1, A2, ... An)
VALUES (v1, v2, ... vn)
T1 est le nom d’une table, et les A1, ... An sont
les noms des attributs dans lequels on souhaite
placer les valeurs. Les autres attributs seront donc
à NULL (ou à la valeur par défaut).
Mise à jours:
La mise à jours s’effectue avec la commande
UPDATE dont la syntaxe est la suivante :
UPDATE T1 SET colonne1 = valeur1, colonne2
= valeur2, ...
WHERE condition;
T1 est le nom d’une table