Vous êtes sur la page 1sur 42

Chapitre-1 : Modèle Relationnel (MR) &

Langage SQL

Table des matières


1. Introduction ............................................................................................................................ 3
2. Modèle relationnel. ................................................................................................................. 3
2-1- Schéma de relation et schéma de base de données relationnel. ...................................... 5
2-2 Règle de la modélisation relationnelle ................................................................................ 6
a- Notion de dépendance fonctionnelle .............................................................................. 6
b- Notion de la normalisation ............................................................................................. 7
c- Identifiant externe .......................................................................................................... 8
d- Contraintes d'intégrité .................................................................................................... 9
3. Algèbre relationnelle ............................................................................................................ 10
3.1. La Sélection .................................................................................................................... 10
3.2. Projection ....................................................................................................................... 11
3.3. Union ............................................................................................................................... 12
3.4. Intersection ..................................................................................................................... 13
3.5. La différence .................................................................................................................. 14
3.6. Produit cartésien ............................................................................................................ 15
3.7. Jointure ........................................................................................................................... 16
3.8. Thêta-jointure ................................................................................................................ 17
3.9. Équi-jointure .................................................................................................................. 17
3.10. La division................................................................................................................... 18
4. Les Index ............................................................................................................................... 20
4.1. Le fonctionnement de l'index........................................................................................ 21
4.2. Les index multi-Attributs .............................................................................................. 22
5. Langage SQL ........................................................................................................................ 22
5.1. La définition des données LDD .................................................................................... 23
5.1.1. La commande CREATE TABLE ......................................................................... 23
5.1.2. La commande ALTER TABLE ............................................................................ 24
5.2. Les types de donnée ......................................................................................................... 24

1
5.2.1. Type Numérique. .................................................................................................... 25
5.2.2. Type Chaine de caractère. ..................................................................................... 25
5.2.3. Type Date ................................................................................................................ 25
5.2.4. Type Logique .......................................................................................................... 26
5.2.5. Type auto incrémentation : Les séquences .......................................................... 26
5.3. Les contraintes ................................................................................................................. 27
5.3.1. Les contraintes de domaine ................................................................................... 27
5.3.2. Les contraintes d’intégrité d’entité ....................................................................... 28
5.3.3. Les contraintes d’intégrité référentielle ............................................................... 28
5.3.4. Les assertions .......................................................................................................... 29
5.4. La manipulation des données MDL ............................................................................. 29
5.4.1. La commande INSERT .......................................................................................... 29
5.4.2. La commande UPDATE ........................................................................................ 30
5.4.3. La commande DELETE ........................................................................................ 31
5.4.4. La commande SELECT ......................................................................................... 32
a. Requêtes simples ........................................................................................................ 32
b. Requêtes simples avec critère (clause WHERE) ..................................................... 33
i. Opérateur Classement (ORDER BY) ....................................................................... 34
ii. Clauses IN et BETWEEN ........................................................................................ 34
iii. La clause LIKE ......................................................................................................... 35
c. Requêtes simples avec calcule sur les dates : clause Extract() ............................... 35
a- Les fonctions Dates ...................................................................................................... 35
d. Requête avec création de nouveau champ avec formule ........................................ 36
e. Requête multi tables (les jointures) .......................................................................... 36
i. Jointure interne ......................................................................................................... 36
ii. Jointure externe ........................................................................................................ 36
f. Supprimer les doubles avec DISTINCT .................................................................. 37
g. Les fonctions d'ensemble ........................................................................................... 38
h. La clause GROUP BY ............................................................................................... 40
i. Les sous-requêtes ....................................................................................................... 40
j. Les UNIONs ................................................................................................................ 41
5.5. Les Vues matérialisées ................................................................................................. 41

A.BENMAKHLOUF 2
1. Introduction

Après avoir fait une conception du monde réel en utilisant par exemple la modélisation entité-
Association (MCD), l’étape suivante est de le transposer en Modèle Logique de Données
Relationnelles (MLDR). Le Modèle relationnel (MR) est un modèle de données plus simple que
celui de l'entité association, ce qui explique son succès tant sur le plan théorique (théorie de la
normalisation, définition de langages de manipulation de données), que sur celui des réalisations.
Mais cette simplicité est aussi sa faiblesse principale : c'est un outil trop pauvre sémantiquement
pour pouvoir bien représenter la complexité du monde réel. C’est pourquoi d'autres modèles de
type entité association ou orientés objets ont été ensuite proposés.
Ce chapitre présente un rappel sur les concepts de base du modèle relationnel.

2. Modèle relationnel.

Ce modèle s’inspire du concept mathématique de relation.

Définitions. Soient A1, A2, A3, ..., An n ensembles appelés domaine. On appelle produit cartésien
de A1, A2, A3, ..., An l’ensemble A1 x A2 x A3 x ... x An défini par :
A1 x A2 x A3 x ... x An = {(x1, x2, x3, ..., xn)| xi  Ai }
On appelle relation sur les ensembles A1, A2, A3, ..., An un sous - ensemble de leur produit
cartésien. A1, A2, A3, ..., An. A chaque relation et à chaque domaine d’une relation correspond un
nom.

Un n-uplet sur (A1,A2, ...,An) est un élément du produit cartésien A1× ... × An
Une instance d’une relation R est un sous ensemble fini de A1× ... × An.

Exemple. Soient A = {1, 2, 3} et B = {a, b}.


On a : A x B = {(1, a), (2, a), (3, a), (1, b), (2, b), (3, b)}.
Le sous - ensemble = {(1, a), (1, b), (2, a), (2, b)} est une relation définie sur les
domaines A et B.
La relation  peut s’écrire, également, sous la forme :

 A B
1 a
1 b
2 a
2 b

A.BENMAKHLOUF 3
Figure-1

Dans le système de notation utilisé ci-dessus (figure 1) la relation  est représentée comme un
tableau de données. D’où l’appellation de tableau ou table.
Toute colonne d’une relation s’appelle attribut (ou encore champ ou rubrique). Un attribut est,
également, caractérisé par un nom.
Exemple. Considérons les domaines Constructeur = {Fiat, Renault, Peugeot, Honda}, Modèle
= {Tipo, Clio, Megane, 208, 308, 2008, Civic, accord} et. Considérons la relation Voiture
définie par :
Voiture = {(Fiat, Tipo), (Renault, Clio), (Renault, Magane), (Peugeot, 208), (Peugeot, 308),
(Peugeot, 2008) , (Honda, Civic), (Honda, Accord)}. Cette relation peut s’écrire, encore, sous la
forme :

Voiture Constructeur Modèle


Fiat Tipo
Renault Clio Figure 2
Renault Clio
Renault Megane
Peugeot 208
Peugeot 308
Peugeot 2008
Honda Civic
Honda Civic
Honda Accord
Honda Accord

Cette relation a le nom Voiture et les attributs Constructeur et Modèle. L’attribut. Une ligne du
tableau s’appelle tuple, n-uplet ou n-uple ou encore, par abus de langage, enregistrement ou
occurrence.
Une relation est représentée par son nom suivi de la liste de ses attributs. Par exemple la relation
Voiture s’écrit : Voiture(Contructeur, Marque).
Le modèle relationnel interdit d'avoir des doubles : deux tuples d'une même relation ne peuvent
pas être identiques. D’où l’introduction d’un autre attribut appelé clé qui va identifier d’une
manière unique chaque n-uplet.
Clé. On entend par clé un ou plusieurs attributs permettant d’identifier une tuple unique de la
relation. Deux tuples ne peuvent avoir une même valeur pour la clé.
Exemple. Redéfinissons la relation Voiture de la manière suivante :

A.BENMAKHLOUF 4
Voiture Immatriculation Constructeur Modèle
1245-A-6 Fiat Tipo
2245-A-6 Renault Clio
4245-B-6 Renault Clio
12245-B-6 Renault Megane
45789-A-44 Peugeot 208
45745-C-44 Peugeot 308
1245-A-54 Peugeot 2008
9245-C-55 Honda Civic
1247-D-55 Honda Civic
1245-A-56 Honda Accord
1245-B-56 Honda Accord
Figure-3

