Cours SQL

Base du langage SQL et des bases de

données

1
SQL SELECT
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. Cette commande peut sélectionner une ou
plusieurs colonnes d’une table.

2
Commande basique
L’utilisation basique de cette commande s’effectue de
la manière suivante :
SELECT nom_du_champ
FROM nom_du_tableau
Cette requête va sélectionner (SELECT) le champ
«nom_du_champ » provenant (FROM) du tableau
appelé « nom_du_tableau ».
Exemple
Imaginons une base de données appelée « client »
qui contient des informations sur les clients d’une
entreprise.
3
Table « client » :

identifiant prenom nom ville

1 Pierre Dupond Paris
2 Sabrina Durand Nantes
3 Julien Martin Lyon
4 David Bernard Marseille
5 Marie Leroy Grenoble

4
Si on veut avoir la liste de toutes les villes des clients,
il suffit d’effectuer la requête suivante :
SELECT ville
FROM client

Résultat :

ville
Paris
Nantes
Lyon
Marseille
Grenoble
5
Obtenir plusieurs colonnes
Avec la même table client il est possible de lire
plusieurs colonnes à la fois. Il suffit tout simplement
de séparer les noms des champs souhaités par une
virgule. Pour obtenir les prénoms et les noms des
clients il faut alors faire la requête suivante :
SELECT prenom, nom
FROM client

6
Résultat :

prenom nom
Pierre Dupond
Sabrina Durand
Julien Martin
David Bernard
Marie Leroy

Obtenir toutes les colonnes d’un tableau

Il est possible de retourner automatiquement toutes
les colonnes d’un tableau sans avoir à connaître le
nom de toutes les colonnes.
7
Au lieu de lister toutes les colonnes, il faut
simplement utiliser le caractère « * » (étoile). C’est
un joker qui permet de sélectionner toutes les
colonnes. Il s’utilise de la manière suivante :
SELECT * FROM client

Cette requête retourne exactement les mêmes

colonnes qu’il y a dans la base de données.
Dans notre cas, le résultat sera donc :

8
Identifiant prenom nom ville
1 Pierre Dupond Paris
2 Sabrina Durand Nantes
3 Julien Martin Lyon
4 David Bernard Marseille
5 Marie Leroy Grenoble

Il y a des avantages et des inconvénients à l’utiliser.

Pour en savoir plus sur le sujet il est recommandé de
faire une recherche sur les avantages et
inconvénients du sélecteur étoile.

9
Cours avancé : ordre des commandes du SELECT
Cette commande SQL est relativement commune car
il est très fréquent de devoir lire les données issues
d’une base de données. Il existe plusieurs
commandes qui permettent de mieux gérer les
données que l’on souhaite lire. Voici un petit aperçu
des fonctionnalités possibles :

10
 • Joindre un autre tableau aux résultats
• Filtrer pour ne sélectionner que certains
enregistrements
• Classer les résultats
• Grouper les résultats pour faire
uniquement des statistiques (note
moyenne, prix le plus élevé … )
Une requête « SELECT » peut devenir assez
longue. Juste à titre informatif, voici une
requête « SELECT » qui possède presque
toutes les commandes possibles :
11
SELECT *
FROM table
WHERE condition
GROUP BY expression
HAVING condition
{ UNION | INTERSECT | EXCEPT }
ORDER BY expression
LIMIT count
OFFSET start

12
A noter : cette requête sert d’aide-mémoire pour
savoir dans quel ordre sont utilisé chacun des
commandes au sein d’une requête SELECT.

13
SQL DISTINCT
L’utilisation de la commande SELECT en SQL permet
de lire les données d’une ou plusieurs colonnes.
Cette commande peut potentiellement afficher
des lignes en doubles. Pour éviter des
redondances dans les résultats il faut simplement
ajouter DISTINCT après le mot SELECT.

14
Commande basique
L’utilisation basique de cette commande consiste
alors à effectuer la requête suivante :
SELECT DISTINCT ma_colonne
FROM nom_du_tableau

Cette requête sélectionne le champ « ma_colonne »

de la table « nom_du_tableau » en évitant de
retourner des doublons.

15
Requête pour Oracle
Pour le Système de Gestion de Bases de Données
(SGBD) Oracle, cette requête est remplacée par la
commande « UNIQUE » :
SELECT UNIQUE ma_colonne
FROM nom_du_tableau

16
Exemple
Prenons le cas d’une table « client » qui contient des
noms et prénoms :

identifiant prenom nom

1 Pierre Dupond
2 Sabrina Bernard
3 David Durand
4 Pierre Leroy
5 Marie Leroy

17
En utilisant seulement SELECT tout les noms sont
retournés, or la table contient plusieurs fois le
même prénom (cf. Pierre). Pour sélectionner
uniquement les prénoms uniques il faut utiliser la
requête suivante :
SELECT DISTINCT prenom
FROM client

18
Résultat :
prenom
Pierre
Sabrina
David
Marie

Ce résultat affiche volontairement qu’une seule fois

le prénom « Pierre » grâce à l’utilisation de la
commande DISTINCT qui n’affiche que les
résultats distincts.

19
Intérêt
L’utilisation de la commande DISTINCT est très
pratique pour éviter les résultats en doubles.
Cependant, pour optimiser les performances il est
préférable d’utiliser la commande SQL GROUP BY
lorsque c’est possible.

20
SQL AS (alias)
Dans le langage SQL il est possible d’utiliser des
alias pour renommer temporairement une colonne
ou une table dans une requête. Cette astuce est
particulièrement utile pour faciliter la lecture des
requêtes.
Intérêts et utilités - Alias sur une colonne
Permet de renommer le nom d’une colonne dans les
résultats d’une requête SQL. C’est pratique pour
avoir un nom facilement identifiable dans une
application qui doit ensuite exploiter les résultats
d’une recherche.
21
Cas concrets d’utilisations :
• Une colonne qui s’appelle normalement
c_iso_3166 peut être renommée « code_pays »
(cf. le code ISO 3166 correspond au code des
pays), ce qui est plus simple à comprendre dans
le reste du code par un développeur.
• Une requête qui utilise la commande UNION sur

des champs aux noms différents peut être ambigu

pour un développeur. En renommant les champs
avec un même nom il est plus simple de traiter les
résultats.

22
• Lorsqu’une fonction est utilisée, le nom d’une
colonne peut-être un peu complexe. Il est ainsi
possible de renommer la colonne sur laquelle il y
a une fonction SQL. Exemple : SELECT
COUNT(*) AS nombre_de_resultats FROM
`table`.
• Lorsque plusieurs colonnes sont combinées il est
plus simple de renommer la nouvelle colonne qui
est une concaténation de plusieurs champs.

23
4

1
SQL GROUP BY
La commande GROUP BY est utilisée en SQL pour
grouper plusieurs résultats et utiliser une fonction de
totaux sur un groupe de résultat. Sur une table qui
contient toutes les ventes d’un magasin, il est par
exemple possible de liste regrouper les ventes par
clients identiques et d’obtenir le coût total des achats
pour chaque client.

Syntaxe d’utilisation de GROUP BY

De façon générale, la commande GROUP BY s’utilise
de la façon suivante :

2
SELECT colonne1,
fonction(colonne2) FROM
table
GROUP BY colonne1

A noter : cette commande doit toujours s’utiliser

après la commande WHERE et avant la commande
HAVING.

Exemple d’utilisation
Prenons en considération une table « achat » qui
résume les ventes d’une boutique :
3
id client tarif date
1 Pierre 102 2012-10-
23
2 Simon 47 2012-10-
27
3 Marie 18 2012-11-
05
4 Marie 20 2012-11-
14
5 Pierre 160 2012-12-
03

Ce tableau contient une colonne qui sert

d’identifiant pour chaque ligne, une autre qui 4
contient le nom du client, le coût de la vente et la
date d’achat.
Pour obtenir le coût total de chaque client en
regroupant les commandes des mêmes clients, il faut
utiliser la requête suivante :
SELECTclient,
SUM(tarif) FROM achat
GROUP BY client

La fonction SUM() permet d’additionner la valeur de

chaque tarif pour un même client. Le résultat sera
donc le suivant :
5
client SUM(tarif)
Pierre 262
Simon 47
Marie 38

6
La manière simple de comprendre le GROUP BY
c’est tout simplement d’assimiler qu’il va éviter de
présenter plusieurs fois les mêmes lignes. C’est une
méthode pour éviter les doublons.
Juste à titre informatif, voici ce qu’on obtient de la
requête sans utiliser GROUP BY.

Requête :
SELECT client, SUM(tarif)
FROM achat

Résultat :

7
client SUM(tarif)
Pierre 262
Simon 47
Marie 38
Marie 38
Pierre 262

Utilisation d’autres fonctions de statistiques

Il existe plusieurs fonctions qui peuvent être
utilisées pour manipuler plusieurs enregistrements,
il s’agit des fonctions d’agrégations statistiques, les
principales sont les suivantes :
• AVG() pour calculer la moyenne d’un set de

8
 valeur. Permet de connaître le prix du panier
moyen pour de chaque client
• COUNT() pour compter le nombre de lignes
concernées. Permet de savoir combien d’achats a
été effectué par chaque client
• MAX() pour récupérer la plus haute valeur.
Pratique pour savoir l’achat le plus cher
• MIN() pour récupérer la plus petite valeur. Utile

par exemple pour connaître la date du premier

achat d’un client
• SUM() pour calculer la somme de plusieurs lignes.

Permet par exemple de connaître le total

de tous les achats d’un client
Ces petites fonctions se révèlent rapidement
indispensable pour travailler sur des données.
9
SQL HAVING
La condition HAVING en SQL est presque similaire à
WHERE à la seule différence que HAVING permet de
filtrer en utilisant des fonctions telles que SUM(),
COUNT(), AVG(), MIN() ou MAX().

Syntaxe
L’utilisation de HAVING s’utilise de la manière
suivante:

10
SELECT colonne1,
SUM(colonne2) FROM
nom_table
GROUP BY colonne1
HAVING fonction(colonne2) operateur valeur

Cela permet donc de SÉLECTIONNER les colonnes

DE la table « nom_table » en GROUPANT les lignes
qui ont des valeurs identiques sur la colonne
"colonne1" et que la condition de HAVING soit
respectée.
Important : HAVING est très souvent utilisé en 11
même temps que GROUP BY bien que ce ne soit
pas obligatoire.

