Académique Documents
Professionnel Documents
Culture Documents
Cours SQL
Cours SQL
_____________
Auteur
Tony Archambeau
24 mai 2014
Licence
Mis disposition selon les termes de la licence Creative Commons Attribution - Pas
dUtilisation Commerciale - Partage dans les Mmes Conditions 4.0 International..
Vous tes libres de reproduire, distribuer et communiquer cette cration au public
condition de faire un lien vers http://sql.sh, de redistribuer dans les mmes conditions et
de ne pas faire d'utilisation commerciale du cours.
1/89
sql.sh
Sommaire
SQL SELECT..........................................................................................................................................3
SQL DISTINCT........................................................................................................................................6
SQL AS (alias).........................................................................................................................................8
SQL WHERE.........................................................................................................................................11
SQL AND & OR.....................................................................................................................................13
SQL IN...................................................................................................................................................15
SQL BETWEEN.....................................................................................................................................17
SQL LIKE...............................................................................................................................................19
SQL IS NULL / IS NOT NULL................................................................................................................21
SQL GROUP BY...................................................................................................................................23
SQL HAVING.........................................................................................................................................25
SQL ORDER BY....................................................................................................................................27
SQL LIMIT.............................................................................................................................................29
SQL CASE.............................................................................................................................................31
SQL UNION...........................................................................................................................................35
SQL UNION ALL....................................................................................................................................37
SQL INTERSECT..................................................................................................................................39
SQL EXCEPT / MINUS.........................................................................................................................41
SQL INSERT INTO................................................................................................................................43
SQL ON DUPLICATE KEY UPDATE....................................................................................................45
SQL UPDATE........................................................................................................................................48
SQL DELETE........................................................................................................................................49
SQL MERGE.........................................................................................................................................50
SQL TRUNCATE TABLE.......................................................................................................................51
SQL CREATE DATABASE....................................................................................................................52
SQL DROP DATABASE........................................................................................................................53
SQL CREATE TABLE............................................................................................................................54
SQL ALTER TABLE...............................................................................................................................56
SQL DROP TABLE................................................................................................................................58
Jointure SQL.........................................................................................................................................59
SQL INNER JOIN..................................................................................................................................60
SQL CROSS JOIN................................................................................................................................62
SQL LEFT JOIN....................................................................................................................................64
SQL RIGHT JOIN..................................................................................................................................66
SQL FULL JOIN....................................................................................................................................68
SQL SELF JOIN....................................................................................................................................70
SQL NATURAL JOIN.............................................................................................................................72
SQL Sous-requte.................................................................................................................................74
SQL EXISTS..........................................................................................................................................77
SQL ALL................................................................................................................................................79
SQL ANY / SOME..................................................................................................................................80
Index SQL.............................................................................................................................................82
SQL CREATE INDEX............................................................................................................................83
SQL EXPLAIN.......................................................................................................................................85
Commentaires en SQL..........................................................................................................................88
2/89
sql.sh
SQL SELECT
Lutilisation la plus courante de SQL consiste lire des donnes issues de la base de donnes. Cela
seffectue grce la commande SELECT, qui retourne des enregistrements dans un tableau de
rsultat. Cette commande peut slectionner une ou plusieurs colonnes dune table.
Commande basique
Lutilisation basique de cette commande seffectue de la manire suivante :
SELECT nom_du_champ
FROM nom_du_tableau
Exemple
Imaginons une base de donnes appele client qui contient des informations sur les clients dune
entreprise.
Table client :
identifiant
prenom
nom
ville
Pierre
Dupond
Paris
Sabrina
Durand
Nantes
Julien
Martin
Lyon
David
Bernard
Marseille
Marie
Leroy
Grenoble
Si lont veut avoir la liste de toutes les villes des clients, il suffit deffectuer la requte suivante :
SELECT ville
FROM client
Rsultat :
ville
Paris
Nantes
Lyon
Marseille
Grenoble
3/89
sql.sh
Rsultat :
prenom
nom
Pierre
Dupond
Sabrina
Durand
Julien
Martin
David
Bernard
Marie
Leroy
Cette requte retourne exactement les mmes colonnes quil y a dans la base de donnes. Dans
notre cas, le rsultat sera donc :
identifiant
prenom
nom
ville
Pierre
Dupond
Paris
Sabrina
Durand
Nantes
Julien
Martin
Lyon
David
Bernard
Marseille
Marie
Leroy
Grenoble
Il y a des avantages et des inconvnient lutiliser. Pour en savoir plus sur le sujet il est recommand
de lire larticle avantage et inconvnient du slecteur toile.
sql.sh
SELECT *
FROM table
WHERE condition
GROUP BY expression
HAVING condition
{ UNION | INTERSECT | EXCEPT }
ORDER BY expression
LIMIT count
OFFSET start
A noter : cette requte imaginaire sert principale daide-mmoire pour savoir dans quel ordre sont
utilis chacun des commandes au sein dune requte SELECT.
5/89
sql.sh
SQL DISTINCT
Lutilisation de la commande SELECT en SQL permet de lire toutes les donnes dune ou plusieurs
colonnes. Cette commande peut potentiellement afficher des lignes en doubles. Pour viter des
redondances dans les rsultats il faut simplement ajouter DISTINCT aprs le mot SELECT.
Commande basique
Lutilisation basique de cette commande consiste alors effectuer la requte suivante :
SELECT DISTINCT ma_colonne
FROM nom_du_tableau
Exemple
Prenons le cas concret dune table client qui contient des noms et prnoms :
identifiant
prenom
nom
Pierre
Dupond
Sabrina
Bernard
David
Durand
Pierre
Leroy
Marie
Leroy
En utilisant seulement SELECT tous les noms sont retourns, or la table contient plusieurs fois le
mme prnom (cf. Pierre). Pour slectionner uniquement les prnoms uniques il faut utiliser la
requte suivante :
SELECT DISTINCT prenom
FROM client
Rsultat :
prenom
Pierre
Sabrina
6/89
sql.sh
David
Marie
Ce rsultat affiche volontairement quune seule fois le prnom Pierre grce lutilisation de la
commande DISTINCT qui naffiche que les rsultats distincts.
Intrt
Lutilisation de la commande DISTINCT est trs pratique pour viter les rsultats en doubles.
Cependant, pour optimiser les performances il est prfrable dutiliser la commande SQL GROUP BY
lorsque cest possible.
7/89
sql.sh
SQL AS (alias)
Dans le langage SQL il est possible dutiliser des alias pour renommer temporairement une colonne
ou une table dans une requte. Cette astuce est particulirement utile pour faciliter la lecture des
requtes.
Intrts et utilits
Alias sur une colonne
Permet de renommer le nom dune colonne dans les rsultats dune requte SQL. Cest pratique
pour avoir un nom facilement identifiable dans une application qui doit ensuite exploiter les rsultats
dune recherche.
Cas concrets dutilisations :
Une colonne qui sappelle normalement c_iso_3166 peut tre renomme 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 dveloppeur.
Une requte qui utilise la commande UNION sur des champs aux noms diffrents peut tre
ambigu pour un dveloppeur. En renommant les champs avec un mme nom il est plus simple
de traiter les rsultats.
Lorsquune fonction est utilis, le nom dune 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 combines il est plus simple de renommer la nouvelle
colonne qui est une concatnation de plusieurs champs.
Syntaxe
Alias sur une colonne
La syntaxe pour renommer une colonne de colonne1 c1 est la suivante :
SELECT colonne1 AS c1, colonne2
FROM `table`
A noter : choisir il est prfrable dutiliser la commande AS pour que ce soit plus explicite (plus
simple lire quun simple espace), dautant plus que cest recommand dans le standard ISO pour
concevoir une requte SQL.
8/89
sql.sh
Exemple
Renommer une colonne
Imaginons une site de-commerce qui possde une table de produits. Ces produits sont disponibles
dans une mme table dans plusieurs langues , dont le franais. Le nom du produit peut ainsi tre
disponible dans la colonne nom_fr_fr , nom_en_gb ou nom_en_us . Pour utiliser lun ou
lautre des titres dans le reste de lapplication sans avoir se soucier du nom de la colonne, il est
possible de renommer la colonne de son choix avec un nom gnrique. Dans notre cas, la requte
pourra ressemble ceci :
SELECT p_id, p_nom_fr_fr AS nom, p_description_fr_fr AS description,
p_prix_euro AS prix
FROM `produit`
Rsultat :
id
nom
description
prix
Ecran
Ecrandegrandestailles.
399.99
Clavier
Claviersansfil.
27
Souris
Sourissansfil.
24
Ordinateurportable
Grandeautonomieetetsacocheofferte.
700
9/89
sql.sh
Cette astuce est encore plus pratique lorsquil y a des noms de tables encore plus compliqus et
lorsquil y a beaucoup de jointures.
10/89
sql.sh
SQL WHERE
La commande WHERE dans une requte SQL permet dextraire les lignes dune base de donnes
qui respectent une condition. Cela permet dobtenir uniquement les informations dsires.
Syntaxe
La commande WHERE sutilise en complment une requte utilisant SELECT. La faon la plus
simple de lutiliser est la suivante :
SELECT nom_colonnes
FROM nom_table
WHERE condition
Exemple
Imaginons une base de donnes appele client qui contient le nom des clients, le nombre de
commandes quils ont effectus et leur ville :
id
nom
nbr_commande
ville
Paul
paris
Maurice
rennes
Josphine
toulouse
Grard
paris
Pour obtenir seulement la liste des clients qui habitent Paris, il faut effectuer la requte suivante :
SELECT *
FROM client
WHERE ville = 'paris'
Rsultat :
id
nom
nbr_commande
nbr_commande
Paul
paris
Grard
paris
Attention : dans notre cas tout est en minuscule donc il ny a pas eu de problme. Cependant, si un
table est sensible la casse, il faut faire attention aux majuscules et minuscules.
Oprateurs de comparaisons
Il existe plusieurs oprateurs de comparaisons. La liste ci-jointe prsente quelques uns des
oprateurs les plus couramment utiliss.
11/89
sql.sh
Oprateur
Description
gale
<>
Pasgale
!=
Pasgale
>
Suprieur
<
Infrieur
>=
Suprieurougale
<=
Infrieurougale
IN
Listedeplusieursvaleurspossibles
BETWEEN
Valeurcomprisedansunintervalledonne(utilepourlesnombresoudates)
LIKE
Rechercheenspcifiantledbut,milieuoufind'unmot.
ISNULL
Valeurestnulle
ISNOTNULL
Valeurn'estpasnulle
Attention : il y a quelques oprateurs qui nexiste pas dans des vieilles versions de systme de
gestion de bases de donnes (SGBD). De plus, il y a de nouveaux oprateurs non indiqus ici qui
sont disponibles avec certains SGBD. Nhsitez pas consulter la documentation de MySQL,
PostgreSQL ou autre pour voir ce quil vous est possible de faire.
12/89
sql.sh
Ces oprateurs peuvent tre combins linfini et mlangs. Lexemple ci-dessous filtre les rsultats
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 parenthses lorsque cest ncessaire. Cela permet dviter les
erreurs car et a amliore la lecture dune requte par un humain.
Exemple de donnes
Pour illustrer les prochaines commandes, nous allons considrer la table produit suivante :
id
nom
categorie
stock
prix
ordinateur
informatique
950
clavier
informatique
32
35
souris
informatique
16
30
crayon
fourniture
147
Oprateur AND
Loprateur AND permet de joindre plusieurs conditions dans une requte. En gardant la mme table
que prcdemment, pour filtrer uniquement les produits informatique qui sont presque en rupture de
stock (moins de 20 produits disponible) il faut excuter la requte suivante :
SELECT * FROM produit
WHERE categorie = 'informatique' AND stock < 20
13/89
sql.sh
Rsultat :
id
nom
categorie
stock
prix
ordinateur
informatique
950
souris
informatique
16
30
Oprateur OR
Pour filtrer les donnes pour avoir uniquement les donnes sur les produits ordinateur ou
clavier il faut effectuer la recherche suivante :
SELECT * FROM produit
WHERE nom = 'ordinateur' OR nom = 'clavier'
Rsultats :
id
nom
categorie
stock
prix
ordinateur
informatique
950
clavier
informatique
32
35
Combiner AND et OR
Il ne faut pas oublier que les oprateurs peuvent tre combins pour effectuer de puissantes
recherche. Il est possible de filtrer les produits informatique avec un stock infrieur 20 et les
produits fourniture avec un stock infrieur 200 avec la recherche suivante :
SELECT * FROM produit
WHERE ( categorie = 'informatique' AND stock < 20 )
OR ( categorie = 'fourniture' AND stock < 200 )
Rsultats :
id
nom
categorie
stock
prix
ordinateur
informatique
950
clavier
informatique
32
35
crayon
fourniture
147
14/89
sql.sh
SQL IN
Loprateur logique IN dans SQL sutilise avec la commande WHERE pour vrifier si une colonne est
gale une des valeurs comprise dans set de valeurs dtermins. Cest une mthode simple pour
vrifier 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 loprateur 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 dutiliser la syntaxe suivante :
SELECT nom_colonne
FROM table
WHERE nom_colonne IN ( valeur1, valeur2, valeur3, ... )
A savoir : entre les parenthses il ny a pas de limite du nombre darguments. Il est possible
dajouter encore dautres valeurs.
Cette syntaxe peut tre associe loprateur NOT pour recherche toutes les lignes qui ne sont pas
gales lune des valeurs stipules.
Simplicit de loprateur IN
La syntaxe utilise avec loprateur est plus simple que dutiliser une succession doprateur OR.
Pour le montrer concrtement avec un exemple, voici 2 requtes qui retournerons les mmes
rsultats, lune utilise loprateur IN, tandis que lautre utilise plusieurs OR.
Exemple
Imaginons une table adresse qui contient une liste dadresse associe des utilisateurs dune
application.
id
id_utilisateur
addr_rue
addr_code_postal
addr_ville
23
35RueMadeleinePelletier
25250
Bournois
43
21RueduMoulinCollet
75006
Paris
15/89
sql.sh
65
28AvenuedeCornouaille
27220
MousseauxNeuville
67
41RueMarceldelaProvot
76430
Graimbouville
68
18AvenuedeNavarre
75009
Paris
Si lont souhaite obtenir les enregistrements des adresses de Paris et de Graimbouville, il est
possible dutiliser la requte suivante :
SELECT *
FROM adresse
WHERE addr_ville IN ( 'Paris', 'Graimbouville' )
Rsultats :
id
id_utilisateur
addr_rue
addr_code_postal
addr_ville
43
21RueduMoulinCollet
75006
Paris
67
41RueMarceldelaProvot
76430
Graimbouville
68
18AvenuedeNavarre
75009
Paris
16/89
sql.sh
SQL BETWEEN
Loprateur BETWEEN est utilis dans une requte SQL pour slectionner un intervalle de donnes
dans une requte utilisant WHERE. Lintervalle peut tre constitu de chanes de caractres, de
nombres ou de dates. Lexemple le plus concret consiste par exemple rcuprer uniquement les
enregistrements entre 2 dates dfinies.
Syntaxe
Lutilisation de la commande BETWEEN seffectue de la manire suivante :
SELECT *
FROM table
WHERE nom_colonne BETWEEN 'valeur1' AND 'valeur2'
La requte suivante retournera toutes les lignes dont la valeur de la colonne nom_colonne sera
comprise entre valeur1 et valeur2.
nom
date_inscription
Maurice
20120302
Simon
20120305
Chlo
20120414
Marie
20120415
Clmentine
20120426
Si lont souhaite obtenir les membres qui se sont inscrit entre le 1 avril 2012 et le 20 avril 2012 il est
possible deffectuer la requte suivante :
SELECT *
FROM utilisateur
WHERE date_inscription BETWEEN 2012-04-01 AND 2012-04-20
Rsultat :
id
nom
date_inscription
Chlo
20120414
Marie
20120415
17/89
sql.sh
SELECT *
FROM utilisateur
WHERE id NOT BETWEEN 4 AND 10
Rsultat :
id
nom
date_inscription
Maurice
20120302
Simon
20120305
Chlo
20120414
Bon savoir
Certaines vieilles versions de systmes de gestion de bases de donnes ne prennent pas en compte
la commande BETWEEN. Mais si vous utilisez une version rcente de MySQL ou PostgreSQL, cela
ne cause aucun problme.
Lautre lment important savoir cest que toutes les bases de donnes ne grent pas loprateur
BETWEEN de la mme manire. Certains systmes vont inclurent les valeurs qui dfinissent
lintervalle tandis que dautres systmes considrent ces valeurs sont exclues. Il est important de
consulter la documentation officielle de la base de donnes que vous utilisez pour avoir une rponse
exacte ce sujet.
18/89
sql.sh
SQL LIKE
Loprateur LIKE est utilis dans la clause WHERE des requtes SQL. Ce mot-cl permet deffectuer
une recherche sur un modle particulier. Il est par exemple possible de rechercher les
enregistrements dont la valeur dune colonne commence par telle ou telle lettre. Les modles de
recherches sont multiple.
Syntaxe
La syntaxe utiliser pour utiliser loprateur LIKE est la suivante :
SELECT *
FROM table
WHERE colonne LIKE modele
Dans cet exemple le modle na pas t dfini, mais il ressemble trs gnralement lun des
exemples suivants :
LIKE %a : le caractre % est un caractre joker qui remplace tous les autres caractres.
Ainsi, ce modle permet de rechercher toutes les chaines de caractre qui se termine par un
a .
LIKE a% : ce modle permet de rechercher toutes les lignes de colonne qui commence
par un a .
LIKE %a% : ce modle est utilis pour rechercher tous les enregistrement qui utilisent le
caractre a .
LIKE pa%on : ce modle permet de rechercher les chaines qui commence par pa et qui
se terminent par on , comme pantalon ou pardon .
LIKE a_c : peu utilis, le caractre _ (underscore) peut tre remplac par nimporte quel
caractre, mais un seul caractre uniquement (alors que le symbole pourcentage % peut
tre remplac par un nombre incalculable de caractres . Ainsi, ce modle permet de
retourner les lignes aac , abc ou mme azc .
Exemple
Imaginons une table client qui contient les enregistrement dutilisateurs :
id
nom
ville
1
Lon
Lyon
Odette
Nice
Vivien
Nantes
Etienne
Lille
19/89
sql.sh
nom
ville
Odette
Nice
Vivien
Nantes
Rsultat :
id
nom
ville
Odette
Nice
Etienne
Lille
20/89
sql.sh
Syntaxe
Pour filtrer les rsultats o les champs dune colonne sont NULL il convient dutiliser la syntaxe
suivante :
SELECT *
FROM `table`
WHERE nom_colonne IS NULL
A linverse, pour filtrer les rsultats et obtenir uniquement les enregistrements qui ne sont pas null, il
convient dutiliser la syntaxe suivante :
SELECT *
FROM `table`
WHERE nom_colonne IS NOT NULL
A savoir : loprateur IS retourne en ralit un boolen, cest dire une valeur TRUE si la condition
est vrai ou FALSE si la condition nest pas respecte. Cet oprateur est souvent utilis avec la
condition WHERE mais peut aussi trouv son utilit lorsquune sous-requte est utilise.
Exemple
Imaginons une application qui possde une table contenant les utilisateurs. Cette table possde 2
colonnes pour associer les adresses de livraison et de facturation un utilisateur (grce une cl
trangre). Si cet utilisateur na pas dadresse 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
Grgoire
20130212
12
12
24
Sarah
20130217
NULL
NULL
25
Anne
20130221
13
14
26
Frdrique
20130302
NULL
NULL
21/89
sql.sh
SELECT *
FROM `utilisateur`
WHERE `fk_adresse_livraison_id` IS NULL
Rsultat :
id
nom
date_inscription
fk_adresse_livraison_id
fk_adresse_facturation_id
24
Sarah
20130217
NULL
NULL
26
Frdrique
20130302
NULL
NULL
Les enregistrements retourns montrent bien que seul les utilisateurs ayant la valeur NULL pour le
champ de ladresse de livraison.
Rsultat :
id
nom
date_inscription
fk_adresse_livraison_id
fk_adresse_facturation_id
23
Grgoire
20130212
12
12
25
Anne
20130221
13
14
Les lignes retourns sont exclusivement celles qui nont pas une valeur NULL pour le champ de
ladresse de livraison.
22/89
sql.sh
SQL GROUP BY
La commande GROUP BY est utilise en SQL pour grouper plusieurs rsultats et utiliser une fonction
de totaux sur un groupe de rsultat. Sur une table qui contient toutes les ventes dun magasin, il est
par exemple possible de liste regrouper les ventes par clients identiques et dobtenir le cot total des
achats pour chaque client.
A noter : cette commande doit toujours sutiliser aprs la commande WHERE et avant la commande
HAVING.
Exemple dutilisation
Prenons en considration une table achat qui rsume les ventes dune boutique :
id
client
tarif
date
Pierre
102
2012-10-23
Simon
47
2012-10-27
Marie
18
2012-11-05
Marie
20
2012-11-14
Pierre
160
2012-12-03
Ce tableau contient une colonne qui sert didentifiant pour chaque ligne, une autre qui contient le
nom du client, le cot de la vente et la date dachat.
Pour obtenir le cot total de chaque client en regroupant les commandes des mmes clients, il faut
utiliser la requte suivante :
SELECT client, SUM(tarif)
FROM achat
GROUP BY client
La fonction SUM() permet dadditionner la valeur de chaque tarif pour un mme client. Le rsultat
sera donc le suivant :
client
SUM(tarif)
Pierre
262
Simon
47
Marie
38
23/89
sql.sh
La manire simple de comprendre le GROUP BY cest tout simplement dassimiler quil va viter de
prsenter plusieurs fois les mmes lignes. Cest une mthode pour viter les doublons.
Juste titre informatif, voici ce quon obtient de la requte sans utiliser GROUP BY.
Requte :
SELECT client, SUM(tarif)
FROM achat
Rsultat :
client
SUM(tarif)
Pierre
262
Simon
47
Marie
38
Marie
38
Pierre
262
24/89
sql.sh
SQL HAVING
La condition HAVING en SQL est presque similaire WHERE la seule diffrence que HAVING
permet de filtrer en utilisant des fonctions telles que SUM(), COUNT(), AVG(), MIN() ou MAX().
Syntaxe
Lutilisation de HAVING sutilise de la manire suivante :
SELECT colonne1, SUM(colonne2)
FROM nom_table
GROUP BY colonne1
HAVING fonction(colonne2) operateur valeur
Cela permet donc de SLECTIONNER 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
respecte.
Important : HAVING est trs souvent utilis en mme 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 diffrents
clients avec le cot du panier pour chaque achat.
id
client
tarif
date_achat
Pierre
102
20121023
Simon
47
20121027
Marie
18
20121105
Marie
20
20121114
Pierre
160
20121203
Si dans cette table on souhaite rcuprer la liste des clients qui ont command plus de 40, toute
commandes confondu alors il est possible dutiliser la requte suivante :
SELECT client, SUM(tarif)
FROM achat
GROUP BY client
HAVING SUM(tarif) > 40
Rsultat :
client
SUM(tarif)
Pierre
162
Simon
47
25/89
sql.sh
La cliente Marie a cumule 38 dachat (un achat de 18 et un autre de 20) ce qui est infrieur
la limite de 40 impose par HAVING. En consquent cette ligne nest pas affiche dans le rsultat.
26/89
sql.sh
SQL ORDER BY
La commande ORDER BY permet de trier les lignes dans un rsultat dune requte SQL. Il est
possible de trier les donnes sur une ou plusieurs colonnes, par ordre ascendant ou descendant.
Syntaxe
Une requte o lont souhaite filtrer lordre des rsultats utilise la commande ORDER BY de la sorte :
SELECT colonne1, colonne2
FROM table
ORDER BY colonne1
Par dfaut les rsultats sont classs par ordre ascendant, toutefois il est possible dinverser lordre
en utilisant le suffixe DESC aprs le nom de la colonne. Par ailleurs, il est possible de trier sur
plusieurs colonnes en les sparant par une virgule. Une requte plus labor ressemblerais alors
cela :
SELECT colonne1, colonne2, colonne3
FROM table
ORDER BY colonne1 DESC, colonne2 ASC
A noter : il nest pas oblig dutiliser le suffixe ASC sachant que les rsultats sont toujours class
par ordre ascendant par dfaut. Toutefois, cest plus pratique pour mieux sy retrouver, surtout si on a
oubli lordre par dfaut.
Exemple
Pour lensemble de nos exemple, nous allons prendre un base utilisateur de test, qui contient les
donnes suivantes :
id
nom
prenom
date_inscription
tarif_total
Durand
Maurice
20120205
145
Dupond
Fabrice
20120207
65
Durand
Fabienne
20120213
90
Dubois
Chlo
20120216
98
Dubois
Simon
20120223
27
Pour rcuprer la liste de ces utilisateurs par ordre alphabtique du nom de famille, il est possible
dutiliser la requte suivante :
SELECT *
FROM utilisateur
ORDER BY nom
Rsultat :
27/89
sql.sh
id
nom
prenom
date_inscription
tarif_total
Dubois
Chlo
20120216
98
Dubois
Simon
20120223
27
Dupond
Fabrice
20120207
65
Durand
Maurice
20120205
145
Durand
Fabienne
20120213
90
En utilisant deux mthodes de tri, il est possible de retourner les utilisateurs par ordre alphabtique
ET pour ceux qui ont le mme nom de famille, les trier par ordre dcroissant dinscription. La requte
serait alors la suivante :
SELECT *
FROM utilisateur
ORDER BY nom, date_inscription DESC
Rsultat :
id
nom
prenom
date_inscription
tarif_total
Dubois
Simon
20120223
27
Dubois
Chlo
20120216
98
Dupond
Fabrice
20120207
65
Durand
Fabienne
20120213
90
Durand
Maurice
20120205
145
28/89
sql.sh
SQL LIMIT
La clause LIMIT est utiliser dans une requte SQL pour spcifier le nombre maximum de rsultats
que lont souhaite obtenir. Cette clause est souvent associ un OFFSET, cest--dire effectuer un
dcalage sur le jeu de rsultat. Ces 2 clauses permettent par exemple deffectuer des systme de
pagination (exemple : rcuprer les 10 articles de la page 4).
ATTENTION : selon le systme de gestion de base de donnes, la syntaxe ne sera pas pareil. Ce
tutoriel va donc prsenter la syntaxe pour MySQL et pour PostgreSQL.
Syntaxe simple
La syntaxe commune aux principales systme de gestion de bases de donnes est la suivante :
SELECT *
FROM table
LIMIT 10
Cette requte permet de rcuprer seulement les 10 premiers rsultats dune table. Bien entendu, si
la table contient moins de 10 rsultats, alors la requte retournera toutes les lignes.
Bon savoir : la bonne pratique lorsque lont utilise LIMIT consiste utiliser galement la clause
ORDER BY pour sassurer que quoi quil en soit ce sont toujours les bonnes donnes qui sont
prsentes. En effet, si le systme de tri est non spcifi, alors il est en principe inconnu et les
rsultats peuvent tre imprvisible.
Cette requte permet de rcuprer les rsultats 6 15 (car lOFFSET commence toujours 0). A titre
dexemple, pour rcuprer les rsultats 16 25 il faudrait donc utiliser: LIMIT 10 OFFSET 15
A noter : Utiliser OFFSET 0 reviens au mme que domettre lOFFSET.
Cette requte retourne les enregistrements 6 15 dune table. Le premier nombre est lOFFSET
tandis que le suivant est la limite.
29/89
sql.sh
Bon savoir : pour une bonne compatibilit, MySQL accepte galement la syntaxe LIMIT nombre
OFFSET nombre. En consquent, dans la conception dune application utilisant MySQL il est
prfrable dutiliser cette syntaxe car cest potentiellement plus facile de migrer vers un autre
systme de gestion de base de donnes sans avoir r-crire toutes les requtes.
Performance
Ce dernier chapitre est destin un public averti. Il nest pas ncessaire de le comprendre
entirement, mais simplement davoir compris les grandes lignes.
Certains dveloppeur pensent tort que lutilisation de LIMIT permet de rduire le temps dexcution
dune requte. Or, le temps dexcution est sensiblement le mme car la requte va permettre de
rcuprer toutes les lignes (donc temps dexcution identique) PUIS seulement les rsultats dfinit
par LIMIT et OFFSET seront retourns. Au mieux, utiliser LIMIT permet de rduire le temps
daffichage car il y a moins de lignes afficher.
30/89
sql.sh
SQL CASE
Dans le langage SQL, la commande CASE WHEN permet dutiliser des conditions de type
si / sinon (cf. if / else) similaire un langage de programmation pour retourner un rsultat
disponible entre plusieurs possibilits. Le CASE peut tre utilis dans nimporte quelle instruction ou
clause, telle que SELECT, UPDATE, DELETE, WHERE, ORDER BY ou HAVING.
Syntaxe
Lutilisation du CASE est possible de 2 manires diffrentes :
Dans cet exemple les valeurs contenus dans la colonne a sont compar 1, 2 ou 3. Si la
condition est vrai, alors la valeur situe aprs le THEN sera retourne.
A noter : la condition ELSE est facultative et sert de ramasse-miette. Si les conditions prcdentes
ne sont pas respectes alors ce sera la valeur du ELSE qui sera retourne par dfaut.
Dans cet exemple les colonnes a , b et c peuvent contenir des valeurs numriques.
Lorsquelles sont respectes, les conditions boolennes permettent de rentrer dans lune ou lautre
des conditions.
Il est possible de reproduire le premier exemple prsent sur cette page en utilisant la syntaxe
suivante :
CASE
WHEN a=1 THEN 'un'
31/89
sql.sh
Exemple
Pour prsenter le CASE dans le langage SQL il est possible dimaginer une base de donnes
utilises 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 achete et une colonne consacre
une marge fictive sur certains produits.
Table achat :
id
nom
surcharge
prix_unitaire
quantite
ProduitA
1.3
ProduitB
1.5
ProduitC
0.75
ProduitD
15
Rsultat :
id
nom
surcharge
prix_unitaire
quantite
CASE
ProduitA
1.3
Prixsuprieurlanormale
ProduitB
1.5
Prixsuprieurlanormale
ProduitC
0.75
Prixinfrieurlanormale
ProduitD
15
Prixordinaire
Ce rsultat montre quil est possible dafficher facilement des messages personnaliss selon des
conditions simples.
32/89
sql.sh
Rsultat :
id
nom
surcharge
prix_unitaire
quantite
CASE
ProduitA
1.3
12
ProduitB
1.5
16
ProduitC
0.75
3.5
ProduitD
15
15
Rsultat :
33/89
sql.sh
id
nom
surcharge
prix_unitaire
quantite
CASE
ProduitA
1.3
Offrede8%pourleprochainachat
ProduitB
1.5
Offrede6%pourleprochainachat
ProduitC
0.75
Offrede10%pourleprochainachat
ProduitD
15
Offrede6%pourleprochainachat
Astuce : la condition ELSE peut parfois tre utilise pour grer les erreurs.
34/89
sql.sh
SQL UNION
La commande UNION de SQL permet de mettre bout--bout les rsultats de plusieurs requtes
utilisant elles-mme la commande SELECT. Cest donc une commande qui permet de concatner les
rsultats de 2 requtes ou plus. Pour lutiliser il est ncessaire que chacune des requtes
concatner retournes le mme nombre de colonnes, avec les mmes types de donnes et dans le
mme ordre.
A savoir : par dfaut, les enregistrements exactement identiques ne seront pas rpts dans les
rsultats. Pour effectuer une union dans laquelle mme les lignes dupliques sont affiches il faut
plutt utiliser la commande UNION ALL.
Syntaxe
La syntaxe pour unir les rsultats de 2 tableaux sans afficher les doublons est la suivante :
SELECT * FROM table1
UNION
SELECT * FROM table2
Schma explicatif
Lunion de 2 ensembles A et B est un concept qui consiste obtenir tous les lments qui
correspondent la fois lensemble A ou lensemble B. Cela se rsume trs simplement par un
petit schma o la zone en bleu correspond la zone que lont souhaite obtenir (dans notre cas :
tous les lments).
Union de 2 ensembles
Exemple
Imaginons une entreprise qui possde plusieurs magasins et dans chacun de ces magasins il y a
une table qui liste les clients.
La table du magasin n1 sappelle magasin1_client et contient les donnes suivantes :
35/89
sql.sh
prenom
nom
ville
date_naissance
total_achat
Lon
Dupuis
Paris
19830306
135
Marie
Bernard
Paris
19930703
75
Sophie
Dupond
Marseille
19860222
27
Marcel
Martin
Paris
19761124
39
nom
ville
date_naissance
total_achat
Marion
Leroy
Lyon
19821027
285
Paul
Moreau
Lyon
19760419
133
Marie
Bernard
Paris
19930703
75
Marcel
Martin
Paris
19761124
39
Sachant que certains clients sont prsents dans les 2 tables, pour viter de retourner plusieurs fois
les mmes enregistrement, il convient dutiliser la requte UNION. La requte SQL est alors la
suivante :
SELECT * FROM magasin1_client
UNION
SELECT * FROM magasin2_client
Rsultat :
prenom
nom
ville
date_naissance
total_achat
Lon
Dupuis
Paris
19830306
135
Marie
Bernard
Paris
19930703
75
Sophie
Dupond
Marseille
19860222
27
Marcel
Martin
Paris
19761124
39
Marion
Leroy
Lyon
19821027
285
Paul
Moreau
Lyon
19760419
133
Le rsultat de cette requte montre bien que les enregistrements des 2 requtes sont mis bout-bout mais sans inclure plusieurs fois les mmes lignes.
36/89
sql.sh
Syntaxe
La syntaxe de la requte SQL pour unir les rsultats des 2 tables est la suivante :
SELECT * FROM table1
UNION ALL
SELECT * FROM table2
Exemple
Imaginons une entreprise qui possde des bases de donnes dans chacun de ces magasins. Sur
ces bases de donnes il y a une table de la liste des clients avec quelques informations et le total
des achats dans lentreprise.
La table magasin1_client correspond au premier magasin :
prenom
nom
ville
date_naissance
total_achat
Lon
Dupuis
Paris
19830306
135
Marie
Bernard
Paris
19930703
75
Sophie
Dupond
Marseille
19860222
27
Marcel
Martin
Paris
19761124
39
nom
ville
date_naissance
total_achat
Marion
Leroy
Lyon
19821027
285
Paul
Moreau
Lyon
19760419
133
Marie
Bernard
Paris
19930703
75
Marcel
Martin
Paris
19761124
39
Pour concatner les tous les enregistrements de ces tables, il est possible deffectuer une seule
requte utilisant la commande UNION ALL, comme lexemple ci-dessous :
37/89
sql.sh
Rsultat :
prenom
nom
ville
date_naissance
total_achat
Lon
Dupuis
Paris
19830306
135
Marie
Bernard
Paris
19930703
75
Sophie
Dupond
Marseille
19860222
27
Marcel
Martin
Paris
19761124
39
Marion
Leroy
Lyon
19821027
285
Paul
Moreau
Lyon
19760419
133
Marie
Bernard
Paris
19930703
75
Marcel
Martin
Paris
19761124
39
Le rsultat de cette requte montre quil y a autant denregistrement que dans les 2 tables runis. A
savoir, il y a quelques clients qui taient prsents dans les 2 tables dorigines en consquent ils sont
prsent 2 fois dans le rsultat de cette requte SQL.
38/89
sql.sh
SQL INTERSECT
La commande SQL INTERSECT permet dobtenir lintersection des rsultats de 2 requtes. Cette
commande permet donc de rcuprer les enregistrements communs 2 requtes. Cela peut savrer
utile lorsquil faut trouver sil y a des donnes similaires sur 2 tables distinctes.
A savoir : pour lutiliser convenablement il faut que les 2 requtes retourne le mme nombre de
colonnes, avec les mmes types et dans le mme ordre.
Syntaxe
La syntaxe adopter pour utiliser cette commande est la suivante :
SELECT * FROM table1
INTERSECT
SELECT * FROM table2
Dans cet exemple, il faut que les 2 tables soient similaires (mmes colonnes, mmes types et mme
ordre). Le rsultat correspondra aux enregistrements qui existent dans table1 et dans table2.
Schma explicatif
Lintersection de 2 ensembles A et B correspond aux lments qui sont prsent dans A et dans B, et
seulement ceux-l. Cela peut tre reprsent par un schma explicatif simple ou lintersection de A et
B correspond la zone en bleu.
Intersection de 2 ensembles
Exemple
Prenons lexemple de 2 magasins qui appartiennent au mme groupe. Chaque magasin possde sa
table de clients.
La table du magasin n1 est magasin1_client :
prenom
nom
ville
date_naissance
total_achat
Lon
Dupuis
Paris
19830306
135
Marie
Bernard
Paris
19930703
75
39/89
sql.sh
Sophie
Dupond
Marseille
19860222
27
Marcel
Martin
Paris
19761124
39
nom
ville
date_naissance
total_achat
Marion
Leroy
Lyon
19821027
285
Paul
Moreau
Lyon
19760419
133
Marie
Bernard
Paris
19930703
75
Marcel
Martin
Paris
19761124
39
Pour obtenir la liste des clients qui sont prsents de faon identiques dans ces 2 tables, il est
possible dutiliser la commande INTERSECT de la faon suivante :
SELECT * FROM magasin1_client
INTERSECT
SELECT * FROM magasin2_client
Rsultat :
prenom
nom
ville
date_naissance
total_achat
Marie
Bernard
Paris
19930703
75
Marcel
Martin
Paris
19761124
39
Le rsultat prsente 2 enregistrements, il sagit des clients qui sont la fois dans la table
magasin1_client et dans la table magasin2_client . Sur certains systmes une telle requte
permet de dceler des erreurs et denregistrer seulement un seul endroit la mme information.
40/89
sql.sh
Syntaxe
La syntaxe dune requte SQL est toute simple :
SELECT * FROM table1
EXCEPT
SELECT * FROM table2
Cette requte permet de lister les rsultats du table 1 sans inclure les enregistrements de la table 1
qui sont aussi dans la table 2.
Attention : les colonnes de la premire requte doivent tre similaires entre la premire et la
deuxime requte (mme nombre, mme type et mme ordre).
Schma explicatif
Cette commande permet de rcuprer les lments de lensemble A sans prendre en compte les
lments de A qui sont aussi prsent dans lensemble B. Dans le schma ci-dessous seule la zone
bleu sera retourne grce la commande EXCEPT (ou MINUS).
Exemple
Imaginons un systme informatique dune entreprise. Ce systme contient 2 tables contenant des
41/89
sql.sh
listes de clients :
Une table clients_inscrits qui contient les prnoms, noms et date dinscription 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 slectionner les utilisateurs pour envoyer un email dinformation.
Les utilisateurs de la deuxime table ne devront pas apparatre dans les rsultats.
Table clients_inscrits :
id
prenom
nom
date_inscription
Lionel
Martineau
20121114
Paul
Cornu
20121215
Sarah
Schmitt
20121217
Sabine
Lenoir
20121218
Table clients_refus_email :
id
prenom
nom
date_inscription
Paul
Cornu
20130127
Manuel
Guillot
20130127
Sabine
Lenoir
20130129
Natalie
Petitjean
20130203
Pour pouvoir slectionner uniquement le prnom et le nom des utilisateurs qui accepte de recevoir
des emails informatifs. La requte SQL utiliser est la suivante :
SELECT prenom, nom FROM clients_inscrits
EXCEPT
SELECT prenom, nom FROM clients_refus_email
Rsultats :
prenom
nom
Lionel
Martineau
Sarah
Schmitt
Ce tableau de rsultats montre bien les utilisateurs qui sont dans inscrits et qui ne sont pas prsent
dans le deuxime tableau. Par ailleurs, les rsultats du deuxime tableau ne sont pas prsent sur ce
rsultat final.
42/89
sql.sh
Insrer une ligne en indiquant les informations pour chaque colonne existante (en respectant
lordre)
Insrer une ligne en spcifiant les colonnes que vous souhaiter complter. Il est possible
dinsrer une ligne en renseigner seulement une partie des colonnes
Obliger de remplir toutes les donnes, tout en respectant lordre des colonnes
Il ny a pas le nom de colonne, donc les fautes de frappe sont limites. Par ailleurs, les
colonnes peuvent tre renommes sans avoir changer la requte
Lordre des colonnes doit rest identique sinon certaines valeurs prennent le risque dtre
complte dans la mauvaise colonne
A noter : il est possible de ne pas renseigner toutes les colonnes. De plus, lordre des colonnes nest
pas important.
43/89
sql.sh
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 numrique tel que INT ou BIGINT il ny a
pas besoin dutiliser de guillemet, il suffit juste dindiquer le nombre.
Un tel exemple sur une table vide va crer le tableau suivant :
id
prenom
nom
ville
age
Rbecca
Armand
SaintDidierdesBois
24
Aime
Hebert
MarignyleChtel
36
Marielle
Ribeiro
Maillres
27
Hilaire
Savary
ConieMolitard
58
44/89
sql.sh
Syntaxe
Cette commande seffectue au sein de la requte INSERT INTO avec la syntaxe suivante :
INSERT INTO table (a, b, c)
VALUES (1, 20, 68)
ON DUPLICATE KEY UPDATE a=a+1
Exemple
Imaginons une application qui laisse les utilisateurs voter pour les produits quils prfrent. Le
systme de vote est trs 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_id
vote_count
vote_first_date
vote_last_date
46
2012042517:45:24
2013021609:47:02
39
2012042816:54:44
2013021421:04:35
49
2012042519:11:09
2013010620:32:57
45/89
sql.sh
Pour nutiliser quune seule ligne qui permet dajouter des votes dans cette table, sans se proccuper
de savoir sil faut faire un INSERT ou un UPDATE, il est possible dutiliser la requte 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()
Dans cette requte la date et lheure est gnre automatiquement avec la fonction NOW().
Rsultat aprs la premire excution de la requte :
id
produit_id
vote_count
vote_first_date
vote_last_date
46
2012042517:45:24
2013021609:47:02
39
2012042816:54:44
2013021421:04:35
49
2012042519:11:09
2013010620:32:57
55
2013040215:06:34
2013040215:06:34
Ce rsultat montre bien lajout dune ligne en fin de table, donc la requte a t utilis sous la forme
dun INSERT. Aprs une deuxime excution de cette mme requte le lendemain, les donnes
seront celles-ci:
id
produit_id
vote_count
vote_first_date
vote_last_date
46
2012042517:45:24
2013021609:47:02
39
2012042816:54:44
2013021421:04:35
49
2012042519:11:09
2013010620:32:57
55
2013040215:06:34
2013040308:14:57
Ces rsultats montre bien quil y a eu un vote supplmentaire et que la date du dernier vote a t mis
jour.
Cette requte insert les donnes et ne produit aucune erreur si lenregistrement existait dj dans la
table.
A savoir : thoriquement il aurait t possible dutiliser INSERT IGNORE mais malheureusement cela
46/89
sql.sh
empche de retourner des erreurs telles que des erreurs de conversions de donnes.
Compatibilit
Pour le moment cette fonctionnalit nest possible quavec MySQL depuis la version 4.1 (date de
2003). Les autres Systmes de Gestion de Bases de Donnes (SGBD) nintgrent pas cette
fonctionnalit. Pour simuler cette fonctionnalit il y a quelques alternatives :
PostgreSQL : il y a une astuce en utilisant une fonction. Lastuce est explique dans la
documentation officielle : fonction INSERT/UPDATE.
Oracle : il est possible dutiliser la commande MERGE pour effectuer la mme chose.
SQL Server : il est possible dutiliser une procdure.
47/89
sql.sh
SQL UPDATE
La commande UPDATE permet deffectuer des modifications sur des lignes existantes. Trs souvent
cette commande est utilise avec WHERE pour spcifier sur quelles lignes doivent porter la ou les
modifications.
Syntaxe
La syntaxe basique dune requte utilisant UPDATE est la suivante :
UPDATE table
SET nom_colonne_1 = 'nouvelle valeur'
WHERE condition
Cette syntaxe permet dattribuer une nouvelle valeur la colonne nom_colonne_1 pour les lignes qui
respectent la condition stipul avec WHERE. Il est aussi possible dattribuer la mme valeur la
colonne nom_colonne_1 pour toutes les lignes dune table si la condition WHERE ntait pas utilise.
A noter, pour spcifier en une seule fois plusieurs modification, il faut sparer 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
Exemple
id
nom
rue
ville
code_postal
pays
Chantal
12AvenueduPetitTrianon
Puteaux
92800
France
Pierre
18Ruedel'Allier
Ponthion
51300
France
Romain
3CheminduChiron
Trvrien
35190
France
Rsultat :
id nom
rue
ville
code_postal
pays
Chantal
12AvenueduPetitTrianon
Puteaux
92800
France
Pierre
49RueAmeline
SaintEustachelaFort
76210
France
Romain
3CheminduChiron
Trvrien
35190
France
48/89
sql.sh
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 slectionner les lignes concernes qui seront
supprimes.
Attention : Avant dessayer de supprimer des lignes, il est recommand deffectuer une sauvegarde
de la base de donnes, ou tout du moins de la table concerne par la suppression. Ainsi, sil y a une
mauvaise manipulation il est toujours possible de restaurer les donnes.
Syntaxe
La syntaxe pour supprimer des lignes est la suivante :
DELETE FROM table
WHERE condition
Attention : sil ny a pas de condition WHERE alors toutes les lignes seront supprimes et la table
sera alors vide.
Exemple
Imaginons une table utilisateur qui contient des informations sur les utilisateurs dune application.
id
nom
prenom
date_inscription
1
Bazin
Daniel
20120213
Favre
Constantin
20120403
Clerc
Guillaume
20120412
Ricard
Rosemonde
20120624
Martin
Natalie
20120702
Si lont souhaite supprimer les utilisateurs qui se sont inscrit avant le 10/04/2012, il va falloir
effectuer la requte suivante :
DELETE FROM utilisateur
WHERE date_inscription < '2012-04-10'
nom
prenom
date_inscription
Clerc
Guillaume
20120412
Ricard
Rosemonde
20120624
Martin
Natalie
20120702
Il ne faut pas oublier quil est possible dutiliser dautres conditions pour slectionner les lignes
supprimer.
49/89
sql.sh
SQL MERGE
Dans le langage SQL, la commande MERGE permet dinsrer ou de mettre jour des donnes dans
une table. Cette commande permet dviter deffectuer plusieurs requtes pour savoir si une donne
est dj dans la base de donnes et ainsi adapter lutilisation dune requte pour ajouter ou une autre
pour modifier la donne existante. Cette commande peut aussi sappeler upsert .
Attention : bien que linstruction a t ajoute dans le standard SQL:2003, les diffrentes SGBD
nutilisent pas toutes les mmes mthodes pour effectuer un upsert.
Syntaxe
La syntaxe standard pour effectuer un merge consiste utiliser une requte SQL semblable celle
ci-dessous :
MERGE INTO table1
USING table_reference
ON (conditions)
WHEN MATCHED THEN
UPDATE SET table1.colonne1 = valeur1, table1.colonne2 = valeur2
DELETE WHERE conditions2
WHEN NOT MATCHED THEN
INSERT (colonnes1, colonne3)
VALUES (valeur1, valeur3)
Compatibilit
Les systmes de gestion de bases de donnes peuvent implmenter cette fonctionnalit soit de
faon standard, en utilisant une commande synonyme ou en utilisant une syntaxe non standard.
50/89
sql.sh
Syntaxe
Cette instruction sutilise dans une requte SQL semblable celle-ci :
TRUNCATE TABLE `table`
Dans cet exemple, les donnes de la table table seront perdues une fois cette requte excute.
Exemple
Pour montrer un exemple concret de lutilisation de cette commande, nous pouvons imaginez un
systme informatique contenant la liste des fournitures dune entreprise. Ces donnes seraient tout
simplement stockes dans une table fourniture .
Table fourniture :
id
nom
date_ajout
Ordinateur
2013-04-05
Chaise
2013-04-14
Bureau
2013-07-18
Lampe
2013-09-27
Il est possible de supprimer toutes les donnes de cette table en utilisant la requte suivante :
TRUNCATE TABLE `fourniture`
Une fois la requte excute, la table ne contiendra plus aucun enregistrement. En dautres mots,
toutes les lignes du tableau prsent ci-dessus auront t supprimes.
51/89
sql.sh
Syntaxe
Pour crer une base de donnes qui sera appel ma_base il suffit dutiliser la requte suivante
qui est trs simple :
CREATE DATABASE ma_base
Loption IF NOT EXISTS permet juste de ne pas retourner derreur si une base du mme nom existe
dj. La base de donnes ne sera pas crase.
Options
Dans le standard SQL la commande CREATE DATABASE nexiste normalement pas. En consquent
il revient de vrifier la documentation des diffrents SGBD pour vrifier les syntaxes possibles pour
dfinir des options. Ces options permettent selon les cas, de dfinir les jeux de caractres, le
propritaire de la base ou mme les limites de connexion.
52/89
sql.sh
Syntaxe
Pour supprimer la base de donnes ma_base , la requte est la suivante :
DROP DATABASE ma_base
Attention : cela va supprimer toutes les tables et toutes les donnes de cette base. Si vous ntes
pas sr de ce que vous faites, nhsitez pas effectuer une sauvegarde de la base avant de
supprimer.
53/89
sql.sh
Syntaxe
La syntaxe gnrale pour crer 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 requte, 4 colonnes ont t dfinies. Le mot-cl type_donnees sera remplacer par
un mot-cl pour dfinir le type de donnes (INT, DATE, TEXT ). Pour chaque colonne, il est
galement possible de dfinir des options telles que (liste non-exhaustive) :
NOT NULL : empche denregistrer une valeur nulle pour une colonne.
DEFAULT : attribuer une valeur par dfaut si aucune donnes nest indique pour cette
colonne lors de lajout dune ligne dans la table.
PRIMARY KEY : indiquer si cette colonne est considre comme cl primaire pour un index.
Exemple
Imaginons que lont souhaite crer une table utilisateur, dans laquelle chaque ligne correspond un
utilisateur inscrit sur un site web. La requte pour crer 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),
code_postal VARCHAR(5),
nombre_achat INT
)
id : identifiant unique qui est utilis comme cl primaire et qui nest pas nulle
nom : nom de lutilisateur dans une colonne de type VARCHAR avec un maximum de 100
54/89
sql.sh
caractres au maximum
prenom : idem mais pour le prnom
email : adresse email enregistr sous 255 caractres au maximum
date_naissance : date de naissance enregistr au format AAAA-MM-JJ (exemple : 1973-1117)
pays : nom du pays de lutilisateur sous 255 caractres au maximum
ville : idem pour la ville
code_postal : 5 caractres du code postal
nombre_achat : nombre dachat de cet utilisateur sur le site
55/89
sql.sh
Syntaxe de base
Dune manire gnrale, la commande sutilise de la manire suivante :
ALTER TABLE nom_table
instruction
Le mot-cl instruction ici sert dsigner une commande supplmentaire, qui sera dtaille cidessous selon laction que lont souhaite effectuer : ajouter, supprimer ou modifier une colonne.
Exemple
Pour ajouter une colonne qui correspond une rue sur une table utilisateur, il est possible dutiliser la
requte suivante :
ALTER TABLE utilisateur
ADD adresse_rue VARCHAR(255)
sql.sh
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 donnes tel que INT, VARCHAR,
TEXT, DATE
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
Ici type_donnees peut correspondre par exemple INT, VARCHAR, TEXT, DATE
PostgreSQL
Pour PostgreSQL la syntaxe est plus simple et ressemble ceci (le type nest pas demand) :
ALTER TABLE nom_table
RENAME COLUMN colonne_ancien_nom TO colonne_nouveau_nom
57/89
sql.sh
Syntaxe
Pour supprimer une table nom_table il suffit simplement dutiliser la syntaxe suivante :
DROP TABLE nom_table
A savoir : sil y a une dpence avec une autre table, il est recommand de les supprimer avant de
supprimer la table. Cest le cas par exemple sil y a des cls trangres.
Intrts
Il arrive quune table soit cr temporairement pour stoquer des donnes qui nont pas vocation
tre r-utiliser. La suppression dune table non utilise est avantageux sur plusieurs aspects :
Exemple de requte
Imaginons quune base de donnes possde une table client_2009 qui ne sera plus jamais utilis
et qui existe dj dans un ancien backup. Pour supprimer cette table, il suffit deffectuer la requte
suivante :
DROP TABLE client_2009
58/89
sql.sh
Jointure SQL
Les jointures en SQL permettent dassocier plusieurs tables dans une mme requte. Cela permet
dexploiter la puissance des bases de donnes relationnelles pour obtenir des rsultats qui
combinent les donnes de plusieurs tables de manire efficace.
Exemple
En gnral, les jointures consistent associer des lignes de 2 tables en associant lgalit des
valeurs dune colonne dune premire table par rapport la valeur dune colonne dune seconde
table. Imaginons quune base de 2 donnes possde une table utilisateur et une autre table
adresse qui contient les adresses de ces utilisateurs. Avec une jointure, il est possible dobtenir les
donnes de lutilisateur et de son adresse en une seule requte.
On peut aussi imaginer quun site web possde une table pour les articles (titre, contenu, date de
publication ) et une autre pour les rdacteurs (nom, date dinscription, date de naissance ). Avec
une jointure il est possible deffectuer une seule recherche pour afficher un article et le nom du
rdacteur. Cela vite davoir afficher le nom du rdacteur dans la table article .
Il y a dautres cas de jointures, incluant des jointures sur la mme table ou des jointure dingalit.
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 mthodes pour associer 2 tables ensemble. Voici la liste des diffrentes techniques
qui sont utilises :
INNER JOIN : jointure interne pour retourner les enregistrements quand la condition est vrai
dans les 2 tables. Cest lune des jointures les plus communes.
CROSS JOIN : jointure croise permettant de faire le produit cartsien de 2 tables. En
dautres mots, permet de joindre chaque lignes dune table avec chaque lignes dune seconde
table. Attention, le nombre de rsultats est en gnral trs lev.
LEFT JOIN (ou LEFT OUTER JOIN) : jointure externe pour retourner tous les
enregistrements de la table de gauche (LEFT = gauche) mme si la condition nest pas vrifi
dans lautre table.
RIGHT JOIN (ou RIGHT OUTER JOIN) : jointure externe pour retourner tous les
enregistrements de la table de droite (RIGHT = droite) mme si la condition nest pas vrifi
dans lautre table.
FULL JOIN (ou FULL OUTER JOIN) : jointure externe pour retourner les rsultats quand la
condition est vrai dans au moins une des 2 tables.
SELF JOIN : permet deffectuer une jointure dune table avec elle-mme comme si ctait une
autre table.
NATURAL JOIN : jointure naturelle entre 2 tables sil y a au moins une colonne qui porte le
mme nom entre les 2 tables SQL
UNION JOIN : jointure dunion
59/89
sql.sh
Syntaxe
Pour utiliser ce type de jointure il convient dutiliser une requte SQL avec cette syntaxe :
SELECT *
FROM table1
INNER JOIN table2 ON table1.id = table2.fk_id
La syntaxe ci-dessus stipule quil faut slectionner les enregistrements des tables table1 et table2
lorsque les donnes de la colonne id de table1 est gal aux donnes de la colonne fk_id de
table2.
La jointure SQL peux aussi tre crite de la faon suivante :
SELECT *
FROM table1
INNER JOIN table2
WHERE table1.id = table2.fk_id
La syntaxe avec la condition WHERE est une manire alternative de faire la jointure mais qui
possde linconvnient dtre moins facile lire sil y a dj plusieurs conditions dans le WHERE.
Exemple
Imaginons une application qui possde une table utilisateur ainsi quune table commande qui
contient toutes les commandes effectues par les utilisateurs.
Table utilisateur :
id
prenom
nom
ville
Aime
Marechal
aime.marechal@example.com
Paris
Esme
Lefort
esmee.lefort@example.com
Lyon
Marine
Prevost
m.prevost@example.com
Lille
Luc
Rolland
lucrolland@example.com
Marseille
Table commande :
60/89
sql.sh
utilisateur_id
date_achat
num_facture
prix_total
20130123
A00103
203.14
20130214
A00104
124.00
20130217
A00105
149.45
20130221
A00106
235.35
20130302
A00107
47.58
Pour afficher toutes les commandes associes aux utilisateurs, il est possible dutiliser la requte
suivante :
SELECT id, prenom, nom, date_achat, num_facture, prix_total
FROM utilisateur
INNER JOIN commande ON utilisateur.id = commande.utilisateur_id
Rsultats :
id
prenom
nom
date_achat
num_facture
prix_total
Aime
Marechal
20130123
A00103
203.14
Aime
Marechal
20130214
A00104
124.00
Esme
Lefort
20130217
A00105
149.45
Esme
Lefort
20130221
A00106
235.35
Le rsultat de la requte montre parfaite la jointure entre les 2 tables. Les utilisateurs 3 et 4 ne sont
pas affichs puisquil ny a pas de commandes associs 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 rsultats ou la condition est
vrai dans les 2 tables.
61/89
sql.sh
Syntaxe
Pour effectuer un jointure avec CROSS JOIN, il convient deffectuer une requte SQL respectant la
syntaxe suivante :
SELECT *
FROM table1
CROSS JOIN table2
Lune ou lautre de ces syntaxes permettent dassocier tous les rsultats de table1 avec chacun des
rsultats de table2.
Exemple
Imaginons une application de recettes de cuisines qui contient 2 tables dingrdients, la table legume
et la table fruit.
Table legume :
l_id
l_nom_fr_fr
l_nom_en_gb
45
Carotte
Carott
46
Oignon
Onion
47
Poireau
Leek
f_id
f_nom_fr_fr
f_nom_en_gb
87
Banane
Banana
88
Kiwi
Kiwi
89
Poire
Pear
Table fruit :
62/89
sql.sh
Pour une raison quelconque lapplication doit associer tous les lgumes avec tous les fruits. Toutes
les combinaisons doivent tre affiches. Pour cela il convient deffectuer lune ou lautre des requtes
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
Rsultats :
l_id
l_nom_fr_fr
f_id
f_nom_fr_fr
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
47
Poireau
88
Kiwi
47
Poireau
89
Poire
Le rsultat montre bien que chaque lgume est associ chaque fruit. Avec 3 fruits et 3 lgumes, il y
a donc 9 lignes de rsultats (3 x3 = 9).
63/89
sql.sh
Syntaxe
Pour lister les enregistrement de table1, mme sil ny a pas de correspondance avec table2, il
convient deffectuer une requte SQL utilisant la syntaxe suivante.
SELECT *
FROM table1
LEFT JOIN table2 ON table1.id = table2.fk_id
Cette requte est particulirement intressante pour rcuprer les informations de table1 tout en
rcuprant les donnes associes, mme sil ny a pas de correspondance avec table2. A savoir, sil
ny a pas de 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 donnes de cette application contient une table pour les utilisateurs et
sauvegarde leurs achats dans une seconde table. Les 2 tables sont relies grce la colonne
utilisateur_id de la table des commandes. Cela permet dassocier une commande un utilisateur.
Table utilisateur :
id
prenom
nom
ville
Aime
Marechal
aime.marechal@example.com
Paris
Esme
Lefort
esmee.lefort@example.com
Lyon
Marine
Prevost
m.prevost@example.com
Lille
Luc
Rolland
lucrolland@example.com
Marseille
Table commande :
64/89
sql.sh
utilisateur_id
date_achat
num_facture
prix_total
20130123
A00103
203.14
20130214
A00104
124.00
20130217
A00105
149.45
20130221
A00106
235.35
20130302
A00107
47.58
Pour lister tous les utilisateurs avec leurs commandes et afficher galement les utilisateurs qui nont
pas effectues dachats, il est possible dutiliser la requte suivante :
SELECT *
FROM utilisateur
LEFT JOIN commande ON utilisateur.id = commande.utilisateur_id
Rsultats :
id
prenom
nom
date_achat
num_facture
prix_total
Aime
Marechal
20130123
A00103
203.14
Aime
Marechal
20130214
A00104
124.00
Esme
Lefort
20130217
A00105
149.45
Esme
Lefort
20130221
A00106
235.35
Marine
Prevost
NULL
NULL
NULL
Luc
Rolland
NULL
NULL
NULL
Les dernires lignes montrent des utilisateurs qui nont effectue aucune commande. La ligne
retourne la valeur NULL pour les colonnes concernant les achats quils nont pas effectus.
Rsultats :
id
prenom
nom
utilisateur_id
Marine
Prevost
NULL
Luc
Rolland
NULL
65/89
sql.sh
Syntaxe
Lutilisation de cette commande SQL seffectue de la faon suivante :
SELECT *
FROM table1
RIGHT JOIN table2 ON table1.id = table2.fk_id
Cette syntaxe stipule quil faut lister toutes les lignes du tableau table2 (tableau de droite) et afficher
les donnes associes du tableau table1 sil y a une correspondance entre ID de table1 et FK_ID de
table2. Sil ny a pas de correspondance, lenregistrement de table2 sera affich et les colonnes de
table1 vaudront toutes NULL.
Exemple
Prenons lexemple dune base de donnes qui contient des utilisateurs et un historique dachat de
ces utilisateurs. Cette 2 tables sont relies entre grce la colonne utilisateur_id de la table des
commandes. Cela permet de savoir quel utilisateur est associ un achat.
Table utilisateur :
id
prenom
nom
ville
actif
Aime
Marechal
aime.marechal@example.com
Paris
Esme
Lefort
esmee.lefort@example.com
Lyon
Marine
Prevost
m.prevost@example.com
Lille
Luc
Rolland
lucrolland@example.com
Marseille
Table commande :
66/89
sql.sh
utilisateur_id
date_achat
num_facture
prix_total
20130123
A00103
203.14
20130214
A00104
124.00
20130217
A00105
149.45
20130221
A00106
235.35
20130302
A00107
47.58
Pour afficher toutes les commandes avec le nom de lutilisateur correspondant il est normalement
dhabitude dutiliser INNER JOIN en SQL. Malheureusement, si lutilisateur a t supprim de la
table, alors a ne retourne pas lachat. Lutilisation de RIGHT JOIN permet de retourner tous les
achats et dafficher le nom de lutilisateur sil existe. Pour cela il convient dutiliser cette requte :
SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture
FROM utilisateur
RIGHT JOIN commande ON utilisateur.id = commande.utilisateur_id
Rsultats :
id
prenom
nom
utilisateur_id
date_achat
num_facture
Aime
Marechal
20130123
A00103
Aime
Marechal
20130214
A00104
Esme
Lefort
20130217
A00105
Marine
Prevost
20130221
A00106
NULL
NULL
NULL
20130302
A00107
Ce rsultat montre que la facture A00107 est lie lutilisateur numro 5. Or, cet utilisateur nexiste
pas ou nexiste plus. Grce RIGHT JOIN, lachat est tout de mme affich mais les informations
lies lutilisateur sont remplac par NULL.
67/89
sql.sh
Syntaxe
Pour retourner les enregistrements de table1 et table2, il convient dutiliser une requte SQL avec
une syntaxe telle que celle-ci :
SELECT *
FROM table1
FULL JOIN table2 ON table1.id = table2.fk_id
La condition prsente ici consiste lier les tables sur un identifiant, mais la condition peut tre
dfinie sur dautres champs.
Exemple
Prenons lexemple dune base de donnes qui contient une table utilisateur ainsi quune table
commande qui contient toutes les ventes.
Table utilisateur :
id
prenom
nom
ville
actif
Aime
Marechal
aime.marechal@example.com
Paris
Esme
Lefort
esmee.lefort@example.com
Lyon
Marine
Prevost
m.prevost@example.com
Lille
Luc
Rolland
lucrolland@example.com
Marseille
Table commande :
utilisateur_id
date_achat
num_facture
prix_total
20130123
A00103
203.14
20130214
A00104
124.00
20130217
A00105
149.45
20130221
A00106
235.35
20130302
A00107
47.58
68/89
sql.sh
Il est possible dutiliser FULL JOIN pour lister tous les utilisateurs ayant effectu ou non une vente, et
de lister toutes les ventes qui sont associes ou non un utilisateur. La requte SQL est la suivante :
SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture
FROM utilisateur
FULL JOIN commande ON utilisateur.id = commande.utilisateur_id
Rsultat :
id
prenom
nom
utilisateur_id
date_achat
num_facture
Aime
Marechal
20130123
A00103
Aime
Marechal
20130214
A00104
Esme
Lefort
20130217
A00105
Marine
Prevost
20130221
A00106
Luc
Rolland
NULL
NULL
NULL
NULL
NULL
20130302
A00107
Ce rsultat affiche bien lutilisateur numro 4 qui na effectu aucun achat. Le rsultat retourne
galement la facture A00107 qui est associe un utilisateur qui nexiste pas (ou qui nexiste plus).
Dans les cas o il ny a pas de correspondance avec lautre table, les valeurs des colonnes valent
NULL.
69/89
sql.sh
Syntaxe
Pour effectuer un SELF JOIN, la syntaxe de la requte 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 effectue avec un LEFT JOIN, mais il est aussi possible de leffectuer avec dautres
types de jointures.
Exemple
Un exemple potentiel pourrait tre une application dun intranet dentreprise qui possde la table des
employs avec la hirarchie entre eux. Les employs peuvent tre dirig par un suprieur direct qui
se trouve lui-mme dans la table.
Table utilisateur :
id
prenom
nom
manager_id
Sebastien
Martin
s.martin@example.com
NULL
Gustave
Dubois
g.dubois@example.com
NULL
Georgette
Leroy
g.leroy@example.com
Gregory
Roux
g.roux@example.com
Les enregistrements de la table ci-dessus montre bien des employs. Les premiers employs nont
pas de suprieur, tandis que les employs n3 et n4 ont respectivement pour suprieur lemploy
n1 et lemploy n2.
Il est possible de lister sur une mme ligne les employs avec leurs suprieurs direct, grce une
requte 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`
Rsultat :
70/89
sql.sh
u1_email
u1_manager_id
u2_prenom
u2_nom
Sebastien
Martin
s.martin@example.com
NULL
NULL
NULL
Gustave
Dubois
g.dubois@example.com NULL
NULL
NULL
Georgette
Leroy
g.leroy@example.com
Sebastien
Martin
Gregory
Roux
g.roux@example.com
Gustave
Dubois
71/89
sql.sh
Syntaxe
La jointure naturelle de 2 tables peut seffectuer facilement, comme le montre la requte SQL
suivante :
SELECT *
FROM table1
NATURAL JOIN table2
Lavantage dun NATURAL JOIN cest quil ny a pas besoin dutiliser la clause ON.
Exemple
Une utilisation classique dune telle jointure pourrait tre lutilisation dans une application qui utilise
une table utilisateur et une table pays. Si la table utilisateur contient une colonne pour lidentifiant du
pays, il sera possible deffectuer une jointure naturelle.
Table utilisateur :
user_id
user_prenom
user_ville
pays_id
Jrmie
Paris
Damien
Lyon
Sophie
Marseille
NULL
Yann
Lille
9999
La
Paris
Table pays :
pays_id
pays_nom
France
Canada
Belgique
Suisse
Pour avoir la liste de tous les utilisateurs avec le pays correspondant, il est possible deffectuer une
72/89
sql.sh
user_id
user_prenom
user_ville
pays_nom
Jrmie
Paris
France
Damien
Lyon
Canada
NULL
Sophie
Marseille
NULL
9999
Yann
Lille
NULL
La
Paris
France
Cet exemple montre quil y a bien eu une jointure entre les 2 tables grce la colonne pays_id
qui se trouve dans lune et lautre des tables.
73/89
sql.sh
SQL Sous-requte
Dans le langage SQL une sous-requte (aussi appel requte imbrique ou requte en
cascade ) consiste excuter une requte lintrieur dune autre requte. Une requte imbrique
est souvent utilise au sein dune clause WHERE ou de HAVING pou remplacer une ou plusieurs
constante.
Syntaxe
Il y a plusieurs faons dutiliser les sous-requtes. De cette faon il y a plusieurs syntaxes
envisageables pour utiliser des requtes dans des requtes.
Cet exemple montre une requte interne (celle sur table2) qui renvoi une seule valeur. La requte
externe quant elle, va chercher les rsultat de table et filtre les rsultats partir de la valeur
retourne par la requte interne.
A noter : il est possible dutiliser nimporte quel oprateur dgalit tel que =, >, <, >=, <= ou <>.
Exemple
La suite de cet article prsente des exemples concrets utilisant les sous-requtes.
74/89
sql.sh
Imaginons un site web qui permet de poser des questions et dy rpondre. Un tel site possde une
base de donnes avec une table pour les questions et une autre pour les rponses.
Table question :
q_id q_date_ajout q_titre
q_contenu
20130324
12:54:32
Commentrparerun Bonjour,j'aimonordinateurdecass,commentpuisje
ordinateur?
procderpourlerparer?
20130326
19:27:41
Commentchanger
unpneu?
Quelestlameilleurmthodepourchangerunpneu
facilement?
20130418
20:09:56
Quefairesiun
appareilestcass?
Estilprfrablederparerlesappareilslectriquesou
d'enacheterdenouveaux?
20130422
17:14:27
Commentfaire
nettoyerunclavier
d'ordinateur?
Bonjour,sousmonclavierd'ordinateurilyabeaucoup
depoussire,commentfautilprocderpourlenettoyer?
Merci.
Table reponse :
r_id
r_fk_question_id r_date_ajout
r_contenu
20130327
07:44:32
Bonjour.Pouvezvousexpliquercequinefonctionnepas
avecvotreordinateur?Merci.
20130328
19:27:11
Bonsoir,leplussimpleconsistefaireappelun
professionnelpourrparerunordinateur.Cordialement,
20130509
22:10:09
Desconseilssondisponiblesurinternetsurcesujet.
20130524
09:47:12
Bonjour.adpenddevous,devotrebudgetetdevos
prfrencevisvisdel'cologie.Cordialement,
q_contenu
Estilprfrablederparerlesappareilslectriquesou
d'enacheterdenouveaux?
20130418
20:09:56
Quefairesiun
appareilestcass?
75/89
sql.sh
Ce rsultat dmontre que la question lie la dernire rponse sur le forum est bien trouve partir
de ce rsultat.
Rsultats :
q_id q_date_ajout q_titre
q_contenu
20130324
12:54:32
Commentrparerun Bonjour,j'aimonordinateurdecass,commentpuisje
ordinateur?
procderpourlerparer?
20130326
19:27:41
Commentchanger
unpneu?
Quelestlameilleurmthodepourchangerunpneu
facilement?
20130418
20:09:56
Quefairesiun
appareilestcass?
Estilprfrablederparerlesappareilslectriquesou
d'enacheterdenouveaux?
Une telle requte permet donc de rcuprer les questions qui ont eu des rponses entre 2 dates.
Cest pratique dans notre cas pour viter dobtenir des rponses qui nont pas eu de rponses du tout
ou pas de nouvelles rponses depuis longtemps.
76/89
sql.sh
SQL EXISTS
Dans le langage SQL, la commande EXISTS sutilise dans une clause conditionnelle pour savoir sil y
a une prsence ou non de lignes lors de lutilisation dune sous-requte.
A noter : cette commande nest pas confondre avec la clause IN. La commande EXISTS vrifie si
la sous-requte retourne un rsultat ou non, tandis que IN vrifie la concordance dune plusieurs
donnes.
Syntaxe
Lutilisation basique de la commande EXISTS consiste vrifier si une sous-requte retourne un
rsultat ou non, en utilisant EXISTS dans la clause conditionnelle. La requte externe sexcutera
uniquement si la requte interne retourne au moins un rsultat.
SELECT nom_colonne1
FROM `table1`
WHERE EXISTS (
SELECT nom_colonne2
FROM `table2`
WHERE nom_colonne3 = 10
)
Dans lexemple ci-dessus, sil y a au moins une ligne dans table2 dont nom_colonne3 contient la
valeur 10, alors la sous-requte retournera au moins un rsultat. Ds lors, la condition sera vrifie et
la requte principale retournera les rsultats de la colonne nom_colonne1 de table1.
Exemple
Dans le but de montrer un exemple concret dapplication, imaginons un systme compos dune
table qui contient des commandes et dune table contenant des produits.
Table commande :
c_id
c_date_achat
c_produit_id
c_quantite_produit
20140108
20140124
20140214
20140323
10
Table produit :
77/89
sql.sh
p_id
p_nom
p_date_ajout
p_prix
Ordinateur
20131117
799.9
Clavier
20131127
49.9
Souris
20131204
15
Ecran
20131215
250
Il est possible deffectuer une requte SQL qui affiche les commandes pour lesquels il y a
effectivement un produit. Cette requte peut tre interprte de la faon suivante :
SELECT *
FROM commande
WHERE EXISTS (
SELECT *
FROM produit
WHERE c_produit_id = p_id
)
Rsultat :
c_id
c_date_achat
c_produit_id
c_quantite_produit
20140108
20140124
Le rsultat dmontre bien que seul les commandes n1 et n2 ont un produit qui se trouve dans la
table produit (cf. la condition c_produit_id = p_id). Cette requte est intressante sachant quelle
ninfluence pas le rsultat de la requte principale, contrairement lutilisation dune jointure qui va
concatner les colonnes des 2 tables jointes.
78/89
sql.sh
SQL ALL
Dans le langage SQL, la commande ALL permet de comparer une valeur dans lensemble de valeurs
dune sous-requte. En dautres mots, cette commande permet de sassurer quune condition est
gale , diffrente , suprieure , infrieure , suprieure ou gale ou infrieure ou gale
pour tous les rsultats retourn par une sous-requte.
Syntaxe
Cette commande sutilise dans une clause conditionnelle entre loprateur de condition et la sousrequte. Lexemple ci-dessous montre un exemple basique :
SELECT *
FROM table1
WHERE condition > ALL (
SELECT *
FROM table2
WHERE condition2
)
A savoir : les oprateur conditionnels peuvent tre les suivants : =, <, >, <>, !=, <=, >=, !> ou !<.
Exemple
Imaginons une requte similaire la syntaxe de base prsente prcdemment :
SELECT colonne1
FROM table1
WHERE colonne1 > ALL (
SELECT colonne1
FROM table2
)
Avec cette requte, si nous supposons que dans table1 il y a un rsultat avec la valeur 10, voici les
diffrents rsultats de la conditions selon le contenu de table2 :
La condition est vrai (cf. TRUE) si table2 contient {-5,0,+5} car toutes les valeurs sont
infrieure 10
La condition est fausse (cf. FALSE) si table2 contient {12,6,NULL,-100} car au moins une
valeur est infrieure 10
La condition est non connue (cf. UNKNOW) si table2 est vide
79/89
sql.sh
Syntaxe
Cette commande sutilise dans une clause conditionnelle juste aprs un oprateur conditionnel et
juste avant une sous-requte. Lexemple ci-dessous dmontre une utilisation basique de ANY dans
une requte SQL :
SELECT *
FROM table1
WHERE condition > ANY (
SELECT *
FROM table2
WHERE condition2
)
Cette requte peut se traduire de la faon suivante : slectionner toutes les colonnes de table1, o la
condition est suprieure nimporte quel rsultat de la sous-requte.
A savoir : les oprateur conditionnels peuvent tre les suivants : =, <, >, <>, !=,<=, >=, !> ou !<.
Exemple
En se basant sur lexemple relativement simple prsent ci-dessus, il est possible deffectuer une
requte concrte qui utilise la commande ANY :
SELECT colonne1
FROM table1
WHERE colonne1 > ANY (
SELECT colonne1
FROM table2
)
Supposons que la table1 possde un seul rsultat dans lequel colonne1 est gal 10.
La condition est vrai (cf. TRUE) si table2 contient {21,14,7} car il y a au moins une valeur
infrieure 10
La condition est fausse (cf. FALSE) si table2 contient {20,10} car aucune valeur est strictement
infrieure 10
La condition est non connue (cf. UNKNOW) si table2 est vide
80/89
sql.sh
Astuce
La commande IN est quivalent loprateur = suivi de ANY.
81/89
sql.sh
Index SQL
En SQL, les index sont des ressources trs utiles qui permettent daccder plus rapidement aux
donnes. Cette page explique le fonctionnement des index et leurs intrts pour accrotre les
performances de lectures des donnes.
Index en SQL
Un index, dans une base de donnes se base sur le mme principe quun index dans un livre. Avec
un index plac sur une ou plusieurs colonnes le systme dune base de donnes peut rechercher les
donnes dabord sur lindex et sil trouve ce quil cherche il saura plus rapidement o se trouve les
enregistrements concerns.
Ces petites ressources ont toutefois leurs inconvnients car cela occupe de lespace supplmentaire
dans la base de donnes. Par ailleurs, linsertion de donnes est plus long car les index sont mis
jour chaque fois que des donnes sont insres.
Gnralement un index pourra tre utilis dans les requtes utilisant les clauses WHERE, GROUP
BY ou ORDER BY. Lorsquune base de donnes possde un grand nombre denregistrements
(exemple: plusieurs milliers ou plusieurs millions de lignes) un index permet de gagner un temps
prcieux pour la lecture de donnes.
82/89
sql.sh
Syntaxe
Crer un index ordinaire
La syntaxe basique pour crer un index est la suivante :
CREATE INDEX `index_nom` ON `table`;
Il est galement possible de crer un index sur une seule colonne en prcisant la colonne sur
laquelle doit sappliquer lindex :
CREATE INDEX `index_nom` ON `table` (`colonne1`);
Lexemple ci-dessus va donc insrer lindex intitul index_nom sur la table nomme table
uniquement sur la colonne colonne1. Pour insrer un index sur plusieurs colonnes il est possible
dutiliser la syntaxe suivante :
CREATE INDEX `index_nom` ON `table` (`colonne1`, `colonne2`);
Dans cet exemple un index unique sera cr sur la colonne nomme colonne1. Cela signifie quil ne
peut pas y avoir plusieurs fois la mme valeur sur 2 enregistrements distincts contenus dans cette
table.
Il est galement possible de crer un index dunicit sur 2 colonnes, en respectant la syntaxe
suivante :
CREATE UNIQUE INDEX `index_nom` ON `table` (`colonne1`, `colonne2`);
Convention de nommage
Il nexiste pas de convention de nommage spcifique sur le nom des index, juste des suggestions de
quelques dveloppeurs et administrateurs de bases de donnes. Voici une liste de suggestions de
prfixes utiliser pour nommer un index :
83/89
sql.sh
84/89
sql.sh
SQL EXPLAIN
Dans le langage SQL, linstruction EXPLAIN est utiliser juste avant un SELECT et permet dafficher
le plan dexcution dune requte SQL. Cela permet de savoir de quelle manire le Systme de
Gestion de Base de Donnes (SGBD) va excuter la requte et sil va utiliser des index et lesquels.
En utilisant cette commande la requte ne renverra pas les rsultats du SELECT mais plutt une
analyse de cette requte.
A noter : le rsultat de cette instruction est diffrent selon les SGBD, tel que MySQL ou PostgreSQL.
Par ailleurs, le nom de cette instruction diffre pour certains SGBD :
MySQL : EXPLAIN
PostgreSQL : EXPLAIN
Oracle : EXPLAIN PLAN
SQLite : EXPLAIN QUERY PLAN
SQL Server :
SET SHOWPLAN_ALL : informations estimes dune requte SQL, affich au format textuel
dtaill
SET SHOWPLAN_TEXT : informations estimes dune requte SQL, affich au format textuel
simple
SET SHOWPLAN_XML : informations estimes dune requte SQL, affich au format XML
SET STATISTICS PROFILE : statistiques sur lexcution dune requte SQL, affich au format
textuel
SET STATISTICS XML : statistiques sur lexcution dune requte SQL, affich au format XML
Firebird : SET PLANONLY ON; puis lexcution de la requte SQL analyser
Syntaxe
La syntaxe ci-dessous reprsente une requte SQL utilisant la commande EXPLAIN pour MySQL ou
PostgreSQL :
EXPLAIN SELECT *
FROM `user`
ORDER BY `id` DESC
Rappel : dans cet exemple, la requte retournera des informations sur le plan dexcution, mais
naffichera pas les vrai rsultats de la requte.
Exemple
Pour expliquer concrtement le fonctionnement de linstruction EXPLAIN nous allons prendre une
table des fuseaux horaires en PHP. Cette table peut tre cr partir de la requte SQL suivante :
CREATE TABLE IF NOT EXISTS `timezones` (
`timezone_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`timezone_groupe_fr` varchar(50) DEFAULT NULL,
`timezone_groupe_en` varchar(50) DEFAULT NULL,
`timezone_detail` varchar(100) DEFAULT NULL,
PRIMARY KEY (`timezone_id`)
85/89
sql.sh
La requte ci-dessous permet de mieux comprendre la structure et les index de cette table.
Imaginons que lont souhaite compter le nombre de fuseaux horaires par groupe, pour cela il est
possible dutiliser la requte SQL suivante :
SELECT timezone_groupe_fr, COUNT(timezone_detail) AS total_timezone
FROM `timezones`
GROUP BY timezone_groupe_fr
ORDER BY timezone_groupe_fr ASC
id : identifiant de SELECT
select_type : type de cause SELECT (exemple : SIMPLE, PRIMARY, UNION, DEPENDENT
UNION, SUBQUERY, DEPENDENT SUBSELECT ou DERIVED)
table : table laquelle la ligne fait rfrence
type : le type de jointure utilis (exemple : system, const, eq_ref, ref, ref_or_null,
index_merge, unique_subquery, index_subquery, range, index ou ALL)
possible_keys : liste des index que MySQL pourrait utiliser pour acclrer lexcution de la
requte. Dans notre exemple, aucun index nest disponible pour acclrer lexcution de la
requte SQL
key : cette colonne prsente les index que MySQL a dcid dutiliser pour lexcution de la
requte
key_len : indique la taille de la cl qui sera utilise. Sil ny a pas de cl, cette colonne renvois
NULL
ref : indique quel colonne (ou constante) sont utiliss avec les lignes de la table
rows : estimation du nombre de ligne que MySQL va devoir analyser examiner pour excuter
la requte
Extra : information additionnelle sur la faon dont MySQL va rsoudre la requte. Si cette
colonne retourne des rsultats, cest quil y a potentiellement des index utiliser pour
86/89
sql.sh
Lajout de cet index va changer la faon dont MySQL peut excuter une requte SQL. En effectuant
la mme requte que tout lheure, les rsultats seront diffrent.
87/89
sql.sh
Commentaires en SQL
Il peut tre intressant dinsrer des commentaires dans les requtes SQL pour mieux sy retrouver
lorsquil y a de grosses requtes complexes. Il y a plusieurs faon de faire des commentaires dans le
langage SQL, qui dpendent notamment du Systme de Gestion de Base de Donnes utilises
(SGBD) et de sa version.
Exemple
SELECT *
-- tout slectionner
Compatibilit
Commentaire dise : #
Le symbole dise permet de faire un commentaire jusqu la fin de la ligne.
Exemple
SELECT *
# tout slectionner
Compatibilit
MySQL
Commentaire multi-ligne : /* et */
Le commentaire multi-ligne lavantage de pouvoir indiquer o commence et o se termine le
commentaire. Il est donc possible de lutiliser en plein milieu dune requte SQL sans problme.
Exemple
SELECT *
/* tout slectionner */
Compatibilit
MySQL
PostgreSQL
Oracle
88/89
sql.sh
SQL Server
SQLite
-- tout slectionner
En consquent il faut se mfier de librairies externes qui peuvent r-crire les requtes SQL ou alors
tout simplement se mfier de copier/coller.
89/89
sql.sh