Cette relation a comme clé l’attribut N_Immatriculation. Il est évident qu’il n’existe les mêmes
voitures même constructeur et même modèle mais pas le même numéro d’immatriculation

2-1- Schéma de relation et schéma de base de données relationnel.

Soit un ensemble d’attribut noté Attr et un ensemble de nom de relation Rel. A chaque nom de
relation R dans Rel on associe un ensemble d’attributs noté Attr(R). Donc un schéma de relation
est caractérisé par son nom et sa liste d’attribut. R(A1, A2, …., An).

On appelle schéma d'une base de données relationnelle l'ensemble des schémas de ses
relations. On appelle base de données relationnelle, l'ensemble des populations de toutes ses
relations.

Un n-uplet sur un ensemble d’attributs {A1,A2, ...,An} d’une relation R et une fonction u de
{A1,A2, ...,An}. On peut aussi dire plus simplement que la fonction u est constitué de n valeurs
(a1,a2, ...,an) telles que pour tout i = 1..n, la valeur ai appartient à l’attribut Ai.

Exemple soit le schéma de relation suivant :

Clients (code client, Société, Contact, Fonction, Adresse, Ville)


Commandes(N°commande, DateCommande, Datelivraison)
Articles(Ref, NomArticle, Prix)

A.BENMAKHLOUF 5
On a supposé que tous les attributs soient des propriétés qui décrivent le même objet (entité).
Cela n’est pas toujours vrai. En effet pour assurer la cohérence des informations qu’on veut
modéliser on doit introduire dans une relation un ou plusieurs attributs appartenant à un d’autres
entités. D’où la notion d’identifiant externe ou clé étrangère qu’on va expliquer dans le
paragraphe suivant. Dans l’exemple précédent nous devons le compléter en introduisant d’autre
attributs et d’autres relations pour savoir les commandes de chaque client et les articles
commandés dans chaque commande.

Clients (code client, Société, Contact, Fonction, Adresse, Ville)


Commandes(N°commande, DateCommande, Datelivraison, code client)
Articles(Ref, NomArticle, Prix)
LigneCommande(N°Commande, Ref, Quantité)

2-2 Règle de la modélisation relationnelle

a- Notion de dépendance fonctionnelle

Permet de passer d’un ensemble d’attribut non structuré à un modèle conceptuel de données puis
à un schéma de BDD cad à un ensemble de relation bien structuré. Cette notion nous aide donc
surtout dans l’étape de conception d’un modèle qui respecte au maximum la réalité.
Pour quoi on dit que A1 est un attribut de R1 et non pas de R2 ?

Définition : soit a1 et a2 des valeurs d’un attribut A et b1, b2 des valeurs d’un autre attribut B. on
dit que B est "fonctionnellement dépendant" de A (on note A → B) ou A défini B si :
𝑎1 = 𝑎2 ⇒ 𝑏1 = 𝑏2

Autrement dit on dit que A->B si pour chaque valeur de A on ne peut faire correspondre qu’une
seule valeur de B
soit une relation R(A1, A2, …., An). si A1 détermine tous les autres attribus A2, …., An :
A1 -> A2, …., An alots on peut dire que A1 est un identifiant de R : R(A1, A2, …., An).

On peut avoir des DF composées. Si A1 et A2 détermine tous les autres attribus A3, …., An on
peut dire que (A1, A2) est un ID composé.

Pour supprimer les redondances, nous devons avoir une dépendance fonctionnelle directe
(DFD) entre l’identifiant et les autres attributs non identifiantes de la relation. Une dépendance
fonctionnelle x → y est directe s’il n’existe pas de propriété z telle que :

A.BENMAKHLOUF 6
x → z et z → y.

b- Notion de la normalisation

Chaque relation dans le schéma de BDD doit être normalisée suivant trois formes normales FN:

1ère FN : Une relation est normalisée en 1ère FN si :


1. Elle possède une clé identifiant de manière unique et stable chaque ligne
2. Chaque attribut est monovalué (ne peut avoir qu’une seule valeur par ligne)
3. Aucun attribut n’est décomposable en plusieurs attributs significatifs

Contre-exemple :
EMPLOYE (Nom, Enfants, Diplômes)

2ème FN : Une relation R est en deuxième forme normale si et seulement si :


1. Elle est en 1FN
2. Tout attribut non clé est totalement dépendant de toute la clé. Autrement dit, aucun
des attributs ne dépend que d’une partie de la clé.

Contre-exemple :
LIGNE_COMMANDE(Num_cde, RéférenceProd, DésignationProd, Quantité)

3ème FN : Une relation est en 3ème forme normale si et seulement si :


1. Elle est en 2° forme normale
2. Tout attribut doit dépendre directement de la clé, c'est-à-dire qu’aucun attribut ne doit
dépendre de la clé par transitivité. Autrement dit, aucun attribut ne doit dépendre d’un
autre attribut non clé.

Contre-exemple :
CLIENT(Num_client, Nom_client, code_categ, nom_categ)

Un modèle relationnel normalisé = relations avec


➢ Une clé, qui permet de distinguer chaque occurrence
➢ Des attributs élémentaires (1FN)
➢ En dépendance de TOUTE la clé (2FN),
➢ Et RIEN QUE de la clé (3FN)

Donc d’après la 1ère FN les attributs sont tous simples et monovalués : toute valeur prise par un
attribut pour un tuple est atomique (non décomposable par le SGBD) et unique. Les notions
d'attribut multivalué ou complexe n'existent pas dans le modèle relationnel.

A.BENMAKHLOUF 7
Cas d'un attribut complexe :

Soit par exemple, un attribut complexe, Adresse, composé des attributs : n°bâtiment, nom-rue,
ville, code-postal. Si on veut ajouter cet attribut dans la relation Etudiant, il y a plusieurs
solutions.

Solution 1: On ajoute l'attribut Adresse qui a pour domaine les chaînes de caractères. Dans ce cas,
l'utilisateur ne peut pas poser de questions sur la ville, il devra lire l'adresse et chercher dans la
chaîne de caractères le nom de la ville lui-même, ou par programme.

Solution 2: On ajoute les attributs suivants : n°bâtiment, nom-rue, ville, code-postal à la relation.
Le SGBD connaît le détail de l'adresse, mais ne connaît pas la notion globale d'adresse.

La solution est choisie en fonction du type d'utilisation de l'attribut

Cas d'un attribut multivalué

Par exemple, on veut mémoriser les différents prénoms des étudiants (et non pas uniquement leur
premier prénom).

Solution 1: Avoir dans la relation Etudiant plusieurs attributs : Prénom1, Prénom2,... Problèmes :
combien mettre d'attributs Prénom ? Comment poser des questions sur cet attribut (on est obligé
de poser autant de questions que d'attributs déclarés !). C'est une mauvaise solution à ne pas
utiliser.

Solution 2: On ne garde que N°Etud, Nom, Age pour la relation Etudiant, et on crée une relation
supplémentaire pour l'attribut multivalué, EtudPrénoms :
Etudiant(N°Etud, Nom, Age)
EtudPrénoms(N°Etud, prénom)

c- Identifiant externe

Certains attributs référencent des tuples d'une autre relation (ou parfois de la même); c'est-à-dire
que leur valeur est toujours égale à celle de l'identifiant d'un tuple existant dans l'autre relation.
On les appelle identifiants externes (ou clés externes ou clés étrangères). Par exemple, la relation
LigneCommande(N°Commande, Ref, Quantité) possède un identifiant composé (N°Commande +
Ref), et deux identifiants externes : N°Commande et Ref. En effet, N°Commande "référence" une
commande, c'est à dire que si une valeur N°Commande existe dans la relation LigneCommande,

A.BENMAKHLOUF 8
alors il doit nécessairement exister dans la relation COmmande. De même, Ref de
ligneCommande "référence" à Ref d’article. on appelle cela une intégrité référentielle.
Le schéma d'une relation comprend donc, en plus de la définition du nom de la relation et de ses
attributs et domaines associés, la définition de son (ses) identifiant, et celle de ses identifiants
externes, s'il en existe.

Les identifiants externes sont déclarés de la façon suivante :

Clients (code client, Société, Contact, Fonction, Adresse, Ville)