Exemple
Pour utiliser un exemple concret, imaginons une
table « achat » qui contient les achats de différents
clients avec le coût du panier pour chaque achat.

id client tarif date_achat

1 Pierre 102 2012-10-23
2 Simon 47 2012-10-27
3 Marie 18 2012-11-05
4 Marie 20 2012-11-14
5 Pierre 160 2012-12-03
12
Si dans cette table on souhaite récupérer la liste des
clients qui ont commandé plus de 40€, toute
commandes confondues alors il est possible d’utiliser
la requête suivante :
SELECT client,
SUM(tarif) FROM achat
GROUP BY client
HAVING SUM(tarif) > 40

Résultat :

13
 client SUM(tarif)
Pierre 162
Simon 47

14
La cliente « Marie » a cumulée
38€ d’achat (un achat de 18€ et
un autre de 20€) ce qui est
inférieur à la limite de 40€
imposée par HAVING. En
conséquent cette ligne n’est pas
affichée dans le résultat.

15
SQL ORDER BY
La commande ORDER BY permet de trier les lignes
dans un résultat d’une requête SQL. Il est possible
de trier les données sur une ou plusieurs colonnes,
par ordre ascendant ou descendant.

Syntaxe
Une requête où l’ont souhaite filtrer l’ordre des
résultats utilise la commande ORDER BY de la sorte :
SELECT colonne1,
colonne2 FROM table
ORDER BY colonne1
16
Par défaut les résultats sont classés par ordre
ascendant, toutefois il est possible d’inverser l’ordre
en utilisant le suffixe DESC après le nom de la
colonne. Par ailleurs, il est possible de trier sur
plusieurs colonnes en les séparant par une virgule.
Une requête plus élaboré ressemblerais alors cela :
SELECT colonne1,
colonne2, colonne3 FROM
table
ORDER BY colonne1 DESC, colonne2 ASC

17
A noter : il n’est pas obligé d’utiliser le suffixe « ASC »
sachant que les résultats sont toujours classé par
ordre ascendant par défaut. Toutefois, c’est plus
pratique pour mieux s’y retrouver, surtout si on a
oublié l’ordre par défaut.

Exemple
Pour l’ensemble de nos exemple, nous allons
prendre une base « utilisateur » de test, qui contient
les données suivantes :

18
id nom prenom date_inscription tarif_total

1 Durand Maurice 2012- 145

02-05
2 Dupond Fabrice 2012- 65
02-07
3 Durand Fabienn 2012- 90
e 02-13
4 Dubois Chloé 2012- 98
02-16
5 Dubois Simon 2012- 27
02-23

Pour récupérer la liste de ces utilisateurs par ordre

19
alphabétique du nom de famille, il est possible
d’utiliser la requête suivante :
SELECT *
FROM utilisateur
ORDER BY nom

Résultat :

20
id nom prenom date_inscription tarif_tot
al
4 Dubois Chloé 2012- 98
02-16
5 Dubois Simon 2012- 27
02-23
2 Dupond Fabrice 2012- 65
02-07
1 Durand Maurice 2012- 145
02-05
3 Durand Fabienn 2012- 90
e 02-13

En utilisant deux méthodes de tri, il est possible de

21
retourner les utilisateurs par ordre alphabétique ET
pour ceux qui ont le même nom de famille, les trier
par ordre décroissant d’inscription. La requête serait
alors la suivante :
SELECT *
FROM utilisateur
ORDER BY nom, date_inscription DESC

Résultat :

22
id nom prenom date_inscription tarif_tot
al
5 Dubois Simon 2012- 27
02-23
4 Dubois Chloé 2012- 98
02-16
2 Dupond Fabrice 2012- 65
02-07
3 Durand Fabienn 2012- 90
e 02-13
1 Durand Maurice 2012- 145
02-05

23
SQL CASE
Dans le langage SQL, la commande « CASE … WHEN … »
permet d’utiliser des conditions de type
« si / sinon » (cf. if / else) similaire à un langage de
programmation pour retourner un résultat disponible
entre plusieurs possibilités. Le CASE peut être utilisé
dans n’importe quelle instruction ou clause, telle que
SELECT, UPDATE, DELETE, WHERE, ORDER BY ou HAVING.

Syntaxe
L’utilisation du CASE est possible de 2 manières
différentes:

24
 • Comparer une colonne à un set de résultat possible
• Élaborer une série de conditions booléennes pour
déterminer un résultat
Comparer une colonne à un set de résultat

25
Voici la syntaxe nécessaire pour comparer une colonne à

CASE a
WHEN 1 THEN 'un'
WHEN 2 THEN 'deux'
WHEN 3 THEN 'trois'

ELSE 'autre'
END
un set d’enregistrement :
Dans cet exemple les valeurs contenus dans la colonne
«a» sont comparé à 1, 2 ou 3. Si la condition est vrai,
26
alors la valeur située après le THEN sera retournée.
A noter : la condition ELSE est facultative et sert de
ramasse-miette. Si les conditions précédentes ne sont
pas respectées alors ce sera la valeur du ELSE qui sera
retournée par défaut.

Élaborer une série de conditions booléennes pour

déterminer un résultat
Il est possible d’établir des conditions plus complexes
pour récupérer un résultat ou un autre. Cela s’effectue
en utilisant la syntaxe suivante :

27
CASE
WHEN a=b THEN 'A égal à B'
WHEN a>b THEN 'A supérieur à B' ELSE 'A
inférieuràB'
END

Dans cet exemple les colonnes « a », « b » et « c »

peuvent contenir des valeurs numériques. Lorsqu’elles
sont respectées, les conditions booléennes permettent
de rentrer dans l’une ou l’autre des conditions.
28
Il est possible de reproduire le premier exemple
présenté sur cette page en utilisant la syntaxe
suivante:
CASE
WHEN a=1 THEN 'un'

WHEN a=2 THEN 'deux'

WHEN a=3 THEN 'trois'
ELSE 'autre'
END

29
Exemple
Pour présenter le CASE dans le langage SQL il est
possible d’imaginer une base de données utilisées par un
site de vente en ligne. Dans cette base il y a une table
contenant les achats, cette table contient le nom des
produits, le prix unitaire, la quantité achetée et une
colonne consacrée à une marge fictive sur certains
produits.
Table « achat » :

30
id nom surcharge prix_unitaire quantite
1 Produit 1.3 6 3
A
2 Produit 1.5 8 2
B
3 Produit 0.75 7 4
C
4 Produit 1 15 2
D

Afficher un message selon une condition

31
Il est possible d’effectuer une requête qui va afficher un
message personnalisé en fonction de la valeur de la
marge. Le message sera différent selon que la marge soit
égale à 1, supérieur à 1 ou inférieure à 1. La requête
peut se présenter de la façon suivante :

32
égale à 1, supérieur à 1 ou inférieure à 1. La requête
peut se présenter de la façon suivante :

SELECT id, nom, marge_pourcentage,

prix_unitaire, quantite, CASE
WHEN marge_pourcentage=1 THEN 'Prix
ordinaire'
WHEN marge_pourcentage>1 THEN 'Prix
supérieur à la normale' ELSE 'Prix
inférieur à la normale'

END
FROM `achat`
Résultat :

i nom surcharge prix_unitaire quantite CASE

d
1 Prod 1.3 6 3 Prix supérieur à
uit A la normale
2 Prod 1.5 8 2 Prix supérieur à
uit B la normale
3 Prod 0.75 7 4 Prix inférieur à
uit C la normale
4 Prod 1 15 2 Prix ordinaire
uit D

34
Ce résultat montre qu’il est possible d’afficher
facilement des messages personnalisés selon des
conditions simples.

35
Afficher un prix unitaire différent selon une
condition
Avec un CASE il est aussi possible d’utiliser des requêtes
13
SELECT id, nom, marge_pourcentage,
prix_unitaire, quantite, CASE
WHEN marge_pourcentage=1 THEN
prix_unitaire WHEN
marge_pourcentage>1 THEN
prix_unitaire*2 ELSE
prix_unitaire/2
End FROM `achat`
plus élaborées. Imaginons maintenant que nous
souhaitions multiplier le prix unitaire par 2 si la marge
est supérieur à 1, la diviser par 2 si la marge est inférieure
à 1 et laisser le prix unitaire tel quel si la marge est égale
à 1. C’est possible grâce à la requête SQL :

Résultat :

37
id nom surcharge prix_unitaire quantite CASE
1 Produit 1.3 6 3 12
A
2 Produit 1.5 8 2 16
B
3 Produit 0.75 7 4 3.5
C
4 Produit 1 15 2 15
D

Comparer un champ à une valeur donnée

Imaginons maintenant que l’application propose des

38
réductions selon le nombre de produits achetés :
• 1 produit acheté permet d’obtenir une réduction de -

5% pour le prochain achat

• 2 produit acheté permet d’obtenir une réduction de -

6% pour le prochain achat

• 3 produit acheté permet d’obtenir une réduction de -

8% pour le prochain achat

• Pour plus de produits achetés il y a un réduction de -

10% pour le prochain achat

Pour effectuer une telle procédure, il est possible de
comparer la colonne « quantite » aux différentes valeurs
spécifiées et d’afficher un message personnalisé en
fonction du résultat. Cela peut être réalisé avec cette
39
requête SQL :

40
 18
SELECT id, nom, marge_pourcentage,
prix_unitaire, quantite, CASE quantite
WHEN 0 THEN 'Erreur'
WHEN 1 THEN 'Offre de -5% pour le
prochain achat' WHEN 2 THEN 'Offre
de -6% pour le prochain achat' WHEN
3 THEN 'Offre de -8% pour le
prochain achat' ELSE 'Offre de -10%
pour le prochain achat'
END
FROM `achat`
Résultat :

19
i nom surcharge prix_unitaire quantite CASE
d
1 Prod 1.3 6 3 Offre de -8% pour
uit A le prochain achat
2 Prod 1.5 8 2 Offre de -6% pour
uit B le prochain achat
3 Prod 0.75 7 4 Offre de -
uit C 10% pour le
prochain achat
4 Prod 1 15 2 Offre de -6% pour
uit D le prochain achat

Astuce : la condition ELSE peut parfois être utilisée pour

