Résumer des lignes : GROUP BY

Un nombre par groupe

GROUP BY rassemble les lignes qui partagent une valeur, et les fonctions d’agrégation réduisent chaque tas à un seul nombre.

SELECT status, COUNT(*) AS orders
FROM orders
GROUP BY status
ORDER BY orders DESC;

Sept statuts, sept lignes. Chaque colonne de la liste SELECT est soit quelque chose sur quoi vous avez regroupé, soit quelque chose que vous avez agrégé — c’est la règle qui rend le résultat bien défini. Demandez order_number ici et la question perd son sens : lequel des 1 351 numéros de commandes livrées faudrait-il choisir ?

COUNT(*) n’est pas COUNT(colonne)

SELECT COUNT(*) AS customers,
       COUNT(phone) AS with_phone,
       COUNT(*) - COUNT(phone) AS without_phone
FROM customers;

COUNT(*) compte les lignes. COUNT(phone) compte les lignes où phone n’est pas nul. L’écart, ce sont les 279 clients de la leçon sur le filtrage, et c’est une astuce réellement utile : soustraire les deux comptes donne ce qui manque sans seconde requête.

Tous les autres agrégats ignorent aussi les NULL, ce qui compte surtout pour AVG. La moyenne de 10, 20 et NULL vaut 15, pas 10 — le NULL n’est pas traité comme un zéro, il n’est pas compté du tout. Quand vous voulez qu’il compte pour zéro, dites-le avec COALESCE(colonne, 0).

Plusieurs agrégats à la fois

SELECT cat.name AS category,
       COUNT(*) AS products,
       ROUND(MIN(p.price), 2) AS cheapest,
       ROUND(AVG(p.price), 2) AS average,
       ROUND(MAX(p.price), 2) AS dearest
FROM products p
JOIN categories cat ON cat.id = p.category_id
GROUP BY cat.id
ORDER BY average DESC
LIMIT 20;

Un seul passage sur la table répond à cinq questions par catégorie. Faire la même chose côté application, c’est transférer les 400 lignes de produits et boucler dessus ; la base calcule les cinq nombres là où les lignes se trouvent déjà et en renvoie 20.

Regrouper à travers une jointure

Agrégats et jointures se combinent. On joint d’abord, puis on regroupe les lignes jointes.

SELECT cat.name AS category,
       COUNT(DISTINCT o.id) AS orders,
       SUM(oi.quantity) AS units,
       ROUND(SUM(oi.quantity * oi.unit_price), 2) AS revenue
FROM order_items oi
JOIN orders o ON o.id = oi.order_id
JOIN products p ON p.id = oi.product_id
JOIN categories cat ON cat.id = p.category_id
WHERE o.status IN ('paid', 'shipped', 'delivered')
GROUP BY cat.id
ORDER BY revenue DESC;

WHERE avant, HAVING après

Les deux filtrent. Ils filtrent à des moments différents, et c’est là leur seule différence.

SELECT cat.name AS category,
       ROUND(SUM(oi.quantity * oi.unit_price), 2) AS revenue
FROM order_items oi
JOIN products p ON p.id = oi.product_id
JOIN categories cat ON cat.id = p.category_id
GROUP BY cat.id
HAVING SUM(oi.quantity * oi.unit_price) > 1000000
ORDER BY revenue DESC;

WHERE s’exécute avant le regroupement et décide quelles lignes y participent. HAVING s’exécute après et décide quels groupes survivent. Une condition sur une colonne brute va donc dans WHERE, et une condition sur un agrégat ne peut aller que dans HAVING — l’agrégat n’existe pas encore pendant l’exécution de WHERE.

Placez à côté la séquence des clauses vue dans la leçon sur SELECT, et la règle s’explique d’elle-même :

FROM  ->  WHERE  ->  GROUP BY  ->  HAVING  ->  SELECT  ->  ORDER BY  ->  LIMIT

Regrouper sur une valeur calculée

On peut regrouper sur une expression, pas seulement sur une colonne. Couper les sept premiers caractères d’un horodatage donne 2025-01 — un mois.

SELECT substr(ordered_at, 1, 7) AS month,
       COUNT(*) AS orders,
       ROUND(SUM(total), 2) AS revenue
FROM orders
WHERE status IN ('paid', 'shipped', 'delivered')
  AND ordered_at >= '2025-01-01'
GROUP BY month
ORDER BY month;

Regrouper sur une valeur dérivée ainsi, c’est la façon dont s’écrit presque tout rapport « par mois » ou « par semaine ». Notez que GROUP BY month réutilise l’alias du SELECT, ce que tous les moteurs autorisent dans GROUP BY et ORDER BY — seuls WHERE et HAVING sont stricts.

Ce que vous savez faire maintenant

Vous savez produire un rapport. Ce que vous ne savez pas encore faire, c’est comparer une ligne à un résumé — « les produits au-dessus du prix moyen », « les trois premiers de chaque catégorie » — car cela demande deux requêtes en même temps. C’est le sujet de la prochaine leçon.