Commandes(N°commande, DateCommande, Datelivraison, code client)
codeclient référence un Client.codeclient
Articles(Ref, NomArticle, Prix)
LigneCommande(N°Commande, Ref, Quantité)
Ref référence un article.Ref
N°Commande référence un Commande.N°Commande
Définition : Soient deux relations R1(X, Y) et R2 (V, W), où X, Y, V, W, désignent des attributs
ou des ensembles d'attributs, et où X est un identifiant de R1, on dit que W est un identifiant
externe sur R1 (ou que W référence R1) si pour tout tuple de R2, la valeur prise par W est
nécessairement la valeur de X pour un tuple existant de R1. Autrement dit, à tout instant,
l'ensemble des valeurs prises par W est compris dans l'ensemble des valeurs prises par X.
Une fois déclaré l'identifiant externe W de R2 sur R1, le SGBD vérifie automatiquement :
• toutes les insertions de tuples dans R2: il vérifie que la valeur de W existe dans R1. Si ce n'est
pas le cas l'insertion dans R2 est refusée ;
• toutes les modifications de W : il vérifie que la nouvelle valeur de W existe dans R1. Si ce n'est
pas le cas la modification est refusée ;
• toutes les suppressions de tuples de R1 : il vérifie qu'il n'existe pas de tuple dans R2 référençant
ce tuple de R1 à supprimer. S'il en existe, selon le SGBD soit la suppression est refusée, soit la
suppression est propagée : les tuples de R2 qui référençaient cette valeur de X sont eux aussi
supprimés.

Le SGBD assure ainsi, l'intégrité de référence (ou intégrité référentielle) de la base de données.

En SQL, la clause pour déclarer une clé externe sur la clé primaire d'une table est :
REFERENCES nom-table; celle pour déclarer une clé externe sur une clé candidate d'une table
est: REFERENCES nom-table (nom-attribut-clé-candidate).

d- Contraintes d'intégrité

A.BENMAKHLOUF 9
Ce sont des règles qui restreintes les valeurs que peuvent prendre les données de la base en plus
de l’intégrité référentielle, les SGBD relationnels offrent plusieurs mécanismes pour exprimer ces
contraintes d'intégrité. Comme par exemple dans Oracle :
❖ Attribut obligatoire : clause NOT NULL
❖ Identifiant : clauses PRIMARY KEY et UNIQUE
❖ Domaine de valeurs particulier d’un attribut : clause CHECK qui permet de vérifier que la
valeur de l'attribut satisfait une condition
❖ Contrainte d'intégrité quelconque : TRIGGER qui permet de spécifier que lors de toute
insertion (ou suppression ou modification) d'un tuple dans telle relation telle condition doit
être satisfaite sinon telle action doit être entreprise automatiquement par le SGBD, comme
par exemple refuser l'insertion ou envoyer un message d'alerte.

3. Algèbre relationnelle

L'algèbre relationnelle est une théorie mathématique proche de la théorie des ensembles qui
définit des opérations qui peuvent être effectuées sur des relations. Ces opérations permettent de
représenter des requêtes sur la base de données dont le résultat s’exprime sous la forme d’une
relation (i.e. table). C’est ce formalisme qui est au cœur du langage de requête de SQL.
L'algèbre relationnelle a été inventée en 1970. Cette algèbre est constituée d'un ensemble
d'opérations formelles sur les relations. Les opérations relationnelles permettent de créer une
nouvelle relation (table) à partir d'opérations élémentaires sur d'autres tables (par exemple
l'union, l'intersection, ou encore la différence).
Les principes de l'algèbre relationnelle sont beaucoup utilisés de nos jours par les SGBD pour la
gestion des bases de données informatiques comme le SQLserver, DBase, Access, etc.
Nous pouvons distinguer trois familles d’opérateurs relationnels :
- Les opérateurs unaires (la sélection et la projection), qui sont les plus simples, permettent de
produire une nouvelle table à partir d’une autre table.
- Les opérateurs binaires ensemblistes (l’union, l’intersection et la différence) permettent de
produire une nouvelle relation à partir de deux relations de même degré et de même domaine.
- Les opérateurs binaires ou n-aires (le produit cartésien, la jointure et la division) permettent
de produire une nouvelle table à partir de deux ou plusieurs autres tables.
Remarque : Les notations de l’algèbre relationnelle ne sont pas standardisées.

3.1. La Sélection

Définition : La sélection génère une relation regroupant exclusivement toutes les occurrences de
la relation R qui satisfont l’expression logique « E ».

A.BENMAKHLOUF 10
Notation : 𝝈(𝑬) 𝑹

E : l’expression logique
R : la Relation (Table) sur laquelle nous appliquons la sélection

La sélection permet ainsi de choisir (i.e. sélectionner) certaines lignes dans une table. Le résultat
de la sélection est donc une nouvelle relation qui a les mêmes attributs que R. Si R est vide
(c’est-à-dire sans aucune occurrence), la relation qui résulte de la sélection est vide.

Soit la relation PERSONNE suivante :

La sélection 𝝈(𝑷𝒓𝒊𝒙≥𝟐𝟎) 𝑷𝒓𝒐𝒅𝒖𝒊𝒕 donne la relation

3.2. Projection

Définition : La projection consiste à supprimer les attributs autres que (A1, A2,.., An) d’une
relation et à éliminer les n-uplets en double apparaissant dans la nouvelle version.
Notation : ∏(𝑨𝟏 ,𝑨𝟐 ,……,𝑨𝒏 ) 𝑹
(A1, A2,.., An) : les attributs à afficher

A.BENMAKHLOUF 11
R : la relation sur laquelle nous voulons appliquer la projection.
La projection permet de choisir des colonnes dans une table. Si R est vide, la relation qui résulte
de la projection est vide, mais pas forcément équivalente étant donné qu’elle contient
généralement moins d’attributs.

La projection ∏(𝑹𝒆𝒇𝑷𝒓𝒐𝒅𝒖𝒊𝒕,𝑵𝒐𝒎𝑷𝒓𝒐𝒅𝒖𝒊𝒕) 𝒑𝒓𝒐𝒅𝒖𝒊𝒕 donne la relation :

∏ 𝝈(𝑷𝒓𝒊𝒙≥𝟐𝟎) 𝑷𝒓𝒐𝒅𝒖𝒊𝒕
(𝑹𝒆𝒇𝑷𝒓𝒐𝒅𝒖𝒊𝒕,𝑵𝒐𝒎𝑷𝒓𝒐𝒅𝒖𝒊𝒕)

3.3. Union

A.BENMAKHLOUF 12
Définition : l’union est une opération portant sur deux relations R1 et R2 ayant le même schéma
(même attributs) et construisant une troisième relation constituée des n-uplets appartenant à l’une ou
l’autre des deux relations R1 et R2 sans doublon.

Notation : 𝑹𝟏 ∪ 𝑹𝟐
L’Union est une opération binaire ensembliste commutative sur R1 et R2 qui doivent avoir les mêmes
attributs et si une même occurrence existe dans R1 et R2, elle n’apparaît qu’une seule fois dans le
résultat de l’union. Le résultat de l’union est une nouvelle relation qui a les mêmes attributs que R 1 et
R2. Si R1 et R2 sont vides, la relation qui résulte de l’union est vide. Si R1 (respectivement R2) est vide,
la relation qui résulte de l’union est identique à R2 (respectivement R1).

Exemple :

En langage SQL cette opération de traduit par :

SELECT * from R1 UNION SELECT * from R2;

3.4. Intersection

A.BENMAKHLOUF 13
Définition : L’intersection est une opération portant sur deux relations R1 et R2 ayant le même
schéma et construisant une troisième relation dont les enregistrements sont constitués de ceux
appartenant aux deux relations. Notation 𝑹𝟏 ∩ 𝑹𝟐

Exemple :

En langage SQL cette opération de traduit par :

SELECT * from R1 WHERE EXISTS (SELECT * FROM R2 WHERE


R1.RefProduit=R2.RefProduit);

3.5. La différence

Définition : La différence est une opération portant sur deux relations R1 et R2 ayant le même
schéma et construisant une troisième relation dont les n-uplets sont constitués de ceux ne se
trouvant que dans la relation R1. Notation : R1 - R2.
Le résultat de la différence est une nouvelle relation qui a les mêmes attributs que R 1 et R2. Si R1 est
vide, la relation qui résulte de la différence est vide aussi. Si R2 est vide, la relation qui résulte de la
différence est identique à R1.