29
44
gérer les erreurs.
UPDATE avec CASE
Comme cela a été expliqué au début, il est aussi possible
d’utiliser le CASE à la suite de la commande SET d’un
UPDATE pour mettre à jour une colonne avec une
données spécifique selon une règle. Imaginons par
exemple que l’ont souhaite offrir un produit pour tous les
achats qui ont une surcharge inférieur à 1 et que l’ont
souhaite retirer un produit pour tous les achats avec une
surcharge supérieur à 1. Il est possible d’utiliser la
requête SQL suivante :
UPDATE `achat` SET
`quantite` = (
CASE
WHEN `surcharge` < 1 THEN
`quantite` + 1 WHEN
`surcharge` > 1 THEN
`quantite` - 1 ELSE quantite
END
)
SQL UNION
La commande UNION de SQL permet de mettre bout-à-
bout les résultats de plusieurs requêtes utilisant elles-
même la commande SELECT. C’est donc une commande
qui permet de concaténer les résultats de 2 requêtes ou
plus. Pour l’utiliser il est nécessaire que chacune des
requêtes à concaténer retournes le même nombre de
colonnes, avec les mêmes types de données et dans le
même ordre.
A savoir : par défaut, les enregistrements exactement
identiques ne seront pas répétés dans les résultats. Pour
effectuer une union dans laquelle même les lignes
dupliquées sont affichées il faut plutôt utiliser la
commande UNION ALL.

Syntaxe
La syntaxe pour unir les résultats de 2 tableaux sans
afficher les doublons est la suivante :
SELECT * FROM table1

UNION * FROM table2

SELECT

4
Schéma explicatif
L’union de 2 ensembles A et B est un concept qui
consiste à obtenir tous les éléments qui correspondent à
la fois à l’ensemble A ou à l’ensemble B. Cela se résume
très simplement par un petit schéma où la zone en bleu
correspond à la zone que l’ont souhaite obtenir (dans
notre cas : tous les éléments).

5
 Union de 2 ensembles
Exemple
Imaginons une entreprise qui possède plusieurs
magasins et dans chacun de ces magasins il y a une table
qui liste les clients.
La table du magasin n°1 s’appelle « magasin1_client » et
contient les données suivantes :

6
prenom nom ville date_naissance total_achat
Léon Dupuis Paris 1983-03-06 135
Marie Bernard Paris 1993-07-03 75
Sophie Dupond Marseill 1986-02-22 27
e
Marcel Martin Paris 1976-11-24 39

La table du magasin n°2 s’appelle « magasin2_client » et

contient les données suivantes :

5
7
prenom nom ville date_naissance total_achat
Marion Leroy Lyon 1982-10-27 285
Paul Moreau Lyon 1976-04-19 133
Marie Bernard Paris 1993-07-03 75
Marcel Martin Paris 1976-11-24 39

Sachant que certains clients sont présents dans les 2

tables, pour éviter de retourner plusieurs fois les mêmes
enregistrement, il convient d’utiliser la requête UNION.
La requête SQL est alors la suivante:
SELECT * FROM
magasin1_client
UNION
SELECT * FROM magasin2_client
 Résultat :
prenom nom ville date_na total_ac
issance hat
Léon Dupuis Paris 1983-03- 135
06
Marie Bernard Paris 1993-07- 75
03
Sophie Dupond Marseill 1986-02- 27
e 22
Marcel Martin Paris 1976-11- 39
24
10
Marion Leroy Lyon 1982-10- 285
27
Paul Moreau Lyon 1976-04- 133
19

Le résultat de cette requête montre bien que les

enregistrements des 2 requêtes sont mis bout-à- bout
mais sans inclure plusieurs fois les mêmes lignes.
SQL UNION ALL
La commande UNION ALL de SQL est très similaire à la
commande UNION. Elle permet de concaténer les
enregistrements de plusieurs requêtes, à la seule
différence que cette commande permet d’inclure tous les
enregistrements, même les doublons. Ainsi, si un même
enregistrement est présents normalement dans les
résultats des 2 requêtes concaténées, alors l’union des 2
avec UNION ALL retournera 2 fois ce même résultat.
A savoir : tout comme la commande UNION, il convient
que les 2 requêtes retournes exactement le même
nombre de colonnes, avec les mêmes types de données
10
12
et dans le même ordre.

Syntaxe
La syntaxe de la requête SQL pour unir les résultats des 2
tables est la suivante :
SELECT * FROM
table1 UNION ALL
SELECT * FROM table2
Exemple
Imaginons une entreprise qui possède des bases de
données dans chacun de ces magasins. Sur ces bases de
données il y a une table de la liste des clients avec
quelques informations et le total des achats dans
l’entreprise.
La table « magasin1_client » correspond au premier
magasin :
prenom nom ville date_na total_ac
issance hat
Léon Dupuis Paris 1983-03- 135
06
Marie Bernard Paris 1993-07- 75
03
Sophie Dupond Marseill 1986-02- 27
e 22
Marcel Martin Paris 1976-11- 39
24

La table « magasin2_client » correspond au deuxième

magasin :
prenom nom ville date_na total_ac
issance hat
Marion Leroy Lyon 1982-10- 285
27
Paul Moreau Lyon 1976-04- 133
19
Marie Bernard Paris 1993-07- 75
03
Marcel Martin Paris 1976-11- 39
24

Pour concaténer les tous les enregistrements de ces

tables, il est possible d’effectuer une seule requête
utilisant la commande UNION ALL, comme l’exemple
ci-dessous :
SELECT * FROM
magasin1_client UNION ALL
SELECT * FROM magasin2_client
 Résultat :
prenom nom ville date_naissance total_achat

Léon Dupuis Paris 1983-03- 135

06
Marie Bernard Paris 1993-07- 75
03
Sophie Dupond Marseill 1986-02- 27
e 22
Marcel Martin Paris 1976-11- 39
24
19
Marion Leroy Lyon 1982-10- 285
27
Paul Moreau Lyon 1976-04- 133
19
Marie Bernard Paris 1993-07- 75
03
Marcel Martin Paris 1976-11- 39
24

Le résultat de cette requête montre qu’il y a autant

d’enregistrement que dans les 2 tables réunis. A savoir, il
y a quelques clients qui étaient présents dans les 2 tables
d’origines en conséquent ils sont présent 2 fois dans le
résultat de cette requête SQL.
SQL INTERSECT
La commande SQL INTERSECT permet d’obtenir
l’intersection des résultats de 2 requêtes. Cette
commande permet donc de récupérer les enregistrements
communs à 2 requêtes. Cela peut s’avérer utile lorsqu’il
faut trouver s’il y a des données similaires sur 2 tables
distinctes.
A savoir : pour l’utiliser convenablement il faut que les
2 requêtes retournent le même nombre de colonnes,
avec les mêmes types et dans le même ordre.

Syntaxe
La syntaxe à adopter pour utiliser cette
commande est la suivante :
SELECT * FROM
table1INTERSECT
SELECT * FROM table2

2
3
Dans cet exemple, il faut que les 2 tables soient similaires
(mêmes colonnes, mêmes types et même ordre). Le
résultat correspondra aux enregistrements qui existent
dans table1 et dans table2.

Schéma explicatif
L’intersection de 2 ensembles A et B correspond aux
éléments qui sont présent dans A et dans B, et seulement
ceux-là. Cela peut être représenté par un schéma
explicatif simple ou l’intersection de A et B correspond à la
zone en bleu.
 Intersection de 2 ensembles
Exemple
Prenons l’exemple de 2 magasins qui appartiennent au
même groupe. Chaque magasin possède sa table de
clients.
La table du magasin n°1 est « magasin1_client » :
prenom nom ville date_na total_ac
issance hat
Léon Dupuis Paris 1983-03- 135
06
Marie Bernard Paris 1993-07- 75
03
Sophie Dupond Marseill 1986-02- 27
e 22
Marcel Martin Paris 1976-11- 39
24

La table du magasin n°2 est « magasin2_client » :

prenom nom ville date_na total_ac

issance hat
Marion Leroy Lyon 1982-10- 285
27
Paul Moreau Lyon 1976-04- 133
2
19 7
Marie Bernard Paris 1993-07- 75
03
Marcel Martin Paris 1976-11- 39
24

Pour obtenir la liste des clients qui sont présents de

façon identiques dans ces 2 tables, il est possible
d’utiliser la commande INTERSECT de la façon suivante :
SELECT * FROM magasin1_client
INTERSECT
SELECT * FROM magasin2_client

2
8
 Résultat :
prenom nom ville date_na total_ac
issance hat
Marie Bernard Paris 1993-07- 75
03
Marcel Martin Paris 1976-11- 39
24

Le résultat présente 2 enregistrements, il s’agit des

clients qui sont à la fois dans la table « magasin1_client »
2
et dans la table « magasin2_client». Sur certains 9
systèmes une telle requête permet de déceler des
erreurs et d’enregistrer seulement à un seul endroit la
même information.
6

31
SQL EXCEPT / MINUS
Dans le langage SQL la commande EXCEPT s’utilise entre 2
instructions pour récupérer les enregistrements de la
première instruction sans inclure les résultats de la
seconde requête. Si un même enregistrement devait être
présent dans les résultats des 2 syntaxes, ils ne seront pas
présent dans le résultat final.
A savoir : cette commande s’appelle différemment selon
les Systèmes de Gestion de Base de Données (SGBD) :
• EXCEPT : PostgreSQL

• MINUS : MySQL et Oracle

Dès lors, il faut remplacer tout le reste de ce cours par

10
32
 MINUS pour les SGBD correspondants.
Syntaxe
La syntaxe d’une requête SQL est toute simple :
SELECT * FROM table1
EXCEPT
SELECT * FROM table2

33
Cette requête permet de lister les résultats du table 1
sans inclure les enregistrements de la table 1 qui sont
aussi dans la table 2.
Attention : les colonnes de la première requête
doivent être similaires entre la première et la
deuxième requête (même nombre, même type et
même ordre).

Schéma explicatif
Cette commande permet de récupérer les éléments de
l’ensemble A sans prendre en compte les éléments de A
qui sont aussi présent dans l’ensemble B. Dans le
schéma ci-dessous seule la zone bleu sera retournée
 grâce à la commande EXCEPT (ou MINUS).

Sélection d’un ensemble avec

Exemple exception
Imaginons un système informatique d’une entreprise. Ce
système contient 2 tables contenant des
35
listes de clients :
• Une table « clients_inscrits » qui contient les prénoms,
noms et date d’inscription de clients
• Une table « clients_refus_email » qui contient les

informations des clients qui ne souhaitent pas être

