GROUP BY et HAVING en SQL : le guide complet avec exemples

Maîtrisez le regroupement et le filtrage des agrégats en SQL grâce à GROUP BY et HAVING

1. Le principe du GROUP BY

GROUP BY regroupe les lignes qui ont la même valeur dans une ou plusieurs colonnes, et permet d’appliquer un calcul (somme, moyenne, décompte…) sur chaque groupe. Sans GROUP BY, les fonctions d’agrégation s’appliquent à toute la table.

Prenons une table commandes avec des colonnes id, client, produit, montant et date_achat.

Sans GROUP BY — le total global :

SELECT SUM(montant) AS total_global
FROM commandes;

Résultat : une seule ligne avec le total de toutes les commandes.

Avec GROUP BY — le total par client :

SELECT client, SUM(montant) AS total_depenses
FROM commandes
GROUP BY client;

Résultat : une ligne par client, avec le total de ses commandes. C’est la force du GROUP BY : il transforme N lignes en un résumé par groupe. Concrètement, si la table contient 10 000 commandes réparties sur 300 clients, la requête retourne exactement 300 lignes — une par client.

Syntaxe générale :

SELECT colonne_groupe, fonction_agregation(colonne)
FROM table
WHERE conditions_sur_les_lignes
GROUP BY colonne_groupe
HAVING conditions_sur_les_groupes
ORDER BY colonne;

Pour approfondir les bases du langage SQL avant d’aborder GROUP BY, consultez notre cours SQL complet pour débutants. Si vous travaillez spécifiquement avec MySQL, notre cours MySQL couvre les spécificités de ce SGBD.

2. Les fonctions d’agrégation

Les fonctions d’agrégation calculent une valeur unique à partir d’un ensemble de lignes. Elles sont presque toujours utilisées avec GROUP BY.

Combiner plusieurs fonctions d’agrégation dans une même requête :

-- Statistiques complètes par catégorie de produit
SELECT 
    categorie,
    COUNT(*)            AS nb_produits,
    MIN(prix)           AS prix_min,
    MAX(prix)           AS prix_max,
    AVG(prix)           AS prix_moyen,
    SUM(stock)          AS stock_total
FROM produits
GROUP BY categorie
ORDER BY nb_produits DESC;

3. Exemples concrets de GROUP BY

Compter le nombre de commandes par client :

SELECT client, COUNT(*) AS nb_commandes
FROM commandes
GROUP BY client;

Calculer le chiffre d’affaires par produit :

SELECT produit, SUM(montant) AS ca_total
FROM commandes
GROUP BY produit
ORDER BY ca_total DESC;

Trouver la commande la plus chère par client :

SELECT client, MAX(montant) AS commande_max
FROM commandes
GROUP BY client;

Calculer la note moyenne par matière :

SELECT matiere, AVG(note) AS moyenne, COUNT(*) AS nb_eleves
FROM notes
GROUP BY matiere
ORDER BY moyenne DESC;

Nombre de produits distincts achetés par client :

SELECT client, COUNT(DISTINCT produit) AS nb_produits_differents
FROM commandes
GROUP BY client;

Répartition des utilisateurs par pays :

-- Utile pour des rapports géographiques
SELECT pays, COUNT(*) AS nb_utilisateurs,
       ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 2) AS pourcentage
FROM utilisateurs
GROUP BY pays
ORDER BY nb_utilisateurs DESC;

4. GROUP BY sur plusieurs colonnes

On peut grouper par plusieurs colonnes pour obtenir des sous-groupes plus fins. Le GROUP BY crée alors un groupe pour chaque combinaison unique de valeurs.

-- Chiffre d'affaires par client ET par produit
SELECT client, produit, SUM(montant) AS total
FROM commandes
GROUP BY client, produit
ORDER BY client, total DESC;

Si on a 3 clients et 4 produits, on aura au maximum 12 groupes (3 × 4), un pour chaque combinaison client/produit effectivement présente dans la table.

