Université Cheikh Anta Diop de Dakar

Ecole supérieure polytechnique

Le langage SQL

2024/2025 M.GOUDIABY
Historique de SQL
• Le langage SQL (Structured Query Language) est un langage élaboré
dans les années 1970 par un informaticien britannique du nom de
Edgar Frank Codd !
• Oracle fut la première entreprise a misé sur ce langage !
• Une requête SQL peut être portée sans modifications (ou
modifications de mineures) de MYSQL à Oracle ou dʼOracle à SQL
Server
Structuration du Langage SQL
• Le langage SQL est composé de trois langages:
❑Le langage de définition des données (LDD) qui permet de créer ou
modifier les structures d'une base de données
❑ Le Langage de Manipulation des données (LMD) qui permet de
consulter ou de modifier le contenu d'une base de données "
❑Le langage de contrôle de données (LCD) qui permet de gérer les
privilèges ou les différents droits des utilisateurs sur la base de
données
Structuration du Langage SQL
Langage de Définition des Données (LDD)
• Syntaxe de Create Table
CREATE TABLE NOMTABLE (
Colonne1 type1 [DEFAULT valeur1] [NOT NULL] ,
Colonne2 type2 [DEFAULT valeur2] [NOT NULL],
CONSTRAINT nomContrainte1 typeContrainte1,
CONSTRAINT nomContrainte2 typeContrainte2
...) ;
❑NomTable : peut comporter des lettres majuscules ou minuscules, des
chiffres et les symboles, par exemple : _, $ et #.
❑ Colonne type: nom d’une colonne et son type (voir les types SQL.). La
directive DEFAULT fixe une valeur par défaut. La directive NOT NULL
interdit que la valeur de la colonne soit nulle.
❑ NomContrainte typeContrainte: nom de la contrainte et son type (clé
primaire, clé étrangère, etc.).
❑ ; : symbole qui termine une instruction SQL
Les types de contraintes
❑ UNIQUE (colonne1 [,colonne2]...)
❑ PRIMARY KEY (colonne1 [,colonne2]...
❑ FOREIGN KEY (colonne1 [,colonne2]...
REFERENCES nomTablePere (colonne1 [,colonne2]...)
[ON DELETE { CASCADE | SET NULL }]
❑ CHECK (condition)
❑La contrainte UNIQUE impose une valeur distincte au niveau de la
table (les valeurs nulles font exception à moins que NOT NULL soit
aussi appliquée sur les colonnes).

❑ La contrainte PRIMARY KEY déclare la clé primaire de la table. Un

index est généré automatiquement sur la ou les colonnes concernées.
Les valeurs des colonnes clés primaires ne peuvent être ni nulles ni
identiques
❑La contrainte FOREIGN KEY déclare une clé étrangère entre une table
enfant (child) et une table père (parent)..
o La directive ON DELETE dispose de deux options :
- CASCADE propagera la suppression de tous les enregistrements
fils rattachés à l’enregistrement père supprimé, !
- SET NULL positionnera seulement leur clé étrangère à NULL .
❑ La contrainte CHECK impose un domaine de valeurs ou une
condition simple ou complexe entre colonnes
- CHECK (note BETWEEN 0 AND 20),
- CHECK (Sexe=’M' OR Sexe=’F')).
Création de la Table Client

❑CREATE TABLE CLIENT

( Numcli INTEGER NOT NULL,
Prenom CHAR (25) NOT NULL,
Nom CHAR (20) NOT NULL,
Ville CHAR (25) NOT NULL,
Telephone CHAR (12),
CONSTRAINT Client PRIMARY KEY (Numcli),
);
Création de la Table Article

❑CREATE TABLE ARTICLE (

Refart CHAR (5) NOT NULL,
Designation CHAR (20) NOT NULL,
Categorie CHAR (25) NOT NULL,
Prix INTEGER NOT NULL ,
CONSTRAINT Article PRIMARY KEY (refart)
);
 Création de la Table Achat

❑CREATE TABLE ACHAT (

Numclient INTEGER NOT NULL,
Refarticle CHAR (5) NOT NULL,
Dateachat DATE,
Quantite INTEGER,
CONSTRAINT fk_Ach_numclient_Cli FOREIGN KEY
(numclient) REFERENCES CLIENT (numcli)
on DELETE CASCADE,
CONSTRAINT Ach_refarticle_Cli FOREIGN KEY (refarticle) REFERENCES
ARTICLE(refart)
On DELETE SET NULL
);
Contraintes sur une table
Clé de la relation
CONSTRAINT nomCtr PRIMARY KEY (liste attr)
Exemple:
CONSTRAINT Client PRIMARY KEY (Numcli)
Le contrainte pk_Client définit l’attribut Numcli comme étant la clé
de la relation Client
Les valeurs d’une clé sont toutes différentes et ne peuvent pas être
nulles
Contraintes sur une table
Contrainte d’intégrité référentielle
CONSTRAINT nomCtr FOREIGN KEY (attr local) REFERENCES
relRéf(attrRéf)
• La valeur de l’attribut local (également appelé clé étrangère) n’est
acceptable que si elle appartient à l’ensemble des valeurs de l’attribut
de référence
• Exemple:
CONSTRAINT Ach_numclient_ FOREIGN KEY (numclient)
REFERENCES CLIENT (numcli)
Contraintes sur une table

Attribut à valeur unique

CONSTRAINT nomCtr UNIQUE liste_attributs
Une déclaration de contrainte unique est moins forte que primary key:
dans ce cas, l’unicité est assurée, mais avec possibilité de valeur nulle
Table Fournisseur

CREATE TABLE Fournisseur (

numFour VARCHAR(2) NOT NULL,
nomFour VARCHAR(15) NOT NULL,
remise NUMBER(2),
ville VARCHAR(15),
CONSTRAINT cle_Four PRIMARY KEY (numFour)
);
NULL par défaut, i.e. l’attribut peut ne pas avoir été renseigné
Exemples
Table Produit

CREATE TABLE Produit (

numProd VARCHAR(2) NOT NULL,
nomProd VARCHAR(15) NOT NULL,
couleur VARCHAR(10),
poids NUMBER(5,2),
origine VARCHAR(15),
CONSTRAINT cle_Prod PRIMARY KEY (numProd)
);
Exemples
Table Stock
CREATE TABLE Stock ( numFour VARCHAR(2) NOT NULL,
numProd VARCHAR(2) NOT NULL,
qte NUMBER(4),
CONSTRAINT cle_Stock
PRIMARY KEY (numFour,numProd),
CONSTRAINT fourOk FOREIGN KEY (numFour)
REFERENCES Fournisseur(numFour),
CONSTRAINT prodOk FOREIGN KEY (numProd)
REFERENCES Produit(numProd),
CONSTRAINT qteOk CHECK (qte>0)
);
Suppression d’une table
Une table est supprimée à l’aide de la commande SQL DROP TABLE
DROP TABLE Stock
• Cette commande supprime non seulement les tuples de la table, mais
également la table elle-même
• Il ne sera plus possible d’insérer de tuple dans cette table (puisqu’elle
n’existe plus !)
Suppression d’une table et renommage
Suppression d’une colonne ou d’une contrainte
ALTER TABLE CLIENT DROP COLUMN EMAIL;
ALTER TABLE CLIENT DROP CONSTRAINT client;
Renommage
RENAME TABLE AncienNom TO NouveauNom;
Suppression d’une table
DROP TABLE NOM_TABLE;
Langage de Manipulation des Données (LMD)
Insertion ou Mise à Jour
L’insertion d’un tuple dans une table est réalisée via la commande
INSERT INTO
INSERT INTO Stock VALUES (’f1’,’p1’,300)
INSERT INTO Fournisseur VALUES (’f1’,’Dupont’,0,’Paris’)
• Si certains attributs sont déclarés not null (cas des clés par ex.), vous
devez leur donner une valeur
• Sinon, vous pouvez donner la valeur NULL (attribut non renseigné)
EXEMPLE D’APPLICATION AVEC INSERT INTO

INSERT INTO CLIENT VALUES

(1,’DIAW’,’JEAN’,’LOUGA’,’77 442 23 33’),
(2,’KA’,’BERNARD’,’DAKAR’,’77 344 23 88’),
(3,’NANGO’,’TOTO’,’ZIGUINCHOR’,’76 332 44 62’),
(4,’MENDY’,’BOB’,’ZIGUINCHOR’,’76 222 33 47’),
(5,’DIAMANKA’,’CHRISTOPHE’,’ZIGUINCHOR’, ’70 443 66 34’);
EXEMPLE D’APPLICATION AVEC INSERT INTO

INSERT INTO ARTICLE VALUES(‘1B3F’,’YOUSSOU NDOUR’,’CD’,3000);

EXEMPLE D’APPLICATION AVEC INSERT INTO

INSERT INTO ACHAT VALUES(1,’1B3F’,’2009-01-30’,5)

Instruction SELECT
Construction de base d’une requête SQL
Select a1,…,ap
From T1,…,Tn
Where B
• Avec :
– les a1 sont des attributs et représentent le résultat attendu de la
requête
– les T1 indiquent quelles sont les tables concernées par cette
requête (où vont être récupérées les informations)
– B est une condition booléenne sur les a1
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.
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.
Table « client » :

Identifiant Prénom Nom ville

1 Pierre Dupond Dakar

2 Sabrina Durand Thiès

3 Julien Martin Tamba

4 David Bernard Kolda

5 Marie Leroy Mbour

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

Dakar

Thiès

Tamba

Kolda

Mbour
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
Résultat :

Prénom 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. 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 :

Identifiant Prénom Nom ville

1 Pierre Dupond Dakar
2 Sabrina Durand Thiès
3 Julien Martin Tamba
4 David Bernard Kolda
5 Marie Leroy Mbour

Il y a des avantages et des inconvénient à l’utiliser. Pour en savoir

plus sur le sujet il est recommandé de lire l’article avantage et
inconvénient du sélecteur étoile.
SQL DISTINCT
L’utilisation de la commande SELECT en SQL permet de lire toutes 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.
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.
Exemple :
Prenons le cas concret d’une table « client » qui contient des noms et
prénoms :
Identifiant Prénom Nom

1 Pierre Dupond

2 Sabrina Durand

3 Julien Martin

4 David Bernard

5 Pierre Leroy
En utilisant seulement SELECT tous 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
Résultat :
Prénom
Pierre
Sabrina
Julien
David

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.
SQL WHERE
La commande WHERE dans une requête SQL permet d’extraire les
lignes d’une base de données qui respectent une condition. Cela permet
d’obtenir uniquement les informations désirées.

Syntaxe La commande WHERE s’utilise en complément à une requête

utilisant SELECT. La façon la plus simple de l’utiliser est la suivante :
SELECT nom_colonnes
FROM nom_table
WHERE condition
Exemple :
Imaginons une base de données appelée « client » qui contient le nom
des clients, le nombre de commandes qu’ils ont effectués et leur ville :
Id Nom Nbr_Commande ville
1 Paul 3 dakar
2 Maurice 0 thiès
3 Joséphine 1 kolda
4 Gérard 7 dakar

Pour obtenir seulement la liste des clients qui habitent à dakar, il faut effectuer la
requête suivante :
SELECT *
FROM client
WHERE ville = ‘dakar'
Résultat :
Id Nom Nbr_Commande ville

1 Paul 3 dakar

4 Gérard 7 dakar

Attention : dans notre cas tout est en minuscule donc il n’y a pas eu
de problème. Cependant, si un table est sensible à la casse, il faut
faire attention aux majuscules et minuscules.
Opérateurs de comparaisons
Il existe plusieurs opérateurs de comparaisons. La liste ci-jointe présente
quelques uns des opérateurs les plus couramment utilisés.
Opérateur Description
= Égale
<> Pas égale
!= Pas égale
> Supérieur à
< Inférieur à
>= Supérieur ou égale à
<= Inférieur ou égale à
IN Liste de plusieurs valeurs possibles
BETWEEN Valeur comprise dans un intervalle donnée (utile pour les nombres ou dates)
LIKE Recherche en spécifiant le début, milieu ou fin d'un mot
IS NULL Valeur est nulle
IS NOT NULL Valeur n’est pas nulle
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.
Alias sur une table
Permet d’attribuer un autre nom à une table dans une requête SQL. Cela
peut aider à avoir des noms plus court, plus simple et plus facilement
compréhensible. Ceci est particulièrement vrai lorsqu’il y a des jointures.
Syntaxe
Alias sur une colonne
La syntaxe pour renommer une colonne de colonne1 à c1 est la suivante :
SELECT colonne1 AS c1, colonne2
FROM `table`
Cette syntaxe peut également s’afficher de la façon suivante :
SELECT colonne1 c1, colonne2
FROM `table`
A noter : à choisir il est préférable d’utiliser la commande « AS » pour que
ce soit plus explicite (plus simple à lire qu’un simple espace), d’autant plus
que c’est recommandé dans le standard ISO pour concevoir une requête
SQL.
Alias sur une table
La syntaxe pour renommer une table dans une requête est la suivante :
SELECT *
FROM `nom_table` AS t1
Cette requête peut également s’écrire de la façon suivante :
SELECT *
FROM `table`t1
SQL AND & OR
Une requête SQL peut être restreinte à l’aide de la condition WHERE.
Les opérateurs logiques AND et OR peuvent être utilisées au sein de la
commande WHERE pour combiner des conditions.
Syntaxe d’utilisation des opérateurs AND et OR Les opérateurs sont à
ajouter dans la condition WHERE. Ils peuvent être combinés à l’infini
pour filtrer les données comme souhaités.
• L’opérateur AND permet de s’assurer que la condition1 ET la
condition2 sont vrai :
SELECT nom_colonnes
FROM nom_table
WHERE condition1 AND condition2
• L’opérateur OR vérifie quant à lui que la condition1 OU la condition2 est
vrai :
SELECT nom_colonnes
FROM nom_table
WHERE condition1 OR condition2
Ces opérateurs peuvent être combinés à l’infini et mélangés. L’exemple ci-
dessous filtre les résultats de la table « nom_table » si condition1 ET
condition2 OU condition3 est vrai :
SELECT nom_colonnes
FROM nom_table
WHERE condition1 AND (condition2 OR condition3)
Attention : il faut penser à utiliser des parenthèses lorsque c’est nécessaire.
Cela permet d’éviter les erreurs car et ça améliore la lecture d’une requête
par un humain.
Exemple de données : la table « produit »
Id Nom catégorie stock prix
1 ordinateur informatique 5 95O00
2 clavier informatique 32 3500
3 souris informatique 16 3000
4 crayon fourniture 147 2000

Opérateur AND
L’opérateur AND permet de joindre plusieurs conditions dans une
requête. En gardant la même table que précédemment, pour filtrer
uniquement les produits informatique qui sont presque en rupture de
stock (moins de 20 produits disponible) il faut exécuter la requête
suivante :
SELECT *
FROM produit
WHERE catégorie = 'informatique' AND stock < 20
Résultat :
Id Nom catégorie stock prix

1 ordinateur informatique 5 95O00

3 souris informatique 16 3000

Opérateur OR
Pour filtrer les données pour avoir uniquement les données sur les
produits « ordinateur » ou « clavier » il faut effectuer la recherche
suivante :
SELECT *
FROM produit
WHERE nom = 'ordinateur' OR nom = 'clavier'
Résultat :
Id Nom catégorie stock prix

1 ordinateur informatique 5 95O00

2 clavier informatique 32 3500

Combiner AND et OR
Il ne faut pas oublier que les opérateurs peuvent être combinés pour
effectuer de puissantes recherche. Il est possible de filtrer les produits
« informatique » avec un stock inférieur à 20 et les produits « fourniture »
avec un stock inférieur à 200 avec la recherche suivante :
SELECT *
FROM produit
WHERE ( catégorie = 'informatique' AND stock < 20 )
OR ( catégorie = ‘fourniture' AND stock < 200 )
Résultats :
Id Nom catégorie stock prix

1 ordinateur informatique 5 95O00

2 souris informatique 16 3500

4 crayon fourniture 147 2000

 SQL IN
L’opérateur logique IN dans SQL s’utilise avec la commande WHERE pour
vérifier si une colonne est égale à une des valeurs comprise dans set de valeurs
déterminés.
C’est une méthode simple pour vérifier si une colonne est égale à une valeur OU
une autre valeur OU une autre valeur et ainsi de suite, sans avoir à utiliser de
multiple fois l’opérateur OR.
Syntaxe
Pour chercher toutes les lignes où la colonne « nom_colonne » est égale à ‘valeur
1′ OU ‘valeur 2′ ou ‘valeur 3′, il est possible d’utiliser la syntaxe suivante :
SELECT nom_colonne
FROM table
WHERE nom_colonne IN ( valeur1, valeur2, valeur3, ... )
A savoir : entre les parenthèses il n’y a pas de limite du nombre
d’arguments. Il est possible d’ajouter encore d’autres valeurs.
Cette syntaxe peut être associée à l’opérateur NOT pour recherche toutes
les lignes qui ne sont pas égales à l’une des valeurs stipulées.

Simplicité de l’opérateur IN
La syntaxe utilisée avec l’opérateur est plus simple que d’utiliser une
succession d’opérateur OR.
Pour le montrer concrètement avec un exemple, voici 2 requêtes qui
retournerons les mêmes résultats, l’une utilise l’opérateur IN, tandis que
l’autre utilise plusieurs OR.
Requête avec plusieurs OR
SELECT prenom
FROM utilisateur
WHERE prenom = 'Maurice' OR prenom = 'Marie' OR prenom = 'Thimoté’

Requête équivalent avec l’opérateur IN

SELECT prenom
FROM utilisateur
WHERE prenom IN ( 'Maurice', 'Marie', 'Thimoté' )
Exemple :
Imaginons une table « adresse » qui contient une liste d’adresse associée à
des utilisateurs d’une application.
id id_utilisateur addr_rue addr_code_postal addr_ville

1 35 Rue Madeleine Pelletier 25250 Bournois

2 43 21 Rue du Moulin Collet 75006 Paris

3 65 28 Avenue de Cornouaille 27220 Mousseaux-Neuville

4 67 41 Rue Marcel de la Provoté 76430 Graimbouville

5 68 18 Avenue de Navarre 75009 Paris

Si l’ont souhaite obtenir les enregistrements des adresses de Paris et de
Graimbouville, il est possible d’utiliser la requête suivante :
SELECT *
FROM adresse
WHERE addr_ville IN ( 'Paris', 'Graimbouville’ )
Résultats :
id id_utilisateur addr_rue addr_code_postal addr_ville

2 43 21 Rue du Moulin Collet 75006 Paris

4 67 41 Rue Marcel de la Provoté 76430 Graimbouville

5 68 18 Avenue de Navarre 75009 Paris

SQL BETWEEN
L’opérateur BETWEEN est utilisé dans une requête SQL pour
sélectionner un intervalle de données dans une requête utilisant WHERE.
L’intervalle peut être constitué de chaînes de caractères, de nombres ou de
dates.
L’exemple le plus concret consiste par exemple à récupérer uniquement
les enregistrements entre 2 dates définies.
Syntaxe :
L’utilisation de la commande BETWEEN s’effectue de la manière
suivante :
SELECT *
FROM table
WHERE nom_colonne BETWEEN 'valeur1' AND 'valeur2’

La requête suivante retournera toutes les lignes dont la valeur de la

colonne « nom_colonne » sera comprise entre valeur1 et valeur2.
Exemple : filtrer entre 2 dates
Imaginons une table « utilisateur » qui contient les membres d’une
application en ligne.
id nom Date_inscription

1 Maurice 2012/03/02

2 Simon 2012/03/05

3 Chloé 2012/04/14

4 Marie 2012/04/15

5 Clémentine 2012/04/26

Si l’ont souhaite obtenir les membres qui se sont inscrit entre le 1 avril
2012 et le 20 avril 2012 il est possible d’effectuer la requête suivante :
SELECT *
FROM utilisateur
WHERE date_inscription BETWEEN ’2012-04-01′ AND ’2012-04-20′
id nom Date_inscription

3 Chloé 2012/04/14

4 Marie 2012/04/15

Exemple : filtrer entre 2 entiers

Si l’ont souhaite obtenir tous les résultats dont l’identifiant n’est pas
situé entre 4 et 10, il faudra alors utiliser la requête suivante :
SELECT *
FROM utilisateur
WHERE id NOT BETWEEN 4 AND 10

Résultat :
id nom Date_inscription

1 Maurice 2012/03/02

2 Simon 2012/03/05

3 Chloé 2012/04/14
SQL LIKE
L’opérateur LIKE est utilisé dans la clause WHERE des requêtes SQL.
Ce mot-clé permet d’effectuer une recherche sur un modèle particulier.
Il est par exemple possible de rechercher les enregistrements dont la
valeur d’une colonne commence par telle ou telle lettre.
Les modèles de recherches sont multiple.
La syntaxe à utiliser pour utiliser l’opérateur LIKE est la suivante :
SELECT *
FROM table
WHERE colonne LIKE modele à rechercher
✓LIKE ‘%a’ : le caractère « % » est un caractère joker qui remplace
tous les autres caractères.

Ainsi, ce modèle permet de rechercher toutes les chaines de caractère

qui se termine par un « a ».

✓ LIKE ‘a%’ : ce modèle permet de rechercher toutes les lignes de «

colonne » qui commence par un « a ».

✓ LIKE ‘%a%’ : ce modèle est utilisé pour rechercher tous les

enregistrement qui utilisent le caractère « a ».
✓LIKE ‘pa%on’ : ce modèle permet de rechercher les chaines qui
commence par « pa » et qui se terminent par « on », comme « pantalon »
ou « pardon ».
Exemple :
Imaginons une table « client » qui contient les enregistrement d’utilisateurs :
Id Nom ville

1 Léon Lyon

2 Odette Nice

3 Vivien Nantes

4 Etienne Lille
Obtenir les résultats qui commencent par « N »
Si l’ont souhaite obtenir uniquement les clients des villes qui
commencent par un « N », il est possible d’utiliser la requête suivante :
SELECT *
FROM client
WHERE ville LIKE 'N%’
Avec cette requête, seul les enregistrements suivants seront retournés :

Id Nom ville

2 Odette Nice

3 Vivien Nantes
Obtenir les résultats terminent par « e »
Requête : SELECT *
FROM client
WHERE ville LIKE '%e’
Résultat :

Id Nom ville

2 Odette Nice

4 Etienne Lille
SQL IS NULL / IS NOT NULL
Dans le langage SQL, l’opérateur IS permet de filtrer les résultats qui
contiennent la valeur NULL.
Cet opérateur est indispensable car la valeur NULL est une valeur inconnue
et ne peut par conséquent pas être filtrée par les opérateurs de comparaison
(cf. égal, inférieur, supérieur ou différent).
Syntaxe
Pour filtrer les résultats où les champs d’une colonne sont à NULL il
convient d’utiliser la syntaxe suivante :
SELECT *
FROM `table`
WHERE nom_colonne IS NULL
A l’inverse, pour filtrer les résultats et obtenir uniquement les
enregistrements qui ne sont pas null, il convient d’utiliser la syntaxe
suivante :
SELECT *
FROM `table`
WHERE nom_colonne IS NOT NULL
A savoir :
l’opérateur IS retourne en réalité un booléen, c’est à dire une valeur
TRUE si la condition est vrai ou FALSE si la condition n’est pas
respectée. Cet opérateur est souvent utilisé avec la condition WHERE
mais peut aussi trouvé son utilité lorsqu’une sous-requête est utilisée.
Exemple :
Imaginons une application qui possède une table contenant les
utilisateurs. Cette table possède 2 colonnes pour associer les adresses de
livraison et de facturation à un utilisateur (grâce à une clé étrangère). Si
cet utilisateur n’a pas d’adresse de facturation ou de livraison, alors le
champ reste à NULL.
Table « utilisateur » :
id nom date_inscription fk_adresse_livraison_id fk_adresse_facturation_id

23 Grégoire 2013/02/12 12 12

24 Sarah 2013/02/17 NULL NULL

25 Anne 2013/02/21 13 14

26 Frédérique 2013/02/02 NULL NULL

Exemple 1 : utilisateurs sans adresse de livraison
Il est possible d’obtenir la liste des utilisateurs qui ne possèdent pas
d’adresse de livraison en utilisant la requête SQL suivante :
SELECT *
FROM `utilisateur`
WHERE `fk_adresse_livraison_id` IS NULL
id nom date_inscription fk_adresse_livraison_id fk_adresse_facturation_id

24 Sarah 2013/02/17 NULL NULL

26 Frédérique 2013/02/02 NULL NULL

Les enregistrements retournés montrent bien que seul les utilisateurs ayant la valeur NULL pour le
champ de l’adresse de livraison.
Exemple 2 : utilisateurs avec une adresse de livraison
Pour obtenir uniquement les utilisateurs qui possèdent une adresse de
livraison il convient de lancer la requête SQL suivante :
SELECT *
FROM `utilisateur`
WHERE `fk_adresse_livraison_id` IS NOT NULL
Résultat :
id nom date_inscription fk_adresse_livraison_id fk_adresse_facturation_id

23 Grégoire 2013/02/12 12 12

25 Anne 2013/02/21 13 14

Les lignes retournés sont exclusivement celles qui n’ont pas une valeur NULL pour le champ de
l’adresse de livraison.
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 :
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 :
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 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 :
SELECT client, 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 :
client SUM(tarif)

Pierre 262

Simon 47

Marie 38
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 :
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 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.
SQL SUM()
Dans le langage SQL, la fonction d’agrégation SUM() permet de calculer la
somme totale d’une colonne contenant des valeurs numériques. Cette
fonction ne fonction que sur des colonnes de types numériques (INT,
FLOAT …) et n’additionne pas les valeurs NULL.
La syntaxe pour utiliser cette fonction SQL peut être similaire à celle-ci:
SELECT SUM(nom_colonne)
FROM table
Cette requête SQL permet de calculer la somme des valeurs contenu dans la
colonne “nom_colonne”.
A savoir : Il est possible de filtrer les enregistrements avec la
commande WHERE pour ne calculer la somme que des éléments
souhaités.
Exemple
Imaginons un système qui gère des factures et enregistre chaque achat dans
une base de données. Ce système utilise une table “facture” contenant une
ligne pour chaque produit. La table ressemble à l’exemple ci-dessous :
id Facture_id produit prix
1 1 calculatrice 1700
2 1 agrafeuse 400
3 1 ciseaux 300
4 1 agenda 1500
5 2 calculatrice 1700
6 2 agenda 1500
SUM avec WHERE
Pour calculer le montant de la facture n°1 il est possible d’utiliser la
requête SQL suivante:
SELECT SUM(prix) as prix_total
FROM facture
WHERE facture_id = 1
Résultat :
prix
3900

Ce résultat démontre bien que tous les achats de la facture n°1

représente un montant de 3900fr (somme de 1700 + 400 + 300 + 1500).
Somme avec GROUP BY
Pour calculer la somme de chaque facture, il est possible de grouper les
lignes en se basant sur la colonne “facture_id”. Un tel résultat peut être
obtenu en utilisant la requête suivante:
SELECT facture_id, SUM(prix) as prix_total
FROM facture
GROUP BY facture_id
Résultat :
Fature_id Prix_total
1 3900
2 3200

Ce résultat montre bien qu’il est possible de déterminer le prix total de

chaque facture en utilisant la fonction d’agration SUM().
SQL AVG()
La fonction d’agrégation AVG() dans le langage SQL permet de calculer
une valeur moyenne sur un ensemble d’enregistrement de type numérique
et non nul.
Syntaxe
La syntaxe pour utiliser cette fonction de statistique est simple :
SELECT AVG(nom_colonne)
FROM nom_table
Cette requête permet de calculer la note moyenne de la colonne
“nom_colonne” sur tous les enregistrements de la table “nom_table”.
Il est possible de filtrer les enregistrements concernés à l’aide de la
commande WHERE.
Il est aussi possible d’utiliser la commande GROUP BY pour regrouper les
données appartenant à la même entité.
Exemple :
Imaginons une table “achat” qui représente toutes les ventes sur un site d’e-
commerce, dans laquelle on enregistre le montant de l’achat, la date et le
nom du client.
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
Pour connaitre le montant moyen effectué par chaque client, il est possible
d’utiliser une requête qui va utiliser :
• GROUP BY pour regrouper les ventes des mêmes clients
• La fonction AVG() pour calculer la moyenne des enregistrements
La requête sera donc la suivante
SELECT client, AVG(tarif)
FROM achat
GROUP BY client
Le résultat sera le suivant :
client AVG(tarif)
Pierre 131
Simon 47
Marie 19
SQL COUNT()
En SQL, la fonction d’agrégation COUNT() permet de compter le
nombre d’enregistrement dans une table.
Connaître le nombre de lignes dans une table est très pratique dans de
nombreux cas, par exemple pour savoir combien d’utilisateurs sont
présents dans une table ou pour connaître le nombre de commentaires
sur un article.
Syntaxe :
Pour connaître le nombre de lignes totales dans une table, il suffit
d’effectuer la requête SQL suivante :
SELECT COUNT(*) FROM table
Il est aussi possible de connaitre le nombre d’enregistrement sur une
colonne en particulier.
Les enregistrements qui possèdent la valeur nul ne seront pas
comptabilisé.
La syntaxe pour compter les enregistrement sur la colonne
“nom_colonne” est la suivante :
SELECT COUNT(nom_colonne)
FROM table
Exemple :
Imaginons une table qui liste les utilisateurs d’un site web d’e-commerce
Id Nom Ville Date_dinscrition Nombre_achat Id_dernier_achat
1 Marie Paris 2010-04-22 5 24
2 Louis Marseille 2011-08-18 3 36
3 Paul Lyon 2011-11-02 0 NULL
4 Léon Paris 2012-09-01 1 7
5 Paul Nantes 2013-01-10 0 NULL

Utilisation de COUNT(*)
Pour compter le nombre d’utilisateurs total depuis que le site existe, il
suffit d’utiliser COUNT(*) sur toute la table :
SELECT COUNT(*) FROM utilisateur
Résultat :
Count(*)
5

Utilisation de COUNT(*) avec WHERE

Pour compter le nombre d’utilisateur qui ont effectué au moins un achat, il
suffit de faire la même chose mais en filtrant les enregistrements avec
WHERE :
SELECT COUNT(*) FROM utilisateur Where nombre_achat > 0
Count(*)
3
Utilisation de COUNT(colonne)
Une autre méthode permet de compter le nombre d’utilisateurs ayant
effectué au moins un achat. Il est possible de compter le nombre
d’enregistrement sur la colonne “id_dernier_achat”.
Sachant que la valeur est nulle s’il n’y a pas d’achat, les lignes ne seront
pas comptées s’il n’y a pas eu d’achat. La requête est donc la suivante :
SELECT COUNT(Id_dernier_achat) FROM utilisateur
Résultat :
Count(id_dernier_achat)
3
SQL MAX()
Dans le langage SQL, la fonction d’agrégation MAX() permet de
retourner la valeur maximale d’une colonne dans un set
d’enregistrement.
La fonction peut s’appliquée à des données numériques
ou alphanumériques. Il est par exemple possible de rechercher le produit
le plus cher dans une table d’une boutique en ligne.
Syntaxe :
La syntaxe de la requête SQL pour retourner la valeur maximum de la
colonne “nom_colonne” est la suivante:
SELECT MAX(nom_colonne)
FROM table

Lorsque cette fonctionnalité est utilisée en association avec la

commande GROUP BY, la requête peut ressembler à l’exemple ci-
dessous:
SELECT colonne1, MAX(colonne2)
FROM table
GROUP BY colonne1
Exemple :
Imaginons un site d’e-commerce qui possède une table “produit” sur lequel
on peut retrouver des produits informatiques.
Id Nom prix
1 clavier 5000
2 souris 2100
3 écran 12000
4 disque dur 15000

Pour extraire uniquement le tarif le plus élevé dans la table, il est possible
d’utiliser la requête suivante:
SELECT MAX(prix)
FROM produit
Le résultat sera le suivant :
Max(prix)
15000

Connaître l’enregistrement ayant la valeur maximale

Il est aussi possible d’afficher le nom du produit le plus cher en même
temps que d’afficher son prix.
SELECT id, nom, MAX(prix) FROM produit
Le résultat de cette requête sera le suivant :
Id Nom Max(prix)
4 Disque dur 15000
SQL MIN()
La fonction d’agrégation MIN() de SQL permet de retourner la plus petite
valeur d’une colonne sélectionnée.
Cette fonction s’applique aussi bien à des données numériques qu’à des
données alphanumériques.
Syntaxe :
Pour obtenir la plus petite valeur de la colonne “nom_colonne” il est
possible d’utiliser la requête SQL suivante:
SELECT MIN(nom_colonne)
FROM table
Étant données qu’il s’agit d’une fonction d’agrégation, il est possible de
l’utiliser en complément de la commande GROUP BY.
Cela permet de grouper des colonnes et de connaître la plus petite valeur
pour chaque groupe.
La syntaxe est alors la suivante :
SELECT colonne1, MIN(colonne2)
FROM table
GROUP BY colonne1
Cette exemple permet de grouper tous les enregistrements de
“colonne1” de la table et de connaître la plus petite valeur de
“colonne2” pour chacun de ces regroupement.
Exemple :
Imaginons la base de données d’une boutique en ligne qui contient des
produits divers. Ces produits possède une catégorie, un nom, un prix et
la date à laquelle ils ont été ajouté dans le catalogue.
Table produits :
Id Categorie Nom Prix Date_ajout
1 informatique Ordinateur 980000 2013-01-24
2 informatique Imprimante 700000 2013-02-10
3 maison Canapé 450000 2013-02-11
4 maison Aspirateur 200000 2013-04-04
Utilisation simple
Pour extraire le prix du produit le moins cher de la catégorie “maison”,
il est possible d’effectuer la requête SQL ci-dessous:
SELECT MIN(prix)
FROM produits
Where categorie = ‘maison’
Résultat :
prix
200000

Le résultat montre bien que le prix le moins cher est celui

de l’aspirateur qui coûte 200000fr
Utilisation dans un GROUP BY
Il est possible de connaître la date du premier ajout dans chaque catégorie.
Cela permet de savoir l’article le plus vieux dans le catalogue pour chaque
thématiques. Cela s’effectue à l’aide de la requête suivante:
SELECT categorie , MIN(date_ajout)
FROM produits
GROUP BY categorie
Résultats :
categorie MIN(date_ajout)
informatique 2013-01-24
maison 2013-02-11
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 :
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 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

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

Si dans cette table on souhaite récupérer la liste des clients qui ont
commandé plus de 40€, toute commandes confondu 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 :
client SUM(tarif)

Pierre 262

Simon 47
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
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
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 un base « utilisateur
» de test, qui contient les données suivantes :
id nom prenom date_inscription tarif_total
1 Durand Maurice 2012-02-05 145

2 Dupond Fabrice 2012-02-07 65

3 Durand Fabienne 2012-02-13 90

4 Dubois Chloré 2012-02-16 98

5 Dubois Simon 2012-02-23 27

Pour récupérer la liste de ces utilisateurs par ordre alphabétique du nom de
famille, il est possible d’utiliser la requête suivante :
SELECT *
FROM utilisateur
ORDER BY nom
Résultat :
id nom prenom date_inscription tarif_total
4 Dubois Chloré 2012-02-16 98
5 Dubois Simon 2012-02-23 27
2 Dupond Fabrice 2012-02-07 65
1 Durand Maurice 2012-02-05 145
3 Durand Fabienne 2012-02-13 90
En utilisant deux méthodes de tri, il est possible de 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 :
id nom prenom date_inscription tarif_total
5 Dubois Simon 2012-02-23 27
4 Dubois Chloré 2012-02-16 98
2 Dupond Fabrice 2012-02-07 65
3 Durand Fabienne 2012-02-13 90
1 Durand Maurice 2012-02-05 145
SQL LIMIT
La clause LIMIT est à utiliser dans une requête SQL pour spécifier le
nombre maximum de résultats que l’ont souhaite obtenir.
Syntaxe simple La syntaxe commune aux principales système de gestion
de bases de données est la suivante :
SELECT *
FROM table
LIMIT 10
Cette requête permet de récupérer seulement les 10 premiers résultats
d’une table.
Bien entendu, si la table contient moins de 10 résultats, alors la requête
retournera toutes les lignes.
SQL DELETE
La destruction de tuples se fait via la commande DELETE FROM qui
supprime tous les tuples vérifiant une certaines propriété.
En utilisant cette commande associé à WHERE il est possible de
sélectionner les lignes concernées qui seront supprimées.
DELETE FROM ‘table’
WHERE condition
La condition booléenne de la clause WHERE est soumise aux mêmes
règles que celle de l’instruction SELECT
Attention : s’il n’y a pas de condition WHERE alors toutes les lignes
seront supprimées et la table sera alors vide.
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
Cette syntaxe permet d’attribuer une nouvelle valeur à la colonne
nom_colonne_1 pour les lignes qui respectent la condition stipulé avec
WHERE.
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 condition
Commandes SQL pour mettre à jour la liste des tuples d’une table:
– insertion : INSERT INTO … VALUES(…)
– suppression : DELETE FROM … WHERE …
– modification : UPDATE … SET … WHERE …
❑Selection
SELECT [ALL/DISTINCT] att1, …, attn FROM Table1,…, Tablen
WHERE condition_recherchée;
Select [ALL/DISTINCT] * FROM Table1,…, Tablen WHERE
condition_recherchée
❑Insertion de données
INSERT INTO Nom_Table (colonne1,…, colonnen) VALUES
(val1,…,valn);
❑Mise à jour des données
UPDATE Nom_Table SET colonne1=nouvellevaleur WHERE
condition;
❑ Supression de donnés
DELETE FROM Nom_Table WHERE condition;
DELETE FROM Nom_Table;
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.
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

SQL INNER JOIN
Dans le langage SQL 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 :
SELECT *
FROM table1
INNER JOIN table2 ON table1.id = 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 table1.id = table2.fk_id
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 prenom nom email ville

1 Aimée Marechal [email protected] Paris

2 Esmée Lefort [email protected] Lyon

3 Marine Prevost [email protected] Lille

4 Luc Rolland [email protected] Marseille

Table commande :
Utilisateur_id date_achat Num_facture Prix_total

1 2013-01-23 A00103 203.14

2 2013-02-14 A00104 124.00

3 2013-02-17 A00105 149.45

4 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 utilisateur.id = commande.utilisateur_id
Résultats :
id prenom nom Date_achat Num_facture Prix_total
1 Aimée Marechal 2013-01-23 A00103 203.14
1 Aimée Marechal 2013-02-14 A00104 124.00
2 Esmée Lefort 2013-02-17 A00105 149.45
2 Esmée Lefort 2013-02-21 A00106 235.35

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.
Autre exemple soit la table Etudiant :
Num_Etudi Prenom Nom Adresse Date_Nais sexe
E1 Cousy Cécile ? ? F
E2 Pourcel Mathieu ? ? M
E3 Burgy Laurent ? ? M

Num_cours Nom_cours Nom_prof nbHC nbHTD nbHTP

C1 Java Munier 12 10 15
C2 Réseaux Bascour 24 30 40
C3 Maths Touré 20 18 24

Num_Etudi Nom_cours Note

E1 C1 18,5
E2 C2 15
E3 C3 9,5
Pour afficher toutes les étudiants de sexe M, il est possible d’utiliser la
requête suivante :
Select NumEtud,Nom,Prenom,Sexe
From Etudiant
Where Sexe=‘M’

Num_Etudi Prenom Nom Sexe

E2 Pourcel Mathieu M
E3 Burgy Laurent M
Jointure
Pour afficher Prenom, Nom, NomCours,NomProf et Note, il est possible
d’utiliser la requête suivante :
Select Nom,Prenom,NomCours,NomProf,Note
From Etudiant,Cours,Suit
Where (Suit.NumEtud = Etudiant.NumEtud)
and (Suit.NumCours = Cours.NumCours)
Résultat :

Prenom Nom Nom_cours Nom_prof Note

Cousy Cécile Java Munier 18,5
Pourcel Mathieu Réseaux Bascour 15
Burgy Laurent Java Munier 9,5
SQL Sous-requête
En langage SQL, une sous-requête (également nommée« requête
interne» ou « requête imbriquée») permet d'exécuter une requête à
l'intérieur d'une autre.
On utilise souvent une requête interne dans une clause WHERE ou
HAVING pour remplacer une ou plusieurs constantes.
Syntaxe :
Il existe différentes manières d'employer les sous-requêtes.
Par conséquent, plusieurs syntaxes peuvent être envisagées pour inclure des
requêtes à l'intérieur d'autres.
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 )
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 <>.