Comment fonctionnent GROUP BY et HAVING ?

Question

Accepted Answer

**`GROUP BY`** regroupe les lignes qui partagent une valeur, de sorte que les fonctions d'agrégation calculent par groupe. **`HAVING`** filtre ces groupes (comme `WHERE`, mais pour les groupes/agrégats). Ensemble, ce sont les bases de la synthèse et de l'analyse des données par catégorie.

## GROUP BY — agrégation par groupe

```sql
SELECT country, COUNT(*) AS user_count, AVG(age) AS avg_age
FROM users
GROUP BY country;
-- one result row PER country, with that country's count and average age
```

`GROUP BY country` réduit toutes les lignes de chaque pays en un seul groupe, et les fonctions d'agrégation (`COUNT`, `AVG`) calculent une valeur pour chaque groupe. Vous pouvez grouper par plusieurs colonnes :

```sql
GROUP BY country, city          -- a group per unique (country, city) combination
```

## HAVING — filtrer les groupes

```sql
-- show only countries with MORE THAN 100 users
SELECT country, COUNT(*) AS user_count
FROM users
GROUP BY country
HAVING COUNT(*) > 100;          -- filter on the AGGREGATE
```

`HAVING` filtre *après* le groupage, sur les valeurs agrégées — quelque chose que `WHERE` ne peut pas faire (WHERE filtre les lignes individuelles avant le groupage).

## WHERE vs HAVING — une distinction clé

```sql
SELECT country, COUNT(*) AS cnt
FROM users
WHERE active = true             -- WHERE: filter ROWS first (before grouping)
GROUP BY country
HAVING COUNT(*) > 100;          -- HAVING: filter GROUPS after (on aggregates)
```

```text
WHERE  → filters individual ROWS, runs BEFORE grouping, can't use aggregates
HAVING → filters GROUPS, runs AFTER grouping, used WITH aggregates
→ Use WHERE to filter rows, HAVING to filter aggregated groups. (Filter with WHERE
  first when possible — it's more efficient, reducing rows before grouping.)
```

## L'ordre d'exécution

```text
FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
(WHERE before grouping, HAVING after — which is why their roles differ)
```

## Pourquoi c'est important

`GROUP BY` et `HAVING` sont au cœur du **SQL analytique** — la synthèse et l'analyse des données par catégorie est un besoin fondamental et constant (nombres par région, ventes par produit, moyennes par groupe), donc les comprendre est essentiel. `GROUP BY` (regroupement des lignes de sorte que les agrégats calculent par groupe) est la base de ces requêtes de synthèse, et comprendre comment il réduit les lignes en groupes pour l'agrégation est nécessaire pour tout rapport ou analyse.

La **distinction `WHERE` vs `HAVING`** est particulièrement importante et souvent confondue : `WHERE` filtre les lignes individuelles *avant* le groupage (et ne peut pas utiliser les agrégats), tandis que `HAVING` filtre les groupes *après* le groupage (sur les valeurs agrégées) — utiliser le mauvais provoque des erreurs ou des résultats incorrects, et comprendre quand chacun s'applique (WHERE pour le filtrage au niveau des lignes, HAVING pour le filtrage au niveau des agrégats des groupes) est une compétence clé.

Savoir filtrer avec WHERE en premier lorsque c'est possible (plus efficace — réduction des lignes avant le groupage) est une optimisation utile.

La connexion à **l'ordre d'exécution** (WHERE avant le groupage, HAVING après) explique pourquoi leurs rôles diffèrent.

Comme le groupage et le filtrage des agrégats sont omniprésents dans les rapports et l'analyse des données, et comme la distinction WHERE-vs-HAVING est à la fois importante pour la correction et couramment mal comprise, maîtriser `GROUP BY` et `HAVING` — regroupement pour les agrégats par catégorie et le modèle de filtrage à deux niveaux — est une connaissance fondamentale et fréquemment appliquée essentielle pour le SQL analytique et un sujet courant d'entretien.