Exemple avec une date :

-- Ventes par mois et par catégorie
SELECT 
    YEAR(date_achat) AS annee,
    MONTH(date_achat) AS mois,
    categorie,
    SUM(montant) AS ca
FROM ventes
GROUP BY YEAR(date_achat), MONTH(date_achat), categorie
ORDER BY annee, mois;

Exemple : répartition des commandes par statut et par année :

SELECT 
    YEAR(date_achat) AS annee,
    statut,
    COUNT(*) AS nb_commandes,
    SUM(montant) AS total
FROM commandes
GROUP BY YEAR(date_achat), statut
ORDER BY annee DESC, nb_commandes DESC;

5. HAVING : filtrer après l’agrégation

HAVING filtre les groupes après que GROUP BY a créé les agrégations. C’est l’équivalent du WHERE, mais pour les résultats agrégés.

Clients ayant passé plus de 5 commandes :

SELECT client, COUNT(*) AS nb_commandes
FROM commandes
GROUP BY client
HAVING COUNT(*) > 5;

Produits dont le CA total dépasse 10 000 € :

SELECT produit, SUM(montant) AS ca_total
FROM commandes
GROUP BY produit
HAVING SUM(montant) > 10000
ORDER BY ca_total DESC;

Matières où la moyenne est inférieure à 10 :

SELECT matiere, AVG(note) AS moyenne
FROM notes
GROUP BY matiere
HAVING AVG(note) < 10;

Départements ayant entre 5 et 20 employés avec un salaire moyen > 3000 :

SELECT departement, 
       COUNT(*) AS nb_employes, 
       AVG(salaire) AS salaire_moyen
FROM employes
GROUP BY departement
HAVING COUNT(*) BETWEEN 5 AND 20
  AND AVG(salaire) > 3000;

Clients dont le panier moyen dépasse 150 € et qui ont commandé au moins 3 fois :

SELECT client,
       COUNT(*) AS nb_commandes,
       AVG(montant) AS panier_moyen,
       SUM(montant) AS total
FROM commandes
GROUP BY client
HAVING COUNT(*) >= 3
  AND AVG(montant) > 150
ORDER BY total DESC;

6. WHERE vs HAVING : la différence clé

C'est la question d'entretien SQL la plus fréquente. La différence est simple mais fondamentale :

Exemple combinant WHERE et HAVING :

-- Clients ayant dépensé plus de 500€ en 2024
-- (en excluant les commandes annulées)
SELECT client, SUM(montant) AS total_2024
FROM commandes
WHERE statut != 'annulée'          -- filtre les lignes AVANT le regroupement
  AND YEAR(date_achat) = 2024
GROUP BY client
HAVING SUM(montant) > 500          -- filtre les groupes APRÈS le regroupement
ORDER BY total_2024 DESC;

Le WHERE a exclu les commandes annulées et celles hors 2024 avant le regroupement. Puis le HAVING n'a gardé que les clients dont le total (des commandes restantes) dépasse 500 €.

Autre exemple concret — rapport sur les vendeurs actifs :

-- Vendeurs ayant réalisé plus de 20 ventes de produits "premium"
-- avec un CA mensuel supérieur à 10 000€
SELECT vendeur_id,
       MONTH(date_vente) AS mois,
       COUNT(*) AS nb_ventes,
       SUM(montant) AS ca_mensuel
FROM ventes
WHERE categorie = 'premium'        -- WHERE filtre la catégorie AVANT le GROUP BY
  AND YEAR(date_vente) = 2024
GROUP BY vendeur_id, MONTH(date_vente)
HAVING COUNT(*) > 20               -- HAVING filtre les groupes résultants
  AND SUM(montant) > 10000
ORDER BY ca_mensuel DESC;

7. Ordre d'exécution d'une requête SQL

