Aide-mémoire SQL : requêtes SELECT, jointures et agrégations

Rangé par ce qu'on cherche à obtenir. La syntaxe est dans les tables ; les requêtes au-dessous s'exécutent sur une vraie base, toujours la table Employe, la même que dans les chapitres.

Voir ce qu'il y a dans la base

La toute première requête à écrire devant une base inconnue.

requete.sql

Résultat

>_ Prêt à exécuter…

L'ordre des clauses, qui ne se discute pas

Une requête s'écrit toujours dans cet ordre, et les clauses absentes se sautent.

SELECT    quelles colonnes
FROM      quelle table
JOIN      quelles autres tables
WHERE     quelles lignes garder            (avant regroupement)
GROUP BY  comment les regrouper
HAVING    quels groupes garder             (après regroupement)
ORDER BY  dans quel ordre les rendre
LIMIT     combien en garder

Mais la base, elle, ne les exécute pas dans cet ordre : elle commence par FROM, puis WHERE, puis GROUP BY, puis HAVING, et seulement ensuite SELECT. C'est toute l'explication de deux pièges de la dernière section.

Choisir les colonnes

Écrire	Ce que ça fait
`SELECT *`	Toutes les colonnes. Commode pour explorer, à éviter ensuite.
`SELECT nom, service`	Seulement celles-là.
`SELECT DISTINCT service`	Sans les doublons.
`SELECT salaire * 12 AS annuel`	Une colonne calculée, renommée.
`SELECT nom \|\| ' ' \|\| prenom`	Coller deux textes.

requete.sql

Résultat

>_ Prêt à exécuter…

Garder certaines lignes

Écrire	Ce que ça fait
`WHERE salaire >= 2500`	Comparer.
`WHERE nom = 'Girard'`	Guillemets simples pour le texte.
`WHERE service IN ('Etudes', 'Support')`	Dans une liste de valeurs.
`WHERE salaire BETWEEN 2000 AND 3000`	Bornes comprises.
`WHERE nom LIKE 'G%'`	Commence par G. `%` remplace n'importe quelle suite.
`WHERE salaire IS NULL`	Valeur absente. Jamais `= NULL`.
`AND` `OR` `NOT`	Combiner. Les parenthèses évitent les surprises.

requete.sql

Résultat

>_ Prêt à exécuter…

Compter, sommer, moyenner

Écrire	Ce que ça fait
`COUNT(*)`	Le nombre de lignes.
`COUNT(colonne)`	Le nombre de valeurs non nulles de cette colonne.
`SUM(x)` `AVG(x)`	Somme, moyenne.
`MIN(x)` `MAX(x)`	Le plus petit, le plus grand.
`ROUND(AVG(x), 2)`	Arrondir le résultat.

requete.sql

Résultat

>_ Prêt à exécuter…

Regrouper

GROUP BY transforme des lignes en paquets, et les fonctions de comptage s'appliquent alors à chaque paquet.

Écrire	Ce que ça fait
`GROUP BY service`	Un paquet par valeur de `service`.
`GROUP BY a, b`	Un paquet par couple de valeurs.
`HAVING COUNT(*) > 5`	Ne garder que les paquets d'au moins six lignes.
`SELECT service, COUNT(*)`	Toute colonne du `SELECT` doit être regroupée ou agrégée.
`ORDER BY COUNT(*) DESC`	Trier les paquets par leur taille.

requete.sql

Résultat

>_ Prêt à exécuter…

WHERE ou HAVING

WHERE filtre des lignes, avant le regroupement. HAVING filtre des groupes, après. Une condition sur une colonne ordinaire va dans WHERE ; une condition sur un COUNT ou une moyenne va dans HAVING. Mettre la seconde dans WHERE fait échouer la requête, et le message le dit.

Relier deux tables

Écrire	Ce que ça fait
`JOIN … ON …`	Garde les lignes qui se correspondent des deux côtés.
`LEFT JOIN`	Garde toutes les lignes de gauche, avec des `NULL` à droite quand rien ne correspond.
`FROM Employe e`	Un alias, qui rend la requête lisible dès deux tables.

requete.sql

Résultat

>_ Prêt à exécuter…

requete.sql

Résultat

>_ Prêt à exécuter…

Modifier les données

Écrire	Ce que ça fait
`INSERT INTO t (a, b) VALUES (…)`	Ajouter une ligne.
`UPDATE t SET a = … WHERE …`	Modifier. Sans WHERE, toutes les lignes.
`DELETE FROM t WHERE …`	Supprimer. Sans WHERE, la table entière.
`BEGIN ; … ; COMMIT ;`	Tout ou rien. `ROLLBACK` annule.

requete.sql

Résultat

>_ Prêt à exécuter…

Ce qui se trompe le plus souvent

Le piège	Ce qu'il faut faire
`= NULL` ne vaut jamais vrai	`IS NULL`, `IS NOT NULL`
`COUNT(colonne)` ignore les valeurs absentes	`COUNT(*)` pour compter les lignes
Une jointure sans `ON` produit toutes les paires	toujours écrire la condition de jointure
Une agrégation dans `WHERE` échoue	la mettre dans `HAVING`
`UPDATE` ou `DELETE` sans `WHERE` touche tout	écrire d'abord le `SELECT` équivalent
`AVG` ignore les `NULL`, pas les zéros	`COALESCE(x, 0)` si l'absence vaut zéro

requete.sql

Résultat

>_ Prêt à exécuter…

requete.sql

Résultat

>_ Prêt à exécuter…

requete.sql

Résultat

>_ Prêt à exécuter…

requete.sql

Résultat

>_ Prêt à exécuter…

Vérifier avant de modifier

Avant tout UPDATE ou DELETE, écrire d'abord la même requête en SELECT avec le même WHERE. Les lignes affichées sont exactement celles qui seront touchées. C'est la précaution qui coûte dix secondes et qui évite de vider une table.

Pour aller plus loin

Les requêtes SQL pose les bases, SQL avancé traite les regroupements et les sous-requêtes, et Les transactions explique ce que garantit un COMMIT et ce qui se passe quand deux clients écrivent en même temps.