Exemple :

A.BENMAKHLOUF 14
R1 - R2
RefProduit NomProduit
34 Produit3
5 Produit4

En langage SQL cette opération de traduit par :

SELECT * FROM R1
WHERE R1. RefProduit NOT IN (SELECT RefProduit FROM R2);

Ou

SELECT * FROM R1
WHERE NOT EXISTS (SELECT * FROM R2 WHERE R1.RefProduit=R2.RefProduit);

3.6. Produit cartésien

Définition : Le produit cartésien est une opération portant sur deux relations R1 et R2 et qui
construit une troisième relation regroupant exclusivement toutes les possibilités de combinaison
des occurrences des relations R1 et R2. On note 𝑹𝟏 × 𝑹𝟐

Le résultat du produit cartésien est une nouvelle relation qui a tous les attributs de R1 et tous ceux
de R2.Si R1 ou R2 ou les deux sont vides, la relation qui résulte du produit cartésien est vide. Le
nombre d’occurrences de la relation qui résulte du produit cartésien est le nombre d’occurrences
de R1 multiplié par le nombre d’occurrences de R2.

Exemple :

A.BENMAKHLOUF 15
En langage SQL cette opération de traduit par :

SELECT * FROM R1, R2 ;

3.7. Jointure

Définition : La jointure est une opération portant sur deux relations R1 et R2 qui construit une
troisième relation regroupant exclusivement toutes les possibilités de combinaison des
occurrences des relations R1 et R2 qui satisfont l’expression logique E. Il s’agit d’une opération
binaire commutative. Une jointure est donc une sélection sur un produit cartésien.

On note : 𝝈(𝑬) (𝑹𝟏 × 𝑹𝟐 )

A.BENMAKHLOUF 16
En SQL :

SELECT * FROM R1, R2


WHERE C>=30 AND B="Z1";

3.8. Thêta-jointure

Définition : La thêta-jointure est une jointure dans laquelle l’expression logique E est une simple
comparaison entre un attribut A1 de la relation R1 et un attribut A2 de la relation R2.

3.9. Équi-jointure

Définition : Une équi-jointure est une thêta-jointure dans laquelle l’expression logique E
est un test d’égalité entre un attribut A1 de la relation R1 et un attribut A2 de la relation R2.

A.BENMAKHLOUF 17
En SQL l’équi-Jointure s’exprime :

SELECT * FROM R1, R2


WHERE A=E;

3.10. La division

Définition : la division est une opération portant sur deux relations R1 et R2, telles que le schéma
de R2 est strictement inclus dans celui de R1, qui génère une troisième relation regroupant toutes
les parties d’occurrences de la relation R1 qui, associées à toutes les occurrences de la relation
R2, se retrouvent dans R1.
Notation : R1÷ R2 = D.
Autrement dit un tuple r1 est dans D si seulement si pour tout tuple r2 de R2, le tuple (r1, r2) est
dans R1.

Soit R1={(a1, b1), (a1, b2), …. , (a1, bp), (a2, b1), (a2, b2), …. , (a2, bp)}
Et R2={b1, b2, …….., bp}

Donc D = R1÷R2 = {a1, a2}

A.BENMAKHLOUF 18
C-a-d D×R2 est inclus dans R1

L’opération Division répond en général aux requêtes de type « Tous les ».

Exemple1 :

En SQL il n’existe pas d’équivalence pour cette opération. Cependant il est toujours possible de
trouver une autre solution, notamment par l'intermédiaire des autres opérations de l’algèbre
relationnelle. On peut par exemple combiner les opérations produit cartésien avec la différence.

Pour l’exemple précédant la requête est :

SELECT D FROM R1
WHERE D NOT IN (SELECT D FROM (
SELECT D, A FROM R1 a, R2 WHERE
NOT EXISTS (SELECT * FROM R1 b WHERE b.D=a.D AND A=E)))
GROUP BY D;

En notation algébrique :

∏ 𝑅1 − ∏ (∏(𝑅1 × 𝑅2) − 𝑅1)


𝐷 𝐷 𝐷,𝐴
Exemple 2 :

A.BENMAKHLOUF 19
Soit le modèle relationnel suivant :

Etudiant(NumEtudiant, NomEtudiant, PrénomEtudiant)


Module(NumModule, NomModule)
Inscrits(NumEtudiant, NumModule)

La division de la relation « Inscrits » par la relation « Module » : (Inscrits ÷ Module) nous


donne la liste des étudiants qui sont inscrits dans tous les modules :
En SQL la requête est :

SELECT * FROM Etudiant WHERE NumEtudiant NOT IN (SELECT NumEtudiant


FROM (SELECT * FROM Etudiant, Module WHERE NOT EXISTS
(SELECT * FROM Inscrits WHERE Etudiant.NumEtudiant=Inscrits.NumEtudiant
AND Module.NumModule=Inscrits.NumModule)));

4. Les Index

