Grouper avec GROUP BY

Un agrégat global résume toute la table en une ligne. GROUP BY va plus loin : il divise les lignes en groupes selon une valeur commune, puis applique l'agrégat à chaque groupe séparément — non plus une ligne, mais une ligne par groupe.

De l'agrégat global au calcul par groupe

La leçon précédente donnait COUNT(*) = 14 — un seul chiffre pour toute la table. C'est utile pour un résumé global, mais si quelqu'un veut comparer les films oscarisés aux autres — combien dans chaque catégorie, quelle note moyenne par groupe — une seule ligne de résultat ne suffit plus.

GROUP BY règle ce problème : il regroupe les lignes qui partagent la même valeur dans une colonne, puis calcule l'agrégat dans chaque paquet séparément. Non plus une ligne en sortie, mais une ligne par groupe.

Table films — la colonne oscar a des valeurs répétées

titrenoteoscar
Inception8.8true
Le Parrain9.2true
Pulp Fiction8.9false
Amélie Poulain8.3false
Les Marées de Titan8.7true
Orbite Basse8.2false
Les Neiges de Kervalec8.3true
L'Écluse de Marvaux8.4false
Les Docks du Port-Neuf7.9false
Minuit moins sept7.9false
Un Été sans Wifi8.3false
Mariage à l'Improviste6.8false
Les Lanternes de Mizuhara8.6true
Cinq-Boulons et la Mer Immobile7.4false

oscar vaut true pour cinq films (dont Inception et Le Parrain) et false pour les neuf autres (dont Pulp Fiction et Amélie Poulain). La valeur se répète — c'est la signature d'une colonne utile pour GROUP BY. PostgreSQL va former deux paquets, l'un pour chaque valeur, et calculer un agrégat dans chacun.

GROUP BY — un calcul par groupe

GROUP BY colonne regroupe toutes les lignes qui partagent la même valeur dans cette colonne, puis applique l'agrégat séparément à chaque groupe. La clause se place après le FROM (ou après un éventuel WHERE) :

La requête
SELECT oscar, COUNT(*) AS nb_films FROM films GROUP BY oscar ORDER BY oscar
Résultat — 2 lignes (un groupe par valeur distincte de oscar) · 2 lignes
oscarnb_films
false9
true5

Deux lignes pour deux valeurs distinctes de oscar. COUNT(*) a été appliqué séparément à chaque groupe : les 9 films où oscar = false et les 5 films où oscar = true. Le total reste bien 14 (9 + 5). ORDER BY oscar trie false avant true.

La règle d'or

Règle à ne jamais oublier : toute colonne qui apparaît dans le SELECT sans être un agrégat doit figurer dans le GROUP BY. Si tu groupes par oscar, la colonne titre n'a pas de valeur unique par groupe — il y a cinq titres dans le groupe oscar=true. PostgreSQL ne sait pas lequel afficher :

SELECT titre, COUNT(*) FROM films GROUP BY oscar → erreur : column "films.titre" must appear in the GROUP BY clause or be used in an aggregate function.

La correction est immédiate : remplacer titre par oscar dans le SELECT. On affiche la colonne sur laquelle on groupe, pas une autre :

La requête
SELECT oscar, COUNT(*) AS nb_films FROM films GROUP BY oscar ORDER BY oscar
La requête corrigée (même résultat que plus haut) · 2 lignes
oscarnb_films
false9
true5

La règle s'applique à toutes les colonnes non-agrégées du SELECT. Si tu voulais afficher à la fois oscar et annee dans le SELECT, les deux devraient figurer dans le GROUP BY : GROUP BY oscar, annee — PostgreSQL créerait un groupe par combinaison de valeurs (oscar=true en 2010, oscar=true en 1972, etc.).

Plusieurs agrégats par groupe

GROUP BY n'est pas limité à COUNT(*). On peut associer AVG, MIN, MAX — ou les combiner dans la même requête. La dimension de groupement reste oscar ; seuls les calculs s'accumulent :

La requête
SELECT oscar, COUNT(*) AS nb_films, ROUND(AVG(note), 1) AS note_moyenne, MIN(annee) AS premiere_sortie, MAX(annee) AS derniere_sortie FROM films GROUP BY oscar ORDER BY oscar
Résultat — 2 lignes · 2 lignes
oscarnb_filmsnote_moyennepremiere_sortiederniere_sortie
false98.019942022
true58.719722019

Les films oscarisés ont une note moyenne plus haute (8.7 contre 8.0) et couvrent une période plus large (1972–2019 contre 1994–2022). La même structure GROUP BY … ORDER BY s'applique quelle que soit la colonne de groupement — les calculs restent identiques, seule la dimension change.

Trier les groupes

ORDER BY fonctionne après GROUP BY — et on peut trier sur le résultat de l'agrégat lui-même, pas seulement sur la colonne de groupement. L'ordre des clauses est toujours : FROM → WHERE → GROUP BY → ORDER BY.

La requête
SELECT oscar, ROUND(AVG(note), 1) AS note_moyenne FROM films GROUP BY oscar ORDER BY note_moyenne DESC
Résultat — du groupe à la note moyenne la plus haute au plus bas · 2 lignes
oscarnote_moyenne
true8.7
false8.0

ORDER BY note_moyenne DESC trie les groupes sur le résultat calculé — les films oscarisés en tête. Sur une table à six groupes ou plus (comme employes GROUP BY dept_id), ce tri révèle immédiatement les groupes dominants sans avoir à parcourir toute la liste. On peut trier sur l'alias (note_moyenne) ou directement sur l'expression AVG(note) — les deux fonctionnent.

Récapitulatif

Ce que tu retiens de cette leçon :

📌 GROUP BY — l'essentiel
GROUP BY colonne→ regroupe les lignes, un calcul par groupe
SELECT col, AGRÉGAT→ la dimension de groupement + le calcul
règle d'or→ toute colonne non-agrégée du SELECT doit être dans le GROUP BY
ORDER BY AGRÉGAT DESC→ trier les groupes sur le résultat du calcul
ordre des clauses→ FROM · WHERE · GROUP BY · ORDER BY
Exemple complet
SELECT oscar,
COUNT(*) AS nb_films,
ROUND(AVG(note), 1) AS note_moyenne
FROM films
GROUP BY oscar
ORDER BY note_moyenne DESC

💡 Bon à savoir : on peut grouper par plusieurs colonnes à la fois — GROUP BY colonne1, colonne2 crée un groupe par combinaison unique de valeurs, utile pour des analyses croisées. La leçon suivante introduit HAVING — le filtre qui s'applique aux groupes après le calcul, là où WHERE ne peut pas aller.

Passe à la pratique

Cette leçon t'a montré la théorie. Pour maîtriser SQL, rien ne vaut la pratique : accède aux exercices et au bac à sable PostgreSQL réel.

← Tous les cours SQL