L'ordre dans lequel vous écrivez les clauses SQL n'est pas l'ordre dans lequel le moteur les exécute. Comprendre cet ordre est essentiel pour maîtriser GROUP BY et HAVING.

Cet ordre d'exécution est directement lié à la façon dont les jointures SQL interagissent avec les agrégations : les jointures (FROM/JOIN) sont résolues en premier, avant tout filtrage.

8. GROUP BY avec des jointures

GROUP BY est souvent combiné avec des jointures pour agréger des données provenant de plusieurs tables.

Nombre de commandes par client (avec le nom du client) :

SELECT c.nom, c.email, COUNT(o.id) AS nb_commandes
FROM clients c
LEFT JOIN commandes o ON c.id = o.client_id
GROUP BY c.id, c.nom, c.email
ORDER BY nb_commandes DESC;

On utilise LEFT JOIN pour inclure les clients qui n'ont passé aucune commande (ils auront nb_commandes = 0).

Chiffre d'affaires par catégorie de produit :

SELECT cat.nom AS categorie,
       COUNT(DISTINCT o.id) AS nb_commandes,
       SUM(li.quantite * li.prix_unitaire) AS ca_total
FROM categories cat
JOIN produits p ON cat.id = p.categorie_id
JOIN lignes_commande li ON p.id = li.produit_id
JOIN commandes o ON li.commande_id = o.id
WHERE o.statut = 'livree'
GROUP BY cat.id, cat.nom
HAVING SUM(li.quantite * li.prix_unitaire) > 5000
ORDER BY ca_total DESC;

Moyenne des notes par élève avec le nom de l'élève :

SELECT e.nom, e.prenom,
       COUNT(n.id) AS nb_notes,
       AVG(n.valeur) AS moyenne_generale,
       MIN(n.valeur) AS note_min,
       MAX(n.valeur) AS note_max
FROM eleves e
LEFT JOIN notes n ON e.id = n.eleve_id
GROUP BY e.id, e.nom, e.prenom
HAVING COUNT(n.id) > 0
ORDER BY moyenne_generale DESC;

9. GROUP BY ROLLUP et CUBE

Au-delà du GROUP BY classique, SQL propose des extensions pour générer des sous-totaux et totaux automatiques : ROLLUP et CUBE. Ces extensions sont disponibles en MySQL, PostgreSQL et la plupart des SGBD modernes.

ROLLUP : sous-totaux hiérarchiques

ROLLUP génère des sous-totaux pour chaque niveau de la hiérarchie, plus un total général.

-- CA par pays, puis par ville, avec sous-totaux par pays et total général
SELECT 
    pays,
    ville,
    SUM(montant) AS ca
FROM ventes
GROUP BY ROLLUP(pays, ville)
ORDER BY pays, ville;

Résultat : on obtient les CA par ville, puis une ligne de sous-total par pays (ville = NULL), puis une ligne de total général (pays = NULL et ville = NULL).

CUBE : toutes les combinaisons de sous-totaux

-- CUBE génère des sous-totaux pour TOUTES les combinaisons de colonnes
SELECT 
    annee,
    trimestre,
    region,
    SUM(ca) AS total_ca
FROM ventes
GROUP BY CUBE(annee, trimestre, region);

CUBE est utile pour les rapports multidimensionnels (tableaux croisés dynamiques en SQL). Avec 3 colonnes, il génère 2³ = 8 niveaux d'agrégation différents.

SELECT 
    CASE WHEN GROUPING(pays) = 1 THEN 'TOTAL GÉNÉRAL' ELSE pays END AS pays,
    CASE WHEN GROUPING(ville) = 1 THEN 'Sous-total' ELSE ville END AS ville,
    SUM(montant) AS ca
FROM ventes
GROUP BY ROLLUP(pays, ville);

10. Pièges courants et bonnes pratiques

❌ Piège 1 : colonnes manquantes dans le GROUP BY