La Recherche d’Information dans une BDD représente une importance considérable dans
n’importe quelque système d’information. Si cette recherche s’effectue d’une façon simplement
séquentielle (c'est à dire en examinant toute la table, ou du moins tous les champs concernés, du
début jusqu'à la fin), le temps d’attente peut devenir prohibitif pour l'opérateur. D’où
l’importance des index qui représentent un outil qui permet de résoudre ce problème.
Imaginons un dictionnaire dans le quelle les mots sont insérés n’importe comment. Pour
rechercher un mot il faut parcourir les pages une après une dans l’ordre (recherche séquentielle)
jusqu’à ce qu’on trouve le mot recherché ou bien on arrive à la dernière page et on conclut que le
mot n’existe pas dans le dictionnaire.
Bien entendu personne ne va choisir un dictionnaire pareil pour rechercher ces mots.
Heureusement que dans tous les dictionnaires les mots sont insérés par ordre alphabétique et donc
on va insérer sur chaque page un index qui n’est autre que la première lettre des mots qui
appartiennent à cette page. Si le mot que nous cherchons commence par « L ». Nous irons vers la
page du milieu et nous cherchons le mot. Si la page ouverte n’est pas la bonne on peut conclure si
on doit continuer notre recherche dans la moitié gauche ou droite de la page ouverte. Nous
arriverons beaucoup plus vite que précédemment à trouver le mot que nous recherchons. Nous
pouvons optimiser plus la recherche en pratiquant une indexation à plusieurs niveaux qui sera
représentée par les trois premières lettres.
Nous pouvons pratiquer cette technique efficace de recherche parce que les mots constituent
un ensemble ordonné (trier par ordre alphabétique). Dans un ensemble désordonné, on ne peut
pratiquer qu'une recherche séquentielle, beaucoup plus lente. Le rôle des index est rendu un
ensemble ordonné pour qu’on puisse faciliter la recherche.

A.BENMAKHLOUF 20
Dans les bases de données nous pouvons insérer des index sur les attributs pour faciliter les
recherches.

4.1. Le fonctionnement de l'index

En informatique un index est représenté par une table à une colonne, les valeurs de cette colonne
index d’une manière unique le contenu trié d’un attribut d’une relation. Prenant par exemple la
table « livres » ci-dessous.

Fig-1

Nous pouvons créer des index sur chaque attribut de cette table (Fig-2). Dans le premier index
(index sur le titre), le premier titre par ordre alphabétique correspond au livre n° 2 (Access), suivi
du livre n° 3 (Les écoles) et du livre n° 1 (Mon jardin). Les autres index s'interprètent de la même
façon.

Les avantages des index sont nombreux :

▪ Il accélère les recherches d'information. En effet, l'index est une représentation de la table,
triée sur un champ donné. On peut donc lui appliquer les méthodes connues de recherche
rapide sur un ensemble ordonné (c'est le SGBD qui se charge de l'opération, laquelle est
transparente pour l'opérateur)
▪ il est de taille très inférieure à celle de la table : on peut le remettre à jour en temps réel à
chaque modification de cette dernière.
▪ il peut servir à empêcher de créer des enregistrements dupliqués en saisissant deux fois,
par erreur, les mêmes données. Nous reviendrons sur ce point au paragraphe suivant.

A.BENMAKHLOUF 21
Les index présentent aussi des inconvenants :
-
Un index occupe de la place en mémoire sur le disque. Sauf que cet argument a beaucoup
perdu de sa valeur avec le temps, parce que la taille des mémoires de masse des
ordinateurs ne cessent de croître rapidement, et le coût ne cesse de diminuer.
- L’augmentation considérable du temps de traitement des données par la SGBDR étant
donné que les index sont mises à jour à chaque modification de la table à laquelle il est
rattaché.

Par conséquent il faut que la création d'index soit justifiée et que les colonnes sur
lesquelles il porte soient judicieusement choisies (de telle façon à minimiser les doublons).
Certains SGBDR, comme Access, créent automatiquement un index lorsqu'une clé primaire
est définie.

4.2. Les index multi-Attributs

Dans une table contenant plusieurs milliers de données, le risque de doublant des enregistrements
reste important. L’indexation nulti-attributs permet d’éviter ce problème en indexant plusieurs
champs à la fois.
Prenant l’exemple d’un annuaire téléphonique d’une grande ville. Pour accepter l'homonymie
tout en rejetant les doublons dus à des erreurs de saisie, on utilise un index basé sur plusieurs
attributs. Si la probabilité de trouver deux fois le nom "BERRADA" est importante, celle de
trouver deux fois le nom et prénom "BERRADA Mohamed" est déjà nettement plus faible, et
celle de trouver deux fois "BERRADA Mohamed né le 09/06/1989" est pratiquement nulle. En
créant un index sur trois champs (Nom + Prénom + Date de naissance), on peut rejeter les
doublons dus à des erreurs de saisie tout en tolérant parfaitement l'homonymie.
5. Langage SQL

SQL est un langage normalisé non procédural et ensembliste. C’est un langage complet de
gestion de bases de données relationnelles. Il permet de :

- définir les données (Langage de Définition de Données LDD) (ordres CREATE,


ALTER, DROP),
- manipuler les données (Langage de Manipulation de Données LMD) (ordres UPDATE,
INSERT, DELETE)
- interroger une base de données (ordre SELECT)
- contrôler l'accès aux données (Langage de Contrôle de Données LCD) (ordres GRANT,
REVOKE).

L'intérêt de SQL est que c'est un langage SQL utilisé par les principaux SGBDR : Oracle, Access,

A.BENMAKHLOUF 22
SQL server, MySQL… Chacun de ces SGBDR a cependant sa propre variante du langage. Dans
ce chapitre nous présentons un noyau de commandes disponibles sur l'ensemble de ces SGBDR,

5.1. La définition des données LDD

La première série de commandes sert à la maintenance de la base de données : création des tables
et des indexes, modification de la structure d'une table ou suppression d'une table ou d'un index.
SQL dispose pour cela des instructions suivantes :
ALTER TABLE
CREATE TABLE
CREATE INDEX

5.1.1. La commande CREATE TABLE

La commande CREATE TABLE permet de créer une table dans la base de données courante. Sa
syntaxe est la suivante :

CREATE TABLE NomTable (champ1 type propriété, champ2 type


propriété,.. );

Paramètre Signification

Champ Nom du champ


Type - Char(x)
- Integer
- Date
- BIT (logique)

propriétés - NULL ou NOT NULL : autorise ou non que le champ


puisse être vide.
- UNIQUE : indique que deux enregistrements ne pourront
avoir la même valeur dans ce champ.
- PRIMARY KEY : indique que ce champ est la clé
primaire

Exemple : créer une table « Client » dans la BDD « basevente » avec les champs « IDclient » de
type réel et de propriété clé primaire, NomClient de type texte et de propriété non nulle etc….

A.BENMAKHLOUF 23
CREATE TABLE basevente.Client
(IDClient FLOAT PRIMARY KEY,
NomClient TEXT NOT NULL,
PrenomClient TEXT NOT NULL,
AdresseClient TEXT NOT NULL)

5.1.2. La commande ALTER TABLE

La commande ALTER TABLE permet de modifier la structure d'une table, sa syntaxe est la
suivante

ALTER TABLE NomTable Action (spécifications du champ);

ALTER TABLE permet trois actions, ces actions sont :


ADD Ajoute un champ a une table
DROP Supprime un champ d'une table
MODIFY Modifie les caractéristiques d'un champ

Après l'action, on indique, entre parenthèses, les spécifications du champ de la même façon que
pour la commande CREATE TABLE. On ne peut faire qu'une action à la fois (ajout, suppression
ou modification dans la même commande).

Exemple :

Ajout d'un champ :

ALTER TABLE Client ADD "date naissance" Date;


Suppression d’un champ :

ALTER TABLE Client DROP "date naissance"

Remarque :

Dans le cas d’un nom d’un attribut ou d’une table qui est composé de plusieurs mots, il faut
utiliser les guillemets.

5.2. Les types de donnée

Dans les BDD on peut utiliser des données de différentes types : numériques, chaînes de

A.BENMAKHLOUF 24
Caractères, date et logique. pour la syntaxe des types de données nous nous focalisons dans ce
cours sur le SQL Oracle.

5.2.1. Type Numérique.

Un seul type numérique NUMBER. Lors de la définition d’une colonne de type numérique, on
peut préciser le nombre maximum de chiffres et de décimales qu’une valeur de cette colonne
pourra contenir

NUMBER
NUMBER(taille_maxi)
NUMBER(taille_maxi, décimales)

Si le paramètre décimal n’est pas spécifié, 0 est pris par défaut. La valeur absolue du nombre doit
être inférieur à 10128. NUMBER est un nombre à virgule flottante (on ne précise pas le nombre
de chiffres après la virgule) qui peut avoir jusqu’à 38 chiffres significatifs.
•Exemple : NUMBER(6,2) 6 chiffres dont 2 après la virgule

5.2.2. Type Chaine de caractère.

Les constantes chaînes de caractères sont entourées par des apostrophes. Il existe deux types pour
les colonnes qui contiennent des chaînes de caractères :
- le type CHAR pour les colonnes qui contiennent des chaînes de longueur constante
inférieure à 2000 octets (pour Oracle). Cette chaîne de caractères est complétée par des
espaces si le nombre de char est inférieur à la longueur fixé dans char(),
o CHAR(longueur)

- le type VARCHAR2 pour les colonnes qui contiennent des chaînes de longueur variable.
Tous les SGBD ont une longueur maximale pour ces chaînes (4000 sous Oracle).
o VARCHAR2(longueur) longueur est la longueur maximale en nombre de
caractères qu’il sera possible de stocker dans le champ

5.2.3. Type Date

Une constante de type DATE est une chaîne de caractères entre apostrophes. Le format dépend
des options que l’administrateur a choisies au moment de la création de la base. S’il a choisi de
franciser la base, le format est jour/mois/année, par exemple '12/03/02' (le format américain par
défaut donnerait '13-MAR-02'). L’utilisateur peut saisir les dates telles ’1/3/02' mais les dates

A.BENMAKHLOUF 25
enregistrées dans la base ont toujours 2 chiffres pour chacun des nombres. Dans Oracle, un type
DATE inclut un temps en heures, minutes et secondes.
o DATE

5.2.4. Type Logique

ce type est utiliser pour choisir dans la saisie entre vrai et faux (1 ou 0). Dans oracle il y a la
clause CHECK() qui permet de définir ce type de données.

o CHECK (NomChamp IN (0,1))

5.2.5. Type auto incrémentation : Les séquences

Afin de créer des attributs dont les valeurs sont affectées automatiquement par incrémentation
nous devons créer avant une séquence. Cette dernière Permet de définir une suite de nombres
entiers, de clés uniques, de compteurs pour des tables.

Syntaxe de création d’une séquence.

CREATE SEQUENCE [schéma.]nomSéquence


[INCREMENT BY entier ]
[START WITH entier ]
[ { MAXVALUE entier | NOMAXVALUE } ]
[ { MINVALUE entier | NOMINVALUE } ]
[ { CYCLE | NOCYCLE } ]
[ { CACHE entier | NOCACHE } ]
[ { ORDER | NOORDER } ] ;