contacté par email
Cet exemple aura pour objectif de sélectionner les
utilisateurs pour envoyer un email d’information. Les
utilisateurs de la deuxième table ne devront pas
apparaître dans les résultats.
Table « clients_inscrits » :
id prenom nom date_inscri
ption
1 Lionel Martineau 2012-11-14
2 Paul Cornu 2012-12-15
3 Sarah Schmitt 2012-12-17
4 Sabine Lenoir 2012-12-18

Table « clients_refus_email » :
id prenom nom date_inscri
ption
1 Paul Cornu 2013-01-27
2 Manuel Guillot 2013-01-27
3 Sabine Lenoir 2013-01-29
4 Natalie Petitjean 2013-02-03

Pour pouvoir sélectionner uniquement le prénom et le

nom des utilisateurs qui accepte de recevoir des emails
informatifs. La requête SQL à utiliser est la suivante :
SELECT prenom, nom FROM clients_inscrits
EXCEPT
SELECT prenom, nom FROM clients_refus_email
 Résultats
prenom
: nom
Lionel Martineau
Sarah Schmitt

Ce tableau de résultats montre bien les utilisateurs qui

sont dans inscrits et qui ne sont pas présent dans le
deuxième tableau. Par ailleurs, les résultats du deuxième
tableau ne sont pas présents sur ce résultat final.

40
SQL INSERT INTO
L’insertion de données dans une table s’effectue à
l’aide de la commande INSERT INTO. Cette commande
permet au choix d’inclure une seule ligne à la base
existante ou plusieurs lignes d’un coup.

Insertion d’une ligne à la fois

Pour insérer des données dans une base, il y a 2 syntaxes
principales :
• Insérer une ligne en indiquant les informations pour
chaque colonne existante (en respectant l’ordre)
• Insérer une ligne en spécifiant les colonnes que vous
souhaiter compléter. Il est possible
d’insérer une ligne en renseigner seulement une
partie des colonnes
Insérer une ligne en spécifiant toutes les colonnes
La syntaxe pour remplir une ligne avec cette méthode est
la suivante :
INSERT INTO table
VALUES ('valeur 1',
'valeur 2', ...)

20
42
Cette syntaxe possède les avantages et inconvénients
suivants :
• Obliger de remplir toutes les données, tout en
respectant l’ordre des colonnes
• Il n’y a pas le nom de colonne, donc les fautes de

frappe sont limitées. Par ailleurs, les colonnes