-- ❌ ERREUR en PostgreSQL (correct en MySQL mode permissif)
SELECT client, email, COUNT(*)
FROM commandes
GROUP BY client;
-- email n'est pas dans GROUP BY ni dans une fonction d'agrégation

-- ✅ Correct
SELECT client, email, COUNT(*)
FROM commandes
GROUP BY client, email;

❌ Piège 2 : COUNT(*) vs COUNT(colonne)

-- COUNT(*) compte TOUTES les lignes (y compris celles avec NULL)
-- COUNT(email) compte uniquement les lignes où email n'est PAS NULL

SELECT 
    COUNT(*) AS total_lignes,
    COUNT(email) AS avec_email,
    COUNT(*) - COUNT(email) AS sans_email
FROM utilisateurs;

❌ Piège 3 : WHERE avec une fonction d'agrégation

-- ❌ ERREUR : les fonctions d'agrégation ne sont pas autorisées dans WHERE
SELECT client, SUM(montant)
FROM commandes
WHERE SUM(montant) > 1000
GROUP BY client;

-- ✅ Correct : utiliser HAVING
SELECT client, SUM(montant) AS total
FROM commandes
GROUP BY client
HAVING SUM(montant) > 1000;

❌ Piège 4 : GROUP BY avec JOIN multiplie les lignes

-- ❌ COUNT(*) est faussé si le JOIN crée des doublons
SELECT u.nom, COUNT(*) AS nb_commandes
FROM utilisateurs u
JOIN adresses a ON u.id = a.user_id    -- 2 adresses → double les lignes
JOIN commandes c ON u.id = c.user_id
GROUP BY u.id, u.nom;

-- ✅ Utiliser COUNT(DISTINCT)
SELECT u.nom, COUNT(DISTINCT c.id) AS nb_commandes
FROM utilisateurs u
JOIN adresses a ON u.id = a.user_id
JOIN commandes c ON u.id = c.user_id
GROUP BY u.id, u.nom;

❌ Piège 5 : AVG sur une colonne avec des NULL

-- Si la colonne "bonus" contient NULL pour 30% des employés,
-- AVG(bonus) calcule la moyenne sur 70% des employés seulement.
-- Pour inclure les NULL comme des 0 :
SELECT departement,
       AVG(COALESCE(bonus, 0)) AS bonus_moyen_reel
FROM employes
GROUP BY departement;

11. Questions fréquentes (FAQ)

-- Ces deux requêtes donnent le même résultat :
SELECT DISTINCT pays FROM clients;
SELECT pays FROM clients GROUP BY pays;

-- GROUP BY : une ligne par département
SELECT departement, AVG(salaire) FROM employes GROUP BY departement;

-- PARTITION BY : une ligne par employé avec la moyenne du département
SELECT nom, salaire, departement,
       AVG(salaire) OVER (PARTITION BY departement) AS moy_dept
FROM employes;

SELECT client, SUM(montant) AS total
FROM commandes
GROUP BY client
ORDER BY total DESC
LIMIT 10 OFFSET 10;  -- page 2

-- Top 3 clients par CA en utilisant une sous-requête
SELECT *
FROM (
    SELECT client, SUM(montant) AS total
    FROM commandes
    GROUP BY client
) AS ca_clients
WHERE total > 1000
ORDER BY total DESC
LIMIT 3;

SELECT COALESCE(region, 'Non définie') AS region,
       COUNT(*) AS nb_clients
FROM clients
GROUP BY COALESCE(region, 'Non définie');

12. Quiz

SELECT departement, COUNT(*) AS nb, AVG(salaire) AS moy
FROM employes
GROUP BY departement
HAVING COUNT(*) > 10 AND AVG(salaire) > 4000;

SELECT produit, COUNT(DISTINCT client_id) AS nb_clients
FROM commandes
GROUP BY produit
HAVING COUNT(DISTINCT client_id) >= 3
ORDER BY nb_clients DESC;