SYNTAXE DESCRIPTION
INCREMENT BY intervalle entre les deux valeurs de la séquence (par défaut 1).
START WITH première valeur de la séquence à générer.
MAXVALUE valeur maximale de la séquence.
MINVALUE valeur minimale de la séquence.
CYCLE la séquence continuera de générer des valeurs après avoir atteint sa limite.
NOCYCLE la séquence s'arretera de générer des valeurs après avoir atteint sa limite.

A.BENMAKHLOUF 26
CACHE les valeurs de la séquence seront mises en cache.
NOCACHE les valeurs de la séquence ne seront pas dans le cache.
ORDER les séquences sont générées dans l’ordre des requêtes.

5.3. Les contraintes

Ce sont les règles de validation que doit vérifier les données saisies dans chaque attrinuts.

5.3.1. Les contraintes de domaine

Il s’agit de définir l’ensemble des valeurs que peut prendre un attribut. Ces contraintes sont
décrites dans la définition d’un attribut, directement après son type et sa longueur.
NOT NULL : on impose que l’attribut possède une valeur
DEFAULT : on spécifie une valeur par défaut dont le type doit correspondre au type de l’attribut
UNIQUE : interdit qu’une colonne contienne deux valeurs identiques.

CREATE TABLE clients (numCli… nomCliVARCHAR(25) NOT NULL, CaCliINTEGER


DEFAULT0, TypeCliVARCHAR(16) DEFAULT 'Particulier’ …);

CREATE TABLE fournisseurs (... NomFourCHAR(25) NOT NULL UNIQUE, ..);

CHECK(condition) : Cette clause permet de spécifier une contrainte qui doit être vérifiée à tout
moment par les tuples de la table. On peut placer un nombre quelconque de telles clauses dans la
définition d’une table. La clause peut même être placée après la définition de tous les attributs.

CREATE TABLE clients (…, TypeCliVARCHAR(16) DEFAULT 'Particulier'


CHECK (TypeCli IN ('Particulier', 'Administration', 'PME'))
CONSTRAINT TypeCli, …

Liv_LigneCdeNUMBER DEFAULT 0
CHECK(Liv_LigneCde<= Qté_LigneCde)
CONSTRAINT Liv_LigneCde, …

CHECK(PU_LigneCde >= 0.8 * (SELECT PV_Art FROM articles WHERE


NumArt= Art_LigneCde))
CONSTRAINT PU_LigneCde

La déclaration d’un domaine

A.BENMAKHLOUF 27
Cette clause permet de spécifier que différents attributs du schéma ont le même ensemble de
valeurs et satisfont les mêmes contraintes.

Exemple : CREATE DOMAIN QtéNUMBER DEFAULT 0 CHECK (Value >= 0),

Cette clause permet de spécifier que différents attributs du schéma ont le même ensemble de
valeurs et satisfont les mêmes contraintes.
Définition des attributs dont les valeurs appartiennent au domaine Qté:
Stock_Art Qté
Qté_LigneCdeQté
...
De cette façon, Stock_Art et Qté_LigneCdehéritent des propriétés de Qté, valeur entière par
défaut nulle, toujours positive ou nulle.

5.3.2. Les contraintes d’intégrité d’entité

PRIMARY KEY : Elles spécifient la clé primaire d’une table via la clause. Elledoit toujours
avoir une valeur déterminée et unique pour la table. Quand une clé primaire est constituée de
plusieurs attributs (clé segmentée), la clause PRIMARY KEY est placée avant la définition des
attributs, séparée par une virgule.

Exemples :

- NumCliNUMBER PRIMARY KEY


- CreateTABLE Appartement
(…),
PRIMARY KEY(NumApp, NumImm);

Remarques : tous les attributs d’une clé segmentée doivent être spécifiés NOT NULL.
PRIMARY KEY peut aussi être séparée de la définition des attributs même s’il n’y a qu’un seul
attribut. Pour une table, il n’existe qu’une seule clé primaire. Dans beaucoup de SGBD, un index
est automatiquement construit sur la clé primaire.

5.3.3. Les contraintes d’intégrité référentielle

REFERENCES nom_table_référencée (clé candidate) : permet de définir dans une table une
clé étrangère qui fait référence à une clé d’une autre table.

A.BENMAKHLOUF 28
Exemples :
CREATE TABLE Commandes (NumCdeNUMBER PRIMARY KEY,
DateCdeDATE NOT NULL,
NumCli NUMBER NOT NULL REFERENCES clients(NumCli),
MagCde NUMBER NOT NULL REFERENCES magasins(MagCde));

Spécification des actions à effectuer en cas de modification (clause ON UPDATE) ou de


suppression (clause ON DELETE) de valeurs de clés référencées :
CASCADE, SET NULL, SET DEFAULT

Exemple :
NumFourNUMBER REFERENCES fournisseurs
ON UPDATE CASCADE ON DELETE SET NULL;

5.3.4. Les assertions

Il s’agit de contraintes non directement rattachées à une table. Elles sont utilisées pour spécifier
une contrainte portant sur plusieurs tables.

CREATE ASSERTION nom_assertion ...

Exemple :
CREATE ASSERTIONVal_Glob_Stock
CHECK (
(SELECT SUM(Art1_PA * Art1_Stock) FROM Articles1) +
(SELECT SUM(Art2_PA * Art2_Stock) FROM Articles2) <100000);

5.4. La manipulation des données MDL

Une fois les tables créées, on peut commencer à y insérer ou supprimer des enregistrements, mettre à jour
des données. Toutes ces opérations sont des opérations de manipulation des bases de données.
Pour effectuer ces manipulations, SQL dispose de 5 instructions :
INSERT
UPDATE
DELETE

5.4.1. La commande INSERT

La commande INSERT est utilisée pour ajouter des enregistrements ou des parties
d'enregistrements dans des tables. Elle est utilisée généralement sous deux formes :

A.BENMAKHLOUF 29
ère
1 forme

INSERT INTO table (champ1, champ2,...)


VALUES ('valeur1','valeur2',...);

Si des valeurs doivent être insérées dans tous les champs de l'enregistrement de la table, la liste
des noms des champs n'a pas besoin d'être explicitement indiquée dans la commande. Les valeurs
des champs à insérer doivent cependant apparaître dans le même ordre que les noms des champs
lors de la création de la table, sans oublier un seul champ. Faites attention en utilisant cette
syntaxe, si la structure de la table change plus tard, la commande qui était bonne risque de ne plus
fonctionner correctement. Il vaut mieux toujours indiquer explicitement le nom des champs sur
lesquels on veut agir.

Exemple : on veut insérer trois nouveaux enregistrements dans la table « Entreprise »

INSERT INTO Entreprise ("Code Entreprise",Société,"Adresse


société",Ville)
VALUES
(1, 'BMCE', 'rue racine', 'rabat'),
(2,'CIH', 'rue des FAR', 'Fes'),
(3, 'BP', 'Bd MedV', 'rabat')

ème
2 forme

INSERT INTO "table1" ("column1", "column2", ...)


SELECT "column3", "column4", ...
FROM "table2"

Dans cette seconde forme, le résultat de la requête va être inséré dans les champs indiqués de la
table. Cette méthode est utilisée lorsque plusieurs enregistrements sont ajoutés simultanément.
Nous devons maintenant utiliser une instruction SELECT pour spécifier les données à ajouter à la
table. Nous sommes donc en train d’insérer des données provenant d’une autre table.
Dans les deux cas, les valeurs insérées doivent correspondre au type de données du champ dans
lequel l'insertion va être faite, on ne peut pas, par exemple demander l'insertion d'une chaîne de
caractères dans un champ de type numérique ou monétaire. Les chaînes de caractères doivent être
placées entre apostrophes ( ' ), les champs numériques ou vides (NULL) ne doivent pas être
placés entre apostrophes.

5.4.2. La commande UPDATE

A.BENMAKHLOUF 30
La commande UPDATE est utilisée pour changer des valeurs dans des champs d'une table. Sa
syntaxe est :

UPDATE Nomtable
SET champ1 = nouvelle_valeur1,
champ2 = nouvelle_valeur2,
champ3 = nouvelle_valeur3
WHEREcondition;

La clause SET indique quels champs de la table vont être mis à jour et avec quelles valeurs ils
vont l'être. Les champs non spécifiés après la clause SET ne seront pas modifiés.
Par exemple, si nous voulons, dans la table produit, modifier le prix d'un produit dont le nom est
"prod1", nous taperons :

UPDATE produits
SET prix_unitaire = 1000
WHERE libelle = 'prod1';

La commande UPDATE affecte tous les enregistrements qui répondent à la condition donnée
dans la clause WHERE. Si la clause WHERE est absente, tous les enregistrements de la table
seront affectés.

Par exemple, si nous tapons :

UPDATE produits
SET prix_unitaire = 1000;

Le prix unitaire de TOUS les produits de la table produit va être modifié.


Tout comme la commande INSERT, la commande UPDATE peut contenir une requête. Dans ce
cas la syntaxe est la suivante :

UPDATE table
SET champ1 = nouvelle_valeur1,
champ2 = nouvelle_valeur2,
champ3 = nouvelle_valeur3
WHERE condition
(requête);

La requête est une requête faite avec la commande SELECT.

5.4.3. La commande DELETE

A.BENMAKHLOUF 31
Pour supprimer des enregistrements d'une table, utilisez la commande DELETE. La syntaxe est
la suivante :

DELETE
FROM table
WHERE condition;

On ne peut pas supprimer seulement le contenu de quelques champs des enregistrements. La


commande DELETE supprime des enregistrements entiers, c'est pour cela qu'il n'est pas
nécessaire d'indiquer ici des noms de champs. La condition spécifiée après WHERE va
déterminer quels sont les enregistrements à supprimer.
Par exemple, pour supprimer tous les clients dont la ville est Saint-Quentin :

DELETE FROM Clients WHERE ville='Saint-Quentin';

Pour supprimer tous les enregistrements d'une table, n'indiquez pas de clause WHERE :

5.4.4. La commande SELECT

La commande SELECT est la commande la plus complexe de SQL. Cette commande va servir à
faire des requêtes pour récupérer des données dans les tables. Elle peut être associée à une des
commandes de manipulation de tables vues avant.

a. Requêtes simples

Une requête simple est créée à partir d’une seule table


La syntaxe est la suivante :

SELECT `champ1`, `champ2`, `champ3`, ...


FROM table;

S'il y a plus d'un champ spécifié après SELECT, les champs doivent être séparés par des virgules.
Les champs sont retournés dans l'ordre spécifié après la clause SELECT, et non pas dans l'ordre
qu'ils ont été créés dans la table.

Par exemple :

Pour sélectionner les champs "prénom" et "nom" de tous les enregistrements de la table Clients :
SELECT 'prénom', 'nom'

A.BENMAKHLOUF 32
FROM clients

Va renvoyer les prénom et nom de tous les clients de la table Clients.


Si on veut récupérer tous les champs des enregistrements sélectionnés, la syntaxe est la suivante :

SELECT *
FROM table;

Les clauses SELECT et FROM doivent obligatoirement apparaître au début de chaque requête,

b. Requêtes simples avec critère (clause WHERE)

On peut, ensuite, indiquer des critères de sélection avec la clause WHERE :

SELECT *
FROM table
WHERE condition ;

Par exemple, pour sélectionner tous les Clients de la table "Clients" dont le code postal est 75000:

SELECT *
FROM Clients
WHERE 'code_postal' = 75000;

On peut utiliser les opérateurs suivants dans la clause


WHERE :

Opérateur Signification
= Egal
<> ou != Différent
< Inférieur
> Supérieur
<= Inférieur ou égal
>= Supérieur ou égal
BETWEEN Entre deux valeurs
LIKE Comme (contient)
NOT LIKE Ne contient pas
IS NULL La case est vide
IS NOT NULL La case n’est pas vide

A.BENMAKHLOUF 33
Exemple : Pour sélectionner tous les articles dont le prix est supérieur à 100 F :

SELECT *
FROM Clients
WHERE prix_unitaire > 100;

Dans le cas où on doit utiliser plusieurs critères combinés ou alternatifs, nous devons utiliser les
opérateurs logiques AND et OR.

SELECT *
FROM Clients
WHERE Ville_Client = 'Casablanca' OR Ville_Client = 'Rabat'

i. Opérateur Classement (ORDER BY)

Pour classer les valeurs d’un champ on utilise l’opérateur ORDER BY

- Classement croissant :
SELECT `champ1`, `Champ2`
From table
ORDER BY `Champ2`

- Classement décroissant :
SELECT `champ1`, `Champ2`
From table
ORDER BY `Champ2` DESC

ii. Clauses IN et BETWEEN

Pour sélectionner des enregistrements dont la valeur d'un champ peut être comprise dans une liste
ou entre deux valeurs, on utilise les clauses IN et BETWEEN.
Par exemple : Pour sélectionner les clients vivant à Saint-Quentin ou Paris :

SELECT *
FROM Clients
WHERE `ville` IN ('Saint-Quentin', 'Paris');

Ou pour sélectionner les produits dont le prix est compris entre 100 et 1000 F :

A.BENMAKHLOUF 34
SELECT *
FROM Produits
WHERE `prix_unitaire` BETWEEN 100 AND 1000;

Pour sélectionner les produits dont le prix n'est pas dans cet intervalle :

SELECT *
FROM Produits
WHERE `prix_unitaire` NOT BETWEEN 100 AND 1000;

De la même façon, NOT IN sélectionne les enregistrements exclus de la liste spécifiée après IN.

iii. La clause LIKE

La clause LIKE permet de faire des recherches approximatives sur le contenu d'un champ. Par
exemple, pour sélectionner les clients dont le nom commence par la lettre D :

SELECT *
FROM Clients
WHERE `nom` LIKE 'S*';

Tout comme dans les requêtes Access, le symbole * remplace un ensemble de caractères, pour
représenter tous les noms commençant par S, on utilisera 'S*', tous ceux se terminant par S, on
utilisera '*S', et tous ceux comportant la lettre S : '*S*'. Le symbole ? ne remplace qu'un seul
caractère. Si on a deux clients nommés Dupond et Dupont, on utilisera 'Dupon?'.

c. Requêtes simples avec calcule sur les dates : clause Extract()

Cette clause permet d’extraire une partie d’une donnée de type date. Elle doit être combinée avec
les commandes Year, Month et Day afin de préciser la partie de la date à extraire.
La commande SYSDATE revoie la date du système (la date actuelle).

Exemple :

a- Les fonctions Dates

Exemple : pour sélectionner les commandes réalisées cette année, on exécute la requête suivante :

SELECT N°Commande, DateCommande

A.BENMAKHLOUF 35
FROM Commande
WHERE EXTRACT(year from DateCommande)=EXTRACT(year from SysDate)

d. Requête avec création de nouveau champ avec formule

Pour créer une requête avec création de nouveau champ nous combinons la commande « select »
avec la commande « As »

SELECT `champ 1`, formule AS `nouveau_champ`


From table ;

Exemple : pour calculer le montant total

SELECT `nom du produit`, Prix_unitaire * Quantité As Montant


From `détail commande`

e. Requête multi tables (les jointures)

La jointure va nous permettre de sélectionner des informations dans plusieurs tables grâce aux
relations existant entre ces tables. Il va néanmoins falloir indiquer comment se fait la relation
entre ces tables.
i. Jointure interne

Exemple :

Liste des employés avec le N° de Commande réalisée

SELECT NomEmployé , PrenomEmployé, N°Commande


FROM Employé INNER JOIN Commande
ON Employé.N°Employé = Commande.N°Employé

La clause FROM indique de ne conserver dans le produit cartésien des tables Employé et
Commande que les éléments pour lesquels le numéro de l’employé provenant de la table
Employé est le même que le numéro de l’employé provenant de la table Commande. Ainsi, on
obtiendra bien une jointure entre les tables Employé et Commande d'après le N°Employé.

Par opposition aux jointures externes que l'on va bientôt étudier, on peut ajouter le mot clé
INNER :

ii. Jointure externe

A.BENMAKHLOUF 36
Dans la sélection précédente, un employé qui n'a pas réalisé de commande n'apparaîtra jamais
dans la liste, puisqu'il n'y aura dans le produit cartésien des deux tables aucun élément où l'on
trouve une égalité des colonnes N°Employé.
On pourrait pourtant désirer afficher une liste de tous les employés, avec leurs commandes, sans
omettre les employés sans commandes. On écrira alors :

SELECT Employé.N°Employé, N°Commande


FROM Employé LEFT OUTER JOIN Commande
ON Employé.N°Employé = Commande.N°Employé

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 (une commande
fictive) est ajoutée dans la table des commandes si un employé n'a pas de commande. 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 employé) 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 (avant le RIGHT OUTER JOIN) et FULL OUTER JOIN si
on veut afficher toutes les lignes des deux tables.

N°Employé N°Commande

E1 C1

E2 C1

E3 C2

E4 C2

E5 Null

E6 Null

E7 Null

f. Supprimer les doubles avec DISTINCT

Supposons que nous voulions la liste des clients ayant acheté quelque chose. Nous voulons que
chaque client ayant acheté quelque chose ne soit affiché qu'une seule fois – nous ne voulons pas
savoir ce qu'a acheté chaque client – nous voulons juste connaître les clients qui ont acheté
quelque chose. Pour cela, nous allons devoir dire à SQL de supprimer les doubles du résultat de

A.BENMAKHLOUF 37
la sélection pour n'afficher les clients qu'une seule fois. Pour cela, nous allons utiliser la clause
DISTINCT.
Nous allons d'abord faire une jointure entre les tables Clients et Commande, et ajouter la clause
DISTINCT sur le champ ou la répétition peut se produire :

SELECT Client.`num_client`, nom, prénom, N°Commande


FROM Clients INNER JOIN Commande
WHERE Commande.num_client = Client.num_client;

Si on exécute cette requête directement, SQL va nous renvoyer une liste des numéros, prénom et
nom correspondants aux noms et prénoms des clients ayant passé chaque commande, il est clair
qu'un client ayant passé plusieurs commandes va se retrouver plusieurs fois dans cette liste.

SELECT DISTINCT Clients.num_client,nom, prénom, N°Commande


FROM Clients INNER JOIN Commande
WHERE Commande.num_client = Client.num_client AND num_commande = 1;

En indiquant la clause DISTINCT avant le champ num_client, on indique à SQL qu'on ne veut
pas voir apparaître plusieurs fois un client ayant ce numéro dans la sélection renvoyée.
On peut même rendre le résultat de la sélection plus agréable à la lecture en utilisant la clause
ORDERBY :

g. Les fonctions d'ensemble

SQL a cinq fonctions importantes : SUM, AVG, MAX, MIN et COUNT. On les appelle
fonctions d'ensemble parce qu'elles résument le résultat d'une requête plutôt que de renvoyer une
liste d'enregistrements.

Fonction Signification

SUM () Donne le total d'un champ de tous les enregistrements satisfaisant la


condition de la requête. Le champ doit bien sur être de type numérique
AVG() donne la moyenne d'un champ de tous les enregistrements satisfaisant
la condition de la requête
MAX() donne la valeur la plus élevée d'un champ de tous les enregistrements
satisfaisant la condition de la requête
MIN() Donne la valeur la plus petite d'un champ de tous les enregistrements
satisfaisant la condition de la requête.
COUNT() Renvoie le nombre d'enregistrements satisfaisant la requête.

A.BENMAKHLOUF 38
Exemples :

SELECT MIN(prix_unitaire),MAX(prix_unitaire),AVG(prix_unitaire)

Va retourner le prix le plus petit de la table Produit, le prix le plus élevé et le prix moyen.

SELECT COUNT (Ref-Produit)


FROM Produits
WHERE libelle LIKE 'P*';

Va retourner le nombre de produits dont le libellé commence par la lettre 'P'

A.BENMAKHLOUF 39
h. La clause GROUP BY

Une des utilisations les plus courantes de la clause GROUP BY est son association avec une
fonction d'ensemble (la fonction COUNT, pour compter le nombre d'enregistrements dans
chaque groupe). Par exemple, si nous voulons la liste des vendeurs, avec pour chaque vendeur
le nombre de ventes qu'il a fait :

SELECT num_vendeur,COUNT (N°Commande) AS Nbre


FROM Commandes
GROUP BY num_vendeur;

On peut ajouter une condition à la requête, par exemple, la liste des vendeurs avec leur
nombre de vente pour le mois de janvier.

SELECT num_vendeur,COUNT (*)


FROM Commandes
GROUP BY num_vendeur
HAVING mois(date)=1;

On utilisera pour cela la clause HAVING.

i. Les sous-requêtes

On peut imbriquer autant de requêtes que l'on veut. La condition après la clause WHERE peut
porter sur le résultat d'une autre requête (ou sous-requête).
Supposons les tables suivantes :

Cette table contient, pour chaque acheteur, le produit qu'il a acheté et le prix d'achat.
Nous voulons la liste des acheteurs ayant acheté des articles chers. Nous considérerons qu'un
article cher est un article dont le prix est supérieur à la moyenne du prix des produits achetés
+ 100 francs.

SELECT Num_acheteur
FROM Vente
WHERE prix >
(SELECT AVG (prix) + 100 FROM Vente);

40
Vous pouvez constater que condition de la requête est basée sur le résultat d'une autre requête.
Dans cet exemple, à chaque fois qu'un acheteur aura acheté un article cher, son numéro
apparaîtra, pour éviter cela, on utilise la clause DISTINCT num_acheteur pour éliminer les
doubles.
Autre exemple avec ces deux tables : nous savons qu'il y a une erreur sur l'orthographe du
nom de l'acheteur du produit n° 1, il devrait s'appeler 'Dupont' :

UPDATE Acheteurs SET nom = 'Dupont'


WHERE num_acheteur =
(SELECT num_acheteur FROM Ventes WHERE num_article = 1

j. Les UNIONs

Lorsqu'on veut que les résultats de plusieurs requêtes soient combinés entre eux, on utilise la
clause UNION. UNION va fusionner les résultats des requêtes.
Par exemple, supposons que nous ayons une table pour les clients habitant Saint-Quentin
(cette table s'appellera clients_stq) et une table pour les clients habitant Paris (clients_Paris).
Pour obtenir les numéros des clients des deux tables, on tapera :
SELECT num_client
FROM clients_stq UNION SELECT num_client FROM clients_paris;

5.5. Les Vues matérialisées

Dans les systèmes de gestion de base de données de type relationnel, une vue est une table
virtuelle représentant le résultat d’une requête sur la base. Les données des vues ne peuvent
être changées. La mise à jour des données doit se faire dans les tables que nous avons utilisées
pour obtenir la vue. De plus une vue s’exécute chaque fois qu’elle est appelée dans une autre
vue, ce qui augmente le temps de réponse des requêtes complexe où on utilise des sous-
requêtes. Dans une vue matérialisée (VM), comme son nom l’indique, les données sont
dupliquées dans des tables qui ne s’exécutent pas une fois appelées. C’est pour cette raison
qu’On les utilise essentiellement à des fins d'optimisation et de performance dans le cas où la
requête associée est particulièrement complexe ou lourde. La mise à jour des données dans
des vues matérialisées se fait automatiquement. La fraîcheur des données de la vue
matérialisée dépend des options choisies lors de sa création. Le décalage entre les données des
tables maîtres et la vue matérialisée peut être nul (rafraîchissement synchrone) ou d'une durée
planifiée : heure, jour, etc. Suivant le contexte il existe différents types de vue matérialisée
possibles : sur clé primaire, rowid (identifiant unique des tuples), et plus ou moins
complexes : avec fonctions d'agrégation, sous-requêtes, jointures, etc.

41
La syntaxe pour créer une VM est :

CREATE MATERIALIZED VIEW Nom_Vue AS


SELECT Col1, Col2, [...], Coln FROM Nom_Table

Pour créer une vue matérialisée avec précision de la fréquence de rafraichissement sous
Oracle :

CREATE MATERIALIZED VIEW Nom_Vue


REFRESH FAST
START WITH SYSDATE
NEXT SYSDATE + 1 AS
SELECT Col1, Col2, [...], Coln FROM Nom_Tab

42

Vous aimerez peut-être aussi