JOIN, UNION, WHERE, HAVING, GROUP BY : le guide pour ne plus jamais confondre

Quand on débute en SQL, certaines clauses semblent se ressembler… jusqu'au jour où on se retrouve face à une erreur incompréhensible, ou pire, des résultats silencieusement faux. Dans cet article, on va démystifier ensemble cinq des clauses les plus fondamentales du SQL : JOIN, UNION, WHERE, HAVING et GROUP BY.

JOIN vs UNION : deux façons très différentes de combiner des données

C'est l'une des confusions les plus classiques chez les personnes qui apprennent le SQL. Ces deux mots-clés servent tous les deux à "combiner" des données, mais ils ne font absolument pas la même chose.

JOIN : assembler des colonnes entre plusieurs tables

Le JOIN permet de relier deux tables en fonction d'une condition commune, typiquement une clé étrangère. Le résultat est une table plus large, avec davantage de colonnes.

Exemple concret : vous avez une table clients et une table commandes. Vous voulez afficher le nom du client à côté du montant de chaque commande.

SELECT clients.nom, commandes.montant
FROM clients
JOIN commandes ON clients.id = commandes.client_id;

Ici, SQL va chercher dans les deux tables et assembler les colonnes côte à côte. Pensez-y comme à un VLOOKUP dans Excel : on va chercher une information dans une autre table.

À retenir : JOIN = relation entre tables. On ajoute des colonnes.

UNION : empiler des lignes entre plusieurs requêtes

Le UNION, lui, ne touche pas aux colonnes. Il prend les résultats de deux requêtes SELECT distinctes et les empile les uns sous les autres. Les deux requêtes doivent avoir le même nombre de colonnes, avec des types compatibles.

Exemple concret : vous avez une table clients_france et une table clients_espagne, et vous voulez une liste unique de tous les noms.

SELECT nom FROM clients_france
UNION
SELECT nom FROM clients_espagne;

Résultat : une seule colonne nom avec toutes les lignes combinées (et les doublons supprimés par défaut, utilisez UNION ALL pour les conserver).

À retenir : UNION = concaténation de résultats. On ajoute des lignes.

WHERE, HAVING, GROUP BY : chacun sa place, chacun son rôle

Ces trois clauses sont souvent utilisées ensemble, mais leur ordre et leur rôle sont très précis. Les confondre, c'est la garantie d'obtenir une erreur, ou des résultats incorrects.

Avant de lire la suite, testez-vous : saurez-vous associer chaque clause à son rôle ?

GROUP BY : regrouper les données

GROUP BY permet de rassembler toutes les lignes qui partagent une même valeur dans une colonne, pour pouvoir ensuite leur appliquer une fonction d'agrégation (COUNT, SUM, AVG, MAX, MIN…).

Exemple : compter le nombre de clients par pays.

SELECT pays, COUNT(*)
FROM clients
GROUP BY pays;

Sans le GROUP BY pays, SQL ne saurait pas comment regrouper les lignes pour calculer le COUNT. Cette clause est indispensable dès que vous utilisez une fonction d'agrégation avec une colonne non agrégée dans votre SELECT.

WHERE : filtrer avant l'agrégation

WHERE s'applique avant que les données ne soient regroupées. C'est le filtre de base, celui qu'on utilise pour exclure des lignes dès le départ.

Exemple : ne compter que les clients dont l'inscription date d'après 2022.

SELECT pays, COUNT(*)
FROM clients
WHERE annee_inscription > 2022
GROUP BY pays;

HAVING : filtrer après l'agrégation

HAVING s'applique après le regroupement. Il permet de filtrer sur le résultat des fonctions d'agrégation, ce que WHERE ne peut pas faire.

Exemple : n'afficher que les pays qui ont plus de 10 clients.

SELECT pays, COUNT(*)
FROM clients
GROUP BY pays
HAVING COUNT(*) > 10;

L'erreur classique à éviter absolument

Un exemple concret pour bien ancrer le concept, erreur ou pas ?

Voici une requête qui ressemble à quelque chose de correct, mais qui va planter :

SELECT nom,
FROM clients;
WHERE COUNT(*) > 10

Pourquoi c'est une erreur ? COUNT(*) est une fonction d'agrégation, elle ne peut pas s'utiliser dans une clause WHERE, qui s'exécute avant que les données soient groupées. Sans compter la virgule traînante après nom qui génère également une erreur de syntaxe.

La version correcte :

SELECT nom
FROM clients
GROUP BY nom
HAVING COUNT(*) > 10;

Récapitulatif : l'ordre d'exécution SQL

Pour tout retenir, voici l'ordre dans lequel SQL exécute les clauses :

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

• WHERE : filtre les lignes brutes (avant agrégation)

• GROUP BY : regroupe les lignes filtrées

• HAVING : filtre les groupes (après agrégation)

Une fois cet ordre bien ancré, les erreurs de type "impossible d'utiliser une fonction d'agrégation dans WHERE" deviennent immédiatement compréhensibles.

En résumé

Clause	Quand l'utiliser
JOIN	Pour combiner des colonnes de plusieurs tables
UNION	Pour empiler les résultats de plusieurs requêtes
WHERE	Pour filtrer des lignes avant l'agrégation
GROUP BY	Pour regrouper des lignes en vue d'une agrégation
HAVING	Pour filtrer des groupes après l'agrégation