peuvent être renommées sans avoir à changer la
requête
• L’ordre des colonnes doit resté identique sinon
certaines valeurs prennent le risque d’être
complétée dans la mauvaise colonne
Insérer une ligne en spécifiant seulement les colonnes
souhaitées
Cette deuxième solution est très similaire, excepté qu’il
faut indiquer le nom des colonnes avant « VALUES ». La
syntaxe est la suivante :
INSERT INTO table
(nom_colonne_1, nom_colonne_2,
... VALUES ('valeur 1',
'valeur 2', ...)

44
A noter : il est possible de ne pas renseigner toutes les
colonnes. De plus, l’ordre des colonnes n’est pas
important.

Insertion de plusieurs lignes à la fois

Il est possible d’ajouter plusieurs lignes à un tableau
avec une seule requête. Pour ce faire, il convient
d’utiliser la syntaxe suivante :
INSERT INTO client (prenom,
nom, ville, age) VALUES
('Rébecca', 'Armand', 'Saint-Didier-des-
Bois', 24),
('Aimée', 'Hebert', 'Marigny-le-Châtel',
36),
('Marielle', 'Ribeiro', 'Maillères', 27),
('Hilaire', 'Savary', 'Conie-Molitard',
58);
A noter : lorsque le champ à remplir est de type
VARCHAR ou TEXT il faut indiquer le texte entre
guillemet simple. En revanche, lorsque la colonne est un
numérique tel que INT ou BIGINT il n’y a pas besoin
d’utiliser de guillemet, il suffit juste d’indiquer le
nombre.
Un tel exemple sur une table vide va créer le tableau
suivant :

id prenom nom ville age

1 Rébecc Armand Saint-Didier- 24
a des-Bois
2 Aimée Hebert Marigny-le- 36
 Châtel
3 Marielle Ribeiro Maillères 27
4 Hilaire Savary Conie-Molitard 58
SQL ON DUPLICATE KEY UPDATE
L’instruction ON DUPLICATE KEY UPDATE est une
fonctionnalité de MySQL qui permet de mettre à jour des
données lorsqu’un enregistrement existe déjà dans une
table. Cela permet d’avoir qu’une seule requête SQL pour
effectuer selon la convenance un INSERT ou un UPDATE.

Syntaxe
Cette commande s’effectue au sein de la requête INSERT
INTO avec la syntaxe suivante :
INSERT INTO table (a, b, c)
VALUES (1, 20, 68)
ON DUPLICATE KEY UPDATE a=a+1
49
A noter : cette requête se traduit comme suit :
1. insérer les données a, b et c avec les données
respectives de 1, 20 et 68
2. Si la clé primaire existe déjà pour ces valeurs alors

seulement faire une mise à jour de a = a+1

Exemple avec la commande WHERE

Grâce à la commande « ON DUPLICATE KEY » Il est
possible d’enregistrer la date à laquelle la données est
insérée pour la première fois et la date de dernière
mise à jour, comme le montre la commande ci-dessous:
 INSERT INTO table (a, b, c, date_insert)
VALUES (1, 20, 1, NOW())
ON DUPLICATE KEY UPDATE date_update=NOW
WHERE c=1

A noter : cette requête se traduit comme suit :

1. insérer les données a, b, c et date_insert, avec les
données respectives de 1, 20, 1 ainsi que la date et
l’heure actuelle
2. Si la clé primaire existe déjà pour ces valeurs alors

mettre a jour la date et l’heure du champ «

date_update »
3. Effectuer la mise à jour uniquement sur les champs où

c=1
Exemple
Imaginons une application qui laisse les utilisateurs voter
pour les produits qu’ils préfèrent. Le système de vote est
très simple et est basé sur des +1. La table des votes
contient le nombre de votes par produits avec la date du
premier vote et la date du dernier vote.
Table vote :

id produit vote_co vote_first_da vote_last_da

_id unt te te
1 46 2 2012-04-25 2013-02-16
[Link] [Link]
30
52
2 39 4 2012-04-28 2013-02-14
[Link] [Link]
3 49 1 2012-04-25 2013-01-06
[Link] [Link]
Pour n’utiliser qu’une seule ligne qui permet d’ajouter
des votes dans cette table, sans se préoccuper de savoir
s’il faut faire un INSERT ou un UPDATE, il est possible
d’utiliser la requête SQL suivante :
INSERT INTO vote (produit_id, vote_count, vote_first_date, vote_last_date)
VALUES (50, 1, NOW(), NOW())
ON DUPLICATE KEY UPDATE vote_count = vote_count+1, vote_last_date = NOW()

54
Dans cette requête la date et l’heure est générée
automatiquement avec la fonction NOW(). Résultat
après la première exécution de la requête :
id produit vote_co vote_first_da vote_last_da
_id unt te te
1 46 2 2012-04-25 2013-02-16
[Link] [Link]
2 39 4 2012-04-28 2013-02-14
[Link] [Link]
3 49 1 2012-04-25 2013-01-06
[Link] [Link]
4 55 1 2013-04-02 2013-04-02
[Link] [Link] 55
Ce résultat montre bien l’ajout d’une ligne en fin de table,
donc la requête a été utilisé sous la forme d’un INSERT.
Après une deuxième exécution de cette même requête le
lendemain, les données seront celles-ci:

id produit vote_co vote_first_da vote_last_da

_id unt te te
1 46 2 2012-04-25 2013-02-16
[Link] [Link]
2 39 4 2012-04-28 2013-02-14
[Link] [Link]
3 49 1 2012-04-25 2013-01-06
 [Link] [Link]
4 55 2 2013-04-02 2013-04-03
[Link] [Link]

Ces résultats montre bien qu’il y a eu un vote

supplémentaire et que la date du dernier vote a été mis à
jour.

Insérer une ligne ou ne rien faire

Dans certains cas il est intéressant d’utiliser un INSERT
mais de ne rien faire si la commande a déjà été insérée
précédemment. Malheureusement, si la clé primaire
existe déjà la requête retournera une erreur. Et s’il n’y a
rien à mettre à jour, la commande ON DUPLICATE KEY
UPDATE (ODKU) ne semble pas convenir. Toutefois il y a
une astuce qui consiste à utiliser une requête de ce type :
INSERT INTO table (a, b, c)
VALUES (1, 45, 6)
ON DUPLICATE KEY UPDATE id = id

58
Cette requête insert les données et ne produit aucune
erreur si l’enregistrement existait déjà dans la table.
A savoir : théoriquement il aurait été possible d’utiliser
INSERT IGNORE mais malheureusement cela
empêche de retourner des erreurs telles que des erreurs
de conversions de données.

Compatibilité
Pour le moment cette fonctionnalité n’est possible
qu’avec MySQL depuis la version 4.1 (date de 2003). Les
autres Systèmes de Gestion de Bases de Données
(SGBD) n’intègrent pas cette fonctionnalité. Pour
simuler cette fonctionnalité il y a quelques alternatives:
• PostgreSQL : il y a une astuce en utilisant une

fonction. L’astuce est expliquée dans la

 documentation officielle : fonction
INSERT/UPDATE.
• Oracle : il est possible d’utiliser la commande MERGE
pour effectuer la même chose.
• SQL Server : il est possible d’utiliser une procédure.
 SQL UPDATE
La commande UPDATE permet d’effectuer des
modifications sur des lignes existantes. Très souvent cette
commande est utilisée avec WHERE pour spécifier sur
quelles lignes doivent porter la ou les modifications.

Syntaxe
La syntaxe basique d’une requête utilisant UPDATE est la
suivante :
UPDATE table
SET nom_colonne_1 = 'nouvelle
valeur' WHERE condition
40
62
Cette syntaxe permet d’attribuer une nouvelle valeur à la
colonne nom_colonne_1 pour les lignes qui respectent la
condition stipulé avec WHERE. Il est aussi possible
d’attribuer la même valeur à la colonne nom_colonne_1
pour toutes les lignes d’une table si la condition WHERE
n’était pas utilisée.
A noter, pour spécifier en une seule fois plusieurs
modification, il faut séparer les attributions de valeur par
des virgules. Ainsi la syntaxe deviendrait la suivante :
UPDATE table
SET colonne_1 = 'valeur 1', colonne_2 =
'valeur 2', colonne_3 = 'valeur 3' WHERE 63

condition
 Exemple
id nom rue ville code_p pays
ostal
1 Chan 12 Avenue du Puteau 92800 France
tal Petit Trianon x
2 Pierr 18 Rue de Ponthi 51300 France
e l'Allier on
3 Rom 3 Chemin du Trévéri 35190 France
ain Chiron en

Imaginons une table « client » qui présente les

64
coordonnées de clients.
Pour modifier l’adresse du client Pierre, il est possible
d’utiliser la requête suivante :
UPDATE client
SET rue = '49 Rue
Ameline',
ville =
'Saint-
Eustache-
la-Forêt',
code_posta
l = '76210'
65
WHERE id = 2
Résultat :
i nom rue ville code_ pays
d postal
1 Chan12 Avenue du Puteaux 92800 Fran
tal Petit Trianon ce
2 Pierr
49 Rue Saint- 76210 Fran
e Ameline Eustache-la- ce
Forêt
3 Rom 3 Chemin du Trévérien 35190 Fran
ain Chiron ce

66
SQL DELETE
La commande DELETE en SQL permet de supprimer des
lignes dans une table. En utilisant cette commande
associé à WHERE il est possible de sélectionner les
lignes concernées qui seront supprimées.
Attention : Avant d’essayer de supprimer des lignes, il est
recommandé d’effectuer une sauvegarde de la base de
données, ou tout du moins de la table concernée par la
suppression. Ainsi, s’il y a une mauvaise manipulation il
est toujours possible de restaurer les données.

Syntaxe
La syntaxe pour supprimer des lignes est la
suivante :

DELETE FROM table WHERE

condition

68
Attention : s’il n’y a pas de condition WHERE alors
toutes les lignes seront supprimées et la table sera alors
vide.

Exemple
Imaginons une table « utilisateur » qui contient des
informations sur les utilisateurs d’une application.
id nom prenom date_inscri
ption
1 Bazin Daniel 2012-02-13
2 Favre Constantin 2012-04-03
3 Clerc Guillaume 2012-04-12
4 Ricard Rosemond 2012-06-24
 e
5 Martin Natalie 2012-07-02

Si l’ont souhaite supprimer les utilisateurs qui se sont

inscrit avant le « 10/04/2012″, il va falloir effectuer la
requête suivante :
DELETE FROM utilisateur
WHERE date_inscription <
'2012-04-10'

70
La requête permettra alors de supprimer les utilisateurs «
Daniel » et « Constantin ». La table contiendra alors les
données suivantes :

id nom prenom date_inscri

ption
3 Clerc Guillaume 2012-04-12
4 Ricard Rosemond 2012-06-24
e
5 Martin Natalie 2012-07-02
Il ne faut pas oublier qu’il est possible d’utiliser
d’autres conditions pour sélectionner les lignes à
supprimer.
SQL MERGE
Dans le langage SQL, la commande MERGE permet
d’insérer ou de mettre à jour des données dans une table.
Cette commande permet d’éviter d’effectuer plusieurs
requêtes pour savoir si une donnée est déjà dans la base
de données et ainsi adapter l’utilisation d’une requête
pour ajouter ou une autre pour modifier la donnée
existante. Cette commande peut aussi s’appeler «
upsert».
Attention : bien que l’instruction a été ajoutée dans le
standard SQL:2003, les différentes SGBD n’utilisent pas
toutes les mêmes méthodes pour effectuer un upsert.
 Syntaxe
La syntaxe standard pour effectuer un merge consiste à
utiliser une requête SQL semblable à celle ci-dessous :
MERGE INTO
table1
USING
table_refer
ence ON
(conditions
)
WHEN MATCHED THEN
UPDATE SET table1.colonne1 =
valeur1, table1.colonne2 = valeur2 73
DELETE WHERE conditions2
WHEN NOT MATCHED THEN
INSERT
Voici les explications détaillées de cette requête :
• MERGE INTO permet de sélectionner la table à modifier
• USING et ON permet de lister les données sources et la
condition de correspondance
• WHEN MATCHED permet de définir la condition de
mise à jour lorsque la condition est vérifiée
• WHEN NOT MATCHED permet de définir la condition
d’insertion lorsque la condition n’est pas
vérifiée
Compatibilité
Les systèmes de gestion de bases de données peuvent
implémenter cette fonctionnalité soit de façon standard,
en utilisant une commande synonyme ou en utilisant
une syntaxe non standard.
• Syntaxe standard : SQL Server, Oracle, DB2, Teradata

et EXASOL
• Utilisation du terme UPSERT : Microsoft SQL Azure et

MongoDB
• Utilisation non standard : MySQL, SQLite, Firebird, IBM

DB2 et Microsoft SQL

SQL TRUNCATE TABLE
En SQL, la commande TRUNCATE permet de supprimer
toutes les données d’une table sans supprimer la table
en elle-même. En d’autres mots, cela permet de purger
la table. Cette instruction diffère de la commande DROP
qui à pour but de supprimer les données ainsi que la
table qui les contient.
A noter : l’instruction TRUNCATE est semblable à
l’instruction DELETE sans utilisation de WHERE. Parmi les
petite différences TRUNCATE est toutefois plus rapide et
utilise moins de ressource. Ces gains en performance se
justifie notamment parce que la requête n’indiquera pas
le nombre d’enregistrement supprimés et qu’il n’y aura
pas d’enregistrement des modifications dans le journal.

Syntaxe
Cette instruction s’utilise dans une requête SQL semblable
à celle-ci :
TRUNCATE TABLE `table`

Dans cet exemple, les données de la table « table » seront

perdues une fois cette requête exécutée.

Exemple 77
Pour montrer un exemple concret de l’utilisation de
cette commande, nous pouvons imaginez un système
informatique contenant la liste des fournitures d’une
entreprise. Ces données seraient tout simplement
stockées dans une table « fourniture ».
Table « fourniture » :

id nom date_ajout
1 Ordinateur 2013-04-05
2 Chaise 2013-04-14
3 Bureau 2013-07-18
4 Lampe 2013-09-27
Il est possible de supprimer toutes les données de cette
table en utilisant la requête suivante :
TRUNCATE TABLE `fourniture`

Une fois la requête exécutée, la table ne contiendra plus

aucun enregistrement. En d’autres mots, toutes les
lignes du tableau présenté ci-dessus auront été
supprimées.

79
SQL CREATE DATABASE
La création d’une base de données en SQL est possible
en ligne de commande. Même si les systèmes de gestion
de base de données (SGBD) sont souvent utilisés pour
créer une base, il convient de connaître la commande à
utiliser, qui est très simple.

Syntaxe
Pour créer une base de données qui sera appelé «
ma_base » il suffit d’utiliser la requête suivante qui est
très simple :
CREATE DATABASE ma_base 80
Base du même nom qui existe déjà
Avec MySQL, si une base de données porte déjà ce
nom, la requête retournera une erreur. Pour éviter
d’avoir cette erreur, il convient d’utiliser la requête
suivante pour MySQL :
CREATE DATABASE IF NOT EXISTS ma_base

L’option IF NOT EXISTS permet juste de ne pas retourner

d’erreur si une base du même nom existe déjà. La base
de données ne sera pas écrasée.
81
Options
Dans le standard SQL la commande CREATE DATABASE
n’existe normalement pas. En conséquent il revient de
vérifier la documentation des différents SGBD pour
vérifier les syntaxes possibles pour définir des options.
Ces options permettent selon les cas, de définir les jeux
de caractères, le propriétaire de la base ou même les
limites de connexion.

60
82
SQL DROP DATABASE
En SQL, la commande DROP DATABASE permet de
supprimer totalement une base de données et tout ce
qu’elle contient. Cette commande est à utiliser avec
beaucoup d’attention car elle permet de supprimer tout
ce qui est inclus dans une base: les tables, les données,
les index …

Syntaxe
Pour supprimer la base de données « ma_base », la
requête est la suivante :
DROP DATABASE ma_base 83
Attention : cela va supprimer toutes les tables et toutes
les données de cette base. Si vous n’êtes pas sûr de ce
que vous faites, n’hésitez pas à effectuer une sauvegarde
de la base avant de supprimer.

Ne pas afficher d’erreur si la base n’existe pas

Par défaut, si le nom de base utilisé n’existe pas, la
requête retournera une erreur. Pour éviter d’obtenir
cette erreur si vous n’êtes pas sûr du nom, il est possible
d’utiliser l’option IF EXISTS. La syntaxe sera alors la
suivante :
DROP DATABASE IF EXISTS ma_base

84
SQL CREATE TABLE
La commande CREATE TABLE permet de créer une table
en SQL. Un tableau est une entité qui est contenu dans
une base de données pour stocker des données
ordonnées dans des colonnes. La création d’une table
sert à définir les colonnes et le type de données qui
seront contenus dans chacun des colonne (entier, chaîne
de caractères, date, valeur binaire …).

Syntaxe
La syntaxe générale pour créer une table est la suivante :
CREATE TABLE
nom_de_la_table (
colonne1 type_donnees,
colonne2 type_donnees,
colonne3 type_donnees,
colonne4 type_donnees
)
Dans cette requête, 4 colonnes ont été définies. Le mot-
clé « type_donnees » 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ées 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.

Exemple
Imaginons que l’ont souhaite créer une table utilisateur, dans
laquelle chaque ligne correspond à un utilisateur inscrit sur un site
web. La requête pour créer cette table peut ressembler à ceci :

CREATE TABLE utilisateur (

id INT PRIMARY KEY NOT NULL, nom
VARCHAR(100),
prenom VARCHAR(100), email
VARCHAR(255),
date_naissance DATE,
pays VARCHAR(255), ville VARCHAR(255), 88

code_postal VARCHAR(5), nombre_achat INT

)
Voici des explications sur les colonnes créées :
• id : identifiant unique qui est utilisé comme clé
primaire et qui n’est pas nulle
• nom : nom de l’utilisateur dans une colonne de type
VARCHAR avec un maximum de 100
 caractères au maximum
• prenom : idem mais pour le prénom
• email : adresse email enregistré sous 255 caractères au
maximum
• date_naissance : date de naissance enregistré au
format AAAA-MM-JJ (exemple : 1973-11- 17)
• pays : nom du pays de l’utilisateur sous 255 caractères
au maximum
• ville : idem pour la ville
• code_postal : 5 caractères du code postal
• nombre_achat : nombre d’achat de cet utilisateur sur
le site
 SQL ALTER TABLE
La commande ALTER TABLE en SQL permet de modifier
une table existante. Il est ainsi possible d’ajouter une
colonne, d’en supprimer une ou de modifier une
colonne existante, par exemple pour changer le type.

Syntaxe de base
D’une manière générale, la commande s’utilise de la
manière suivante :
ALTER TABLE
nom_table 91

instruction
Le mot-clé « instruction » ici sert à désigner une
commande supplémentaire, qui sera détaillée ci-
dessous selon l’action que l’ont souhaite effectuer :
ajouter, supprimer ou modifier une colonne.

Ajouter une colonne

Syntaxe
L’ajout d’une colonne dans une table est relativement
simple et peut s’effectuer à l’aide d’une requête
ressemblant à ceci :
ALTER TABLE nom_table
ADD nom_colonne
type_donnees 70
92
 Exemple
Pour ajouter une colonne qui correspond à une rue sur
une table utilisateur, il est possible d’utiliser la requête
suivante:
ALTER TABLE utilisateur
ADD adresse_rue
VARCHAR(255)

93
Supprimer une colonne
Une syntaxe permet également de supprimer une
colonne pour une table. Il y a 2 manières totalement
équivalente pour supprimer une colonne :
ALTER TABLE nom_table
DROP nom_colonne

Ou (le résultat sera le même)

ALTER TABLE nom_table
DROP COLUMN 94

nom_colonne
Modifier une colonne
Pour modifier une colonne, comme par exemple
changer le type d’une colonne, il y a différentes
syntaxes selon le SGBD.
 MySQL
ALTER TABLE nom_table
MODIFY nom_colonne type_donnees

PostgreSQL
ALTER TABLE nom_table
ALTER COLUMN nom_colonne TYPE type_donnees

Ici, le mot-clé « type_donnees » est à remplacer par un

type de données tel que INT, VARCHAR, TEXT, DATE …

Renommer une colonne

96
Pour renommer une colonne, il convient d’indiquer
 l’ancien nom de la colonne et le nouveau no
de celle-ci.
MySQL
Pour MySQL, il faut également indiquer le type de la
colonne.
ALTER TABLE nom_table
CHANGE colonne_ancien_nom colonne_nouveau_nom type_donnees

97
Ici « type_donnees » peut correspondre par exemple à
INT, VARCHAR, TEXT, DATE …

PostgreSQL
Pour PostgreSQL la syntaxe est plus simple et ressemble à
ceci (le type n’est pas demandé) :
ALTER TABLE nom_table
RENAME COLUMN colonne_ancien_nom TO colonne_nouveau_nom

98
SQL DROP TABLE
La commande DROP TABLE en SQL permet de supprimer
définitivement une table d’une base de données. Cela
supprime en même temps les éventuels index, trigger,
contraintes et permissions associées à cette table.
Attention : il faut utiliser cette commande avec attention
car une fois supprimée, les données sont perdues. Avant
de l’utiliser sur une base importante il peut être judicieux
d’effectuer un backup (une sauvegarde) pour éviter les
mauvaises surprises.

Syntaxe
Pour supprimer une table « nom_table » il suffit
simplement d’utiliser la syntaxe suivante :
DROP TABLE nom_table

A savoir : s’il y a une dépence avec une autre table, il est

recommandé de les supprimer avant de supprimer la
table. C’est le cas par exemple s’il y a des clés
étrangères.
Intérêts 10
0
Il arrive qu’une table soit créé temporairement pour
stoquer des données qui n’ont pas vocation à être ré-
utiliser. La suppression d’une table non utilisée est
avantageux sur plusieurs aspects :
• Libérer de la mémoire et alléger le poids des backups
• Éviter des erreurs dans le futur si une table porte un
nom similaire ou qui porte à confusion
• Lorsqu’un développeur ou administrateur de base de
données découvre une application, il est plus rapide
de comprendre le système s’il n’y a que les tables
utilisées qui sont présente
Exemple de requête
Imaginons qu’une base de données possède une table «
client_2009 » qui ne sera plus jamais utilisé et qui existe
déjà dans un ancien backup. Pour supprimer cette table, il
suffit d’effectuer la requête suivante :
DROP TABLE
client_2009

L’exécution de cette requête va permettre de supprimer la

table.

80
102
Jointure SQL
Les jointures en SQL permettent d’associer plusieurs
tables dans une même requête. Cela permet d’exploiter
la puissance des bases de données relationnelles pour
obtenir des résultats qui combinent les données de
plusieurs tables de manière efficace.

Exemple
En général, les jointures consistent à associer des lignes
de 2 tables en associant l’égalité des valeurs d’une
colonne d’une première table par rapport à la valeur
d’une colonne d’une seconde table. Imaginons qu’une
base de 2 données possède une table « utilisateur » et
une autre table « adresse » qui contient les adresses de
ces utilisateurs. Avec une jointure, il est possible d’obtenir
les données de l’utilisateur et de son adresse en une seule
requête.
On peut aussi imaginer qu’un site web possède une table
pour les articles (titre, contenu, date de publication …) et
une autre pour les rédacteurs (nom, date d’inscription,
date de naissance …). Avec une jointure il est possible
d’effectuer une seule recherche pour afficher un article et
le nom du rédacteur. Cela évite d’avoir à afficher le nom
du rédacteur dans la table « article ».
Il y a d’autres cas de jointures, incluant des jointures sur
la même table ou des jointure d’inégalité. Ces cas étant
assez particulier et pas si simple à comprendre, ils ne
seront pas élaboré sur cette page.

Types de jointures
Il y a plusieurs méthodes pour associer 2 tables
ensemble. Voici la liste des différentes techniques qui
sont utilisées :
• INNER JOIN : jointure interne pour retourner les

enregistrements quand la condition est vrai dans les 2

tables. C’est l’une des jointures les plus communes.
• CROSS JOIN : jointure croisée permettant de faire le
 produit cartésien de 2 tables. En
d’autres mots, permet de joindre chaque lignes d’une
table avec chaque lignes d’une seconde table.
Attention, le nombre de résultats est en général très
élevé.
• LEFT JOIN (ou LEFT OUTER JOIN) : jointure externe
pour retourner tous les enregistrements de la table de
gauche (LEFT = gauche) même si la condition n’est pas
vérifié dans l’autre table.
• RIGHT JOIN (ou RIGHT OUTER JOIN) : jointure
externe pour retourner tous les enregistrements de
la table de droite (RIGHT = droite) même si la
condition n’est pas vérifié dans l’autre table.
• FULL JOIN (ou FULL OUTER JOIN) : jointure externe
pour retourner les résultats quand la condition est
vrai dans au moins une des 2 tables.
• SELF JOIN : permet d’effectuer une jointure d’une table
avec elle-même comme si c’était une
autre table.
• NATURAL JOIN : jointure naturelle entre 2 tables s’il
y a au moins une colonne qui porte le même nom
entre les 2 tables SQL
• UNION JOIN : jointure d’union
DansSQL INNER
le langage SQLJOIN
la commande INNER JOIN, aussi
appelée EQUIJOIN, est un type de jointures très
communes pour lier plusieurs tables entre-elles. Cette
commande retourne les enregistrements lorsqu’il y a au
moins une ligne dans chaque colonne qui correspond à la
condition.

Syntaxe
Pour utiliser ce type de jointure il convient d’utiliser une
requête SQL avec cette syntaxe :
10
8
 SELECT *
FROM table1
INNER JOIN table2 ON [Link] = table2.fk_id

La syntaxe ci-dessus stipule qu’il faut sélectionner les

enregistrements des tables table1 et table2 lorsque les
données de la colonne « id » de table1 est égal aux
données de la colonne fk_id de table2.
La jointure SQL peux aussi être écrite de la façon suivante :
SELECT *
FROM table1
INNER JOIN table2
WHERE [Link] = table2.fk_id
La syntaxe avec la condition WHERE est une manière
alternative de faire la jointure mais qui possède
l’inconvénient d’être moins facile à lire s’il y a déjà
plusieurs conditions dans le WHERE.

Exemple
Imaginons une application qui possède une table
utilisateur ainsi qu’une table commande qui contient
toutes les commandes effectuées par les utilisateurs.
Table utilisateur :
id preno nom email ville
m
1 Aimée Marec [Link]@ex Paris
hal [Link]
2 Esmée Lefort [Link]@exam Lyon
[Link]
3 Marine Prevost [Link]@exampl Lille
[Link]
4 Luc Rolland lucrolland@exampl Marse
[Link] ille

Table commande :

90
112
utilisateur_ date_achat num_factu prix_total
id re
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
2 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58

Pour afficher toutes les commandes associées aux

utilisateurs, il est possible d’utiliser la requête suivante :
SELECT id, prenom, nom, date_achat, num_facture, prix_total
FROM utilisateur
INNER JOIN commande ON [Link] = commande.utilisateur_id
 Résultats :
id preno nom date_a num_f prix_to
m chat acture tal
1 Aimée Marec 2013- A0010 203.14
hal 01-23 3
1 Aimée Marec 2013- A0010 124.00
hal 02-14 4
2 Esmée Lefort 2013- A0010 149.45
02-17 5
2 Esmée Lefort 2013- A0010 235.35
02-21 6 11
4
Le résultat de la requête montre parfaite la jointure entre
les 2 tables. Les utilisateurs 3 et 4 ne sont pas affichés
puisqu’il n’y a pas de commandes associés à ces
utilisateurs.
Attention : il est important de noter que si un utilisateur
à été supprimé, alors on ne verra pas ses commandes
dans la liste puisque INNER JOIN retourne uniquement
les résultats ou la condition est vrai dans les 2 tables.
SQL CROSS JOIN
Dans le langage SQL, la commande CROSS JOIN est un
type de jointure sur 2 tables SQL qui permet de retourner
le produit cartésien. Autrement dit, cela permet de
retourner chaque ligne d’une table avec chaque ligne
d’une autre table. Ainsi effectuer le produit cartésien
d’une table A qui contient 30 résultats avec une table B
de 40 résultats va produire 1200 résultats (30 x 40 =
1200). En général la commande CROSS JOIN est combinée
avec la commande WHERE pour filtrer les résultats qui
respectent certaines conditions.
Attention, le nombre de résultat peut facilement être
très élevé. S’il est effectué sur des tables avec beaucoup
d’enregistrements, cela peut ralentir sensiblement le
serveur.

Syntaxe
Pour effectuer un jointure avec CROSS JOIN, il convient
d’effectuer une requête SQL respectant la syntaxe
suivante :
SELECT *
FROM table1
CROSS JOIN table2

11
7
 Méthode alternative pour retourner les
SELECT *
FROM table1, table2

mêmes résultats :
L’une ou l’autre de ces syntaxes permettent d’associer
tous les résultats de table1 avec chacun des résultats de
table2.

Exemple
Imaginons une application de recettes de cuisines qui
contient 2 tables d’ingrédients, la table legume et la table
fruit.
11
Table legume : 8
l_id l_nom_fr_fr l_nom_en_gb
45 Carotte Carott
46 Oignon Onion
47 Poireau Leek

Table fruit :

f_id f_nom_fr_fr f_nom_en_gb

87 Banane Banana
88 Kiwi Kiwi
89 Poire Pear
11
9
Pour une raison quelconque l’application doit associer
tous les légumes avec tous les fruits. Toutes les
combinaisons doivent être affichées. Pour cela il convient
d’effectuer l’une ou l’autre des requêtes suivantes :

SELECT l_id, l_nom_fr_fr, f_id, f_nom_fr_fr

FROM legume
CROSS JOIN fruit

ou :
SELECT l_id, l_nom_fr_fr, f_id, f_nom_fr_fr
FROM legume, fruit

12
0
 Résultats :
l_id l_nom_fr_f f_id f_nom_fr_f
r r
45 Carotte 87 Banane
45 Carotte 88 Kiwi
45 Carotte 89 Poire
46 Oignon 87 Banane
46 Oignon 88 Kiwi
46 Oignon 89 Poire
47 Poireau 87 Banane
12
1
47 Poireau 88 Kiwi
47 Poireau 89 Poire

Le résultat montre bien que chaque légume est associé à

chaque fruit. Avec 3 fruits et 3 légumes, il y a donc 9
lignes de résultats (3 x3 = 9).

100
122
SQL LEFT JOIN
Dans le langage SQL, la commande LEFT JOIN (aussi
appelée LEFT OUTER JOIN) est un type de jointure entre 2
tables. Cela permet de lister tous les résultats de la table
de gauche (left = gauche) même s’il n’y a pas de
correspondance dans la deuxième tables.

Syntaxe
Pour lister les enregistrement de table1, même s’il n’y
a pas de correspondance avec table2, il convient
d’effectuer une requête SQL utilisant la syntaxe
suivante.
101
123
 SELECT *
FROM table1
LEFT JOIN table2 ON [Link] = table2.fk_id

La requête peux aussi s’écrire de la façon suivante :

SELECT *
FROM table1
LEFT OUTER JOIN table2 ON [Link] = table2.fk_id

Cette requête est particulièrement intéressante pour

récupérer les informations de table1 tout en récupérant
les données associées, même s’il n’y a pas de
correspondance avec table2. A savoir, s’il n’y a pas
correspondance les colonnes de table2 vaudront toutes
NULL.

Exemple
Imaginons une application contenant des utilisateurs et
des commandes pour chacun de ces utilisateurs. La base
de données de cette application contient une table pour
les utilisateurs et sauvegarde leurs achats dans une
seconde table. Les 2 tables sont reliées grâce à la colonne
utilisateur_id de la table des commandes. Cela permet
d’associer une commande à un utilisateur.
Table utilisateur :
id preno nom email ville
m
1 Aimée Marec [Link]@ex Paris
hal [Link]
2 Esmée Lefort [Link]@exam Lyon
[Link]
3 Marine Prevost [Link]@exampl Lille
[Link]
4 Luc Rolland lucrolland@exampl Marse
[Link] ille

Table commande :
utilisateur_ date_achat num_factu prix_total
id re
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
2 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58

Pour lister tous les utilisateurs avec leurs commandes et

afficher également les utilisateurs qui n’ont pas
effectuées d’achats, il est possible d’utiliser la requête
suivante :
 SELECT *
FROM utilisateur
LEFT JOIN commande ON [Link] = commande.utilisateur_id

Résultats :

id preno nom date_a num_fac prix_total

m chat ture
1 Aimé Mar 2013- A00103 203.14
e echa 01-23
l
1 Aimé Mar 2013- A00104 124.00
e echa 02-14
l
2 Esmé Lefor 2013- A00105 149.45
e t 02-17
2 Esmé Lefor 2013- A00106 235.35
e t 02-21
3 Marin Prev NULL NULL NULL
e ost
4 Luc Rolla NULL NULL NULL
nd

Les dernières lignes montrent des utilisateurs qui

n’ont effectuée aucune commande. La ligne retourne
la valeur NULL pour les colonnes concernant les achats
qu’ils n’ont pas effectués.
 Filtrer sur la valeur NULL
Attention, la valeur NULL n’est pas une chaîne de
caractère. Pour filtrer sur ces caractères il faut utiliser la
commande IS NULL. Par exemple, pour lister les
utilisateurs qui n’ont pas effectués d’achats il est
possible d’utiliser la requête suivante.
SELECT id, prenom, nom, utilisateur_id
FROM utilisateur
LEFT JOIN commande ON [Link] = commande.utilisateur_id
WHERE utilisateur_id IS NULL

Résultats :
130
id prenom nom utilisateur_
id
3 Marine Prevost NULL
4 Luc Rolland NULL
132
SQL RIGHT JOIN
En SQL, la commande RIGHT JOIN (ou RIGHT OUTER JOIN)
est un type de jointure entre 2 tables qui permet de
retourner tous les enregistrements de la table de droite
(right = droite) même s’il n’y a pas de correspondance
avec la table de gauche. S’il y a un enregistrement de la
table de droite qui ne trouve pas de correspondance dans
la table de gauche, alors les colonnes de la table de
gauche auront NULL pour valeur.

Syntaxe
L’utilisation de cette commande SQL s’effectue de la façon
110
133
 suivante :
SELECT *
FROM table1
RIGHT JOIN table2 ON [Link] = table2.fk_id

La syntaxe de cette requête SQL peux aussi s’écrire de la

façon suivante :
SELECT *
FROM table1
RIGHT OUTER JOIN table2 ON [Link] = table2.fk_id

Cette syntaxe stipule qu’il faut lister toutes les lignes du

134
associées du tableau table1 s’il y a une correspondance
entre ID de table1 et FK_ID de table2. S’il n’y a pas de
correspondance, l’enregistrement de table2 sera affiché
et les colonnes de table1 vaudront toutes NULL.

Exemple
Prenons l’exemple d’une base de données qui contient
des utilisateurs et un historique d’achat de ces
utilisateurs. Cette 2 tables sont reliées entre grâce à la
colonne utilisateur_id de la table des commandes. Cela
permet de savoir à quel utilisateur est associé un achat.
Table utilisateur :
id preno nom email ville actif
m
1 Aimé Marec [Link] Paris 1
e hal @[Link]
2 Esmé Lefort [Link]@e Lyon 0
e [Link]
3 Marin Prevo [Link]@exa Lille 1
e st [Link]
4 Luc Rollan lucrolland@exa Marse 1
d [Link] ille

Table commande :
utilisateur_ date_achat num_factu prix_total
id re
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
3 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58

Pour afficher toutes les commandes avec le nom de

l’utilisateur correspondant il est normalement
d’habitude d’utiliser INNER JOIN en SQL.
Malheureusement,si l’utilisateur a été supprimé de la
table, alors ça ne retourne pas l’achat. L’utilisation de
RIGHT JOIN permet de retourner tous les achats et
d’afficher le nom de l’utilisateur s’il existe. Pour cela il
convient d’utiliser cette requête :
SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture
FROM utilisateur
RIGHT JOIN commande ON [Link] = commande.utilisateur_id

Résultats : 138
id preno nom utilisate date_ac num_factu
m ur_id hat re
1 Aimé Marec 1 2013- A00103
e hal 01-23
1 Aimé Marec 1 2013- A00104
e hal 02-14
2 Esmé Lefort 2 2013- A00105
e 02-17
3 Marin Prevo 3 2013- A00106
e st 02-21
NU NULL NULL 5 2013- A00107
LL 03-02
Ce résultat montre que la facture A00107 est liée à
l’utilisateur numéro 5. Or, cet utilisateur n’existe pas ou
n’existe plus. Grâce à RIGHT JOIN, l’achat est tout de
même affiché mais les informations liées à l’utilisateur
sont remplacé par NULL.
SQL FULL JOIN
Dans le langage SQL, la commande FULL JOIN (ou FULL
OUTER JOIN) permet de faire une jointure entre 2 tables.
L’utilisation de cette commande permet de combiner les
résultats des 2 tables, les associer entre eux grâce à une
condition et remplir avec des valeurs NULL si la condition
n’est pas respectée.

Syntaxe
Pour retourner les enregistrements de table1 et table2,
il convient d’utiliser une requête SQL avec une syntaxe
telle que celle-ci :
 SELECT *
FROM table1
FULL JOIN table2 ON [Link] = table2.fk_id

Cette requête peut aussi être conçu de cette façon :

SELECT *
FROM table1
FULL OUTER JOIN table2 ON [Link] = table2.fk_id

La condition présentée ici consiste à lier les tables sur

un identifiant, mais la condition peut être définie sur
d’autres champs.
Exemple
Prenons l’exemple d’une base de données qui
contient une table utilisateur ainsi qu’une table
commande qui contient toutes les ventes.
Table utilisateur :

id preno nom email ville actif

m
1 Aimé Marec [Link] Paris 1
e hal @[Link]
2 Esmé Lefort [Link]@e Lyon 0
e [Link]
120
143
3 Marin Prevo [Link]@exa Lille 1
e st [Link]
4 Luc Rollan lucrolland@exa Marse 1
d [Link] ille

Table commande :

utilisateur_ date_achat num_factu prix_total

id re
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
144
3 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58
Il est possible d’utiliser FULL JOIN pour lister tous les
utilisateurs ayant effectué ou non une vente, et de lister
toutes les ventes qui sont associées ou non à un
utilisateur. La requête SQL est la suivante :
SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture
FROM utilisateur
FULL JOIN commande ON [Link] = commande.utilisateur_id

Résultat :
146
id preno nom utilisate date_ac num_factu
m ur_id hat re
1 Aimé Marec 1 2013- A00103
e hal 01-23
1 Aimé Marec 1 2013- A00104
e hal 02-14
2 Esmé Lefort 2 2013- A00105
e 02-17
3 Marin Prevo 3 2013- A00106
e st 02-21
4 Luc Rollan NULL NULL NULL
d
NU NULL 5 2013- A00107
LL 03-02

Ce résultat affiche bien l’utilisateur numéro 4 qui n’a

effectué aucun achat. Le résultat retourne également la
facture A00107 qui est associée à un utilisateur qui
n’existe pas (ou qui n’existe plus). Dans les cas où il n’y a
pas de correspondance avec l’autre table, les valeurs des
colonnes valent NULL.
SQL SELF JOIN
En SQL, un SELF JOIN correspond à une jointure d’une
table avec elle-même. Ce type de requête n’est pas si
commun mais très pratique dans le cas où une table lie
des informations avec des enregistrements de la même
table.

Syntaxe
Pour effectuer un SELF JOIN, la syntaxe de la requête SQL
est la suivante :
 SELECT `t1`.`nom_colonne1`, `t1`.`nom_colonne2`, `t2`.`nom_colonne1`,
`t2`.`nom_colonne2`
FROM `table` as `t1`
LEFT OUTER JOIN `table` as `t2` ON `t2`.`fk_id` = `t1`.`id`

Ici la jointure est effectuée avec un LEFT JOIN, mais il est

aussi possible de l’effectuer avec d’autres types de
jointures.

Exemple
Un exemple potentiel pourrait être une application d’un
intranet d’entreprise qui possède la table des employés
avec la hiérarchie entre eux. Les employés peuvent être
dirigé par un supérieur direct qui se trouve lui-même
dans la table.
Table utilisateur :

id preno nom email manager_id

m
1 Sebas Martin [Link]@exam NULL
tien [Link]
2 Gusta Duboi [Link]@exam NULL
ve s [Link]
3 Georg Leroy [Link]@exampl 1
 ette [Link]
4 Grego Roux [Link]@example 2
ry .com

Les enregistrements de la table ci-dessus montre bien

des employés. Les premiers employés n’ont pas de
supérieur, tandis que les employés n°3 et n°4 ont
respectivement pour supérieur l’employé n°1 et
l’employé n°2.
Il est possible de lister sur une même ligne les employés
avec leurs supérieurs direct, grâce à une requête telle que
celle-ci :
 SELECT `u1`.`u_id`, `u1`.`u_nom`, `u2`.`u_id`, `u2`.`u_nom`
FROM `utilisateur` as `u1`
LEFT OUTER JOIN `utilisateur` as `u2` ON `u2`.`u_manager_id` = `u1`.`u_id`

Résultat :

130
153
u1 u1_pr u1_ u1_email u1_ma u2_pr u2_
_i enom nom nager_i enom nom
d d
1 Seba Mar [Link]@e NULL NULL NUL
stien tin [Link] L
m
2 Gust Dub [Link]@e NULL NULL NUL
ave ois [Link] L
m
3 Geor Lero [Link]@ex 1 Sebas Mar
gette y [Link] tien tin
4 Greg Rou [Link]@ex 2 Gusta Dub
ory x [Link] ve ois
SQL NATURAL JOIN
Dans le langage SQL, la commande NATURAL JOIN
permet de faire une jointure naturelle entre 2 tables.
Cette jointure s’effectue à la condition qu’il y ai des
colonnes du même nom et de même type dans les 2
tables. Le résultat d’une jointure naturelle est la création
d’un tableau avec autant de lignes qu’il y a de paires
correspondant à l’association des colonnes de même
nom.
A noter : puisqu’il faut le même nom de colonne sur les 2
tables, cela empêche d’utiliser certaines règles de
nommages pour le nom des colonnes. Il n’est par exemple
pas possible de préfixer le nom des colonnes sous peine
d’avoir malheureusement 2 nom de colonnes différents.

Syntaxe
La jointure naturelle de 2 tables peut s’effectuer
facilement, comme le montre la requête SQL suivante
:
SELECT *
FROM table1
NATURAL JOIN table2

156
L’avantage d’un NATURAL JOIN c’est qu’il n’y a pas besoin
d’utiliser la clause ON.

Exemple
Une utilisation classique d’une telle jointure pourrait être
l’utilisation dans une application qui utilise une table
utilisateur et une table pays. Si la table utilisateur
contient une colonne pour l’identifiant du pays, il sera
possible d’effectuer une jointure naturelle.
Table « utilisateur » :

user_id user_preno user_ville pays_id

m
1 Jérémie Paris 1
2 Damien Lyon 2
3 Sophie Marseille NULL
4 Yann Lille 9999
5 Léa Paris 1

Table « pays » :

pays_id pays_nom
1 France
2 Canada
3 Belgique 158
4 Suisse

Pour avoir la liste de tous les utilisateurs avec le pays

correspondant, il est possible d’effectuer une requête SQL
similaire à celle-ci :
SELECT *
FROM utilisateur
NATURAL JOIN pays

Cette requête retournera le résultat suivant :

159
pays_id user_id user_pre user_vill pays_no
 nom e m
1 1 Jérémie Paris France
2 2 Damien Lyon Canada
NULL 3 Sophie Marseill NULL
e
9999 4 Yann Lille NULL
1 5 Léa Paris France

Cet exemple montre qu’il y a bien eu une jointure entre

les 2 tables grâce à la colonne « pays_id » qui se trouve
dans l’une et l’autre des tables.
SQL Sous-requête
Dans le langage SQL une sous-requête (aussi appelé «
requête imbriquée » ou « requête en cascade ») consiste
à exécuter une requête à l’intérieur d’une autre requête.
Une requête imbriquée est souvent utilisée au sein d’une
clause WHERE ou de HAVING pou remplacer une ou
plusieurs constante.

Syntaxe
Il y a plusieurs façons d’utiliser les sous-requêtes. De cette
façon il y a plusieurs syntaxes envisageables pour utiliser
des requêtes dans des requêtes.
 Requête imbriquée qui retourne un seul
résultat
L’exemple ci-dessous est une exemple typique d’une
sous-requête qui retourne un seul résultat à la requête
principale.
SELECT *
FROM `table`
WHERE `nom_colonne` = (
SELECT `valeur`
FROM `table2`
LIMIT 1
)

162
Cet exemple montre une requête interne (celle sur «
table2″) qui renvoi une seule valeur. La requête externe
quant à elle, va chercher les résultat de « table » et filtre
les résultats à partir de la valeur retournée par la requête
interne.
A noter : il est possible d’utiliser n’importe quel opérateur
d’égalité tel que =, >, <, >=, <= ou <>.

Requête imbriquée qui retourne une colonne

Une requête imbriquée peut également retournée une
colonne entière. Dès lors, la requête externe peut utiliser
la commande IN pour filtrer les lignes qui possèdent une
des valeurs retournées par la requête interne. L’exemple 140
163
 ci-dessous met en évidence un tel cas de
SELECT *
FROM `table`

figure :
WHERE `nom_colonne` IN (
SELECT `colonne`
FROM `table2`
WHERE `cle_etrangere` = 36
)

Exemple
La suite de cet article présente des exemples concrets
164
utilisant les sous-requêtes.
Imaginons un site web qui permet de poser des questions
et d’y répondre. Un tel site possède une base de données
avec une table pour les questions et une autre pour les
réponses.
Table « question » :

q_ q_dat q_titre q_contenu

id e_ajo
ut
1 2013- Comment Bonjour, j'ai mon
03-24 réparer ordinateur de cassé,
un comment puis-je
[Link] ordinateu procéder pour le réparer?
 32 r?
2 2013- Commen Quel est la meilleur
03-26 t changer méthode pour changer
[Link] un pneu? un pneu facilement ?
41
3 2013- Que faire Est-il préférable de
04-18 si un réparer les appareils
électriques ou
[Link] appareil d'en acheter de
56 est nouveaux?
cassé?
4 2013- Comme Bonjour, sous mon clavier
04-22 nt faire d'ordinateur il y a
 [Link] nettoyer beaucoup de poussière,
27 un comment faut-il procéder
clavier pour le nettoyer?
d'ordinat Merci.
eur?

Table « reponse » :

r_i r_fk_qu r_date r_contenu

d estion_i _ajout
d
1 1 2013- Bonjour. Pouvez-vous
03-27 expliquer ce qui ne 167
 [Link] fonctionne pas avec votre
2 ordinateur? Merci.
2 1 2013- Bonsoir, le plus simple
03-28 consiste à faire appel à un
[Link] professionnel pour réparer
1 un ordinateur.
Cordialement,
3 2 2013- Des conseils son disponible
05-09 sur internet sur ce sujet.
[Link]
9
4 3 2013- Bonjour. Ça dépend de
05-24 vous, de votre budget et de
 [Link] vos préférence vis-à-vis de
2 l'écologie. Cordialement,
Requête imbriquée qui retourne un seul
résultat
Avec une telle application, il est peut-être utile de
connaître la question liée à la dernière réponse ajoutée sur
l’application. Cela peut être effectué via la requête SQL
suivante :
SELECT *
FROM `question`
WHERE q_id = (
SELECT r_fk_question_id
FROM `reponse`
ORDER BY r_date_ajout DESC
LIMIT 1
)

169
 Une telle requête va retourner la ligne
suivante :
q_ q_dat q_titre q_contenu
id e_ajo
ut
3 2013- Que faire Est-il préférable de
04-18 si un réparer les appareils
électriques ou
[Link] appareil d'en acheter de
56 est nouveaux?
cassé?
170
Ce résultat démontre que la question liée à la dernière
réponse sur le forum est bien trouvée à partir de ce
résultat.

Requête imbriquée qui retourne une colonne

Imaginons maintenant que l’ont souhaite obtenir les
questions liées à toutes les réponses comprises entre 2
dates. Ces questions peuvent être récupérée par la
requête SQL suivante :
 SELECT *
FROM `question`
WHERE q_id IN (
SELECT r_fk_question_id
FROM `reponse`
WHERE r_date_ajout BETWEEN '2013-01-01' AND '2013-12-31'
)

Résultats :
q_ q_dat q_titre q_contenu
id e_ajo
ut
1 2013- Commen Bonjour, j'ai mon
03-24 t réparer ordinateur de cassé,
[Link] un comment puis-je
32 ordinate procéder pour le
ur? réparer?
2 2013- Commen Quel est la meilleur
03-26 t changer méthode pour changer
[Link] un pneu? un pneu facilement ?
41
3 2013- Que faire Est-il préférable de
150
173