COUNT, GROUP BY et HAVING

Une fonction d'agrégation (COUNT, SUM, AVG, MIN, MAX) résume plusieurs lignes en une seule valeur : un nombre, une somme, une moyenne. GROUP BY calcule ces agrégats par groupe de lignes, et HAVING filtre les groupes obtenus. Dans une requête SELECT simple, chaque ligne du résultat correspond à une ligne de la table ; avec un agrégat, une ligne du résultat en résume plusieurs. Les exemples portent sur la base d'exemple parc.

COUNT sous toutes ses formes

SELECT COUNT(*)                   AS employes,
       COUNT(telephone)           AS avec_telephone,
       COUNT(DISTINCT id_service) AS services_representes
FROM employe;

Trois employés n'ont pas de téléphone, et le service Juridique n'a personne : 5 services sur 6 sont représentés.

SUM, AVG, MIN, MAX et les NULL

SUM, AVG, MIN et MAX ignorent les NULL. Sur la table logiciel, quatre logiciels ont un nombre de licences, quatre sont libres (NULL) :

SELECT SUM(nb_licences)              AS total,
       AVG(nb_licences)              AS moyenne_sans_null,
       AVG(COALESCE(nb_licences, 0)) AS moyenne_null_a_zero
FROM logiciel;

La première moyenne divise 25 par 4, la seconde par 8. Laquelle est juste ? Celle qui répond à ta question : « nombre moyen de licences des logiciels payants » ou « par logiciel ». Sur une colonne entière, MySQL renvoie la moyenne avec 4 décimales ; utilise ROUND pour l'affichage.

Sur un ensemble vide, COUNT renvoie 0 mais SUM, AVG, MIN et MAX renvoient NULL :

SELECT COUNT(*) AS nb, SUM(duree_min) AS total
FROM intervention
WHERE id_ticket = 7;

Écris COALESCE(SUM(duree_min), 0) si tu veux afficher 0.

MIN et MAX fonctionnent aussi sur les dates et les chaînes : MIN(date_achat) donne la date d'achat la plus ancienne, MAX(nom) le dernier nom dans l'ordre alphabétique. MIN renvoie une valeur, pas la ligne qui la porte : pour savoir quel poste a été acheté à cette date, il faut une sous-requête.

GROUP BY

GROUP BY forme des groupes de lignes qui ont la même valeur, puis calcule les agrégats par groupe. Le résultat contient une ligne par groupe.

SELECT id_technicien,
       COUNT(*)               AS nb_interventions,
       SUM(duree_min)         AS minutes,
       ROUND(AVG(duree_min), 1) AS duree_moyenne
FROM intervention
GROUP BY id_technicien
ORDER BY id_technicien;

On peut regrouper sur plusieurs colonnes : chaque combinaison forme un groupe.

SELECT statut, priorite, COUNT(*) AS nb
FROM ticket
GROUP BY statut, priorite
ORDER BY statut, priorite;

La règle d'or : dans une requête avec GROUP BY, chaque colonne du SELECT est soit dans le GROUP BY, soit à l'intérieur d'une fonction d'agrégation. Sinon, quelle valeur afficher pour un groupe de plusieurs lignes ?

SELECT id_technicien, id_ticket, COUNT(*)
FROM intervention
GROUP BY id_technicien;

ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP BY clause and contains nonaggregated column
'parc.intervention.id_ticket' which is not functionally dependent on columns in GROUP BY clause;
this is incompatible with sql_mode=only_full_group_by

Le technicien 11 a travaillé sur 5 tickets différents : id_ticket n'a pas de valeur unique dans son groupe. Le mode ONLY_FULL_GROUP_BY, actif par défaut depuis MySQL 5.7, refuse la requête. Sans ce mode (vieux serveurs, MariaDB par défaut), MySQL renvoie une valeur prise au hasard dans le groupe, sans erreur.

Le message parle de dépendance fonctionnelle : MySQL 8 accepte une colonne absente du GROUP BY si elle dépend de la clé primaire d'une table regroupée. GROUP BY s.id_service permet donc d'afficher s.libelle, puisqu'un identifiant de service détermine un seul libellé. PostgreSQL accepte la même chose ; SQL Server exige toutes les colonnes dans le GROUP BY.

Différence entre WHERE et HAVING

WHERE filtre les lignes, avant le regroupement. HAVING filtre les groupes, après le calcul des agrégats. Les techniciens qui ont fait plus de 5 interventions :

SELECT id_technicien, COUNT(*) AS nb_interventions
FROM intervention
GROUP BY id_technicien
HAVING COUNT(*) > 5;

Les deux se combinent. Pour le mois d'octobre seulement (WHERE), les techniciens qui cumulent plus de 250 minutes (HAVING) :

SELECT id_technicien, SUM(duree_min) AS minutes_octobre
FROM intervention
WHERE date_intervention >= '2026-10-01' AND date_intervention < '2026-11-01'
GROUP BY id_technicien
HAVING SUM(duree_min) > 250
ORDER BY minutes_octobre DESC;

Chloé Lambert (11) a travaillé 220 minutes en octobre : son groupe existe, mais HAVING l'élimine. MySQL accepte aussi un alias du SELECT dans HAVING (HAVING minutes_octobre > 250) ; c'est une extension, que PostgreSQL et SQL Server refusent. Répéter l'agrégat, comme ici, fonctionne partout.

GROUP_CONCAT et WITH ROLLUP

GROUP_CONCAT assemble les valeurs d'un groupe en une seule chaîne :

SELECT id_service,
       COUNT(*) AS effectif,
       GROUP_CONCAT(nom ORDER BY nom SEPARATOR ', ') AS membres
FROM employe
GROUP BY id_service
ORDER BY id_service;

Sans SEPARATOR, le séparateur est une virgule sans espace. Le résultat est coupé à 1 024 octets par défaut (variable group_concat_max_len), sans erreur : augmente-la pour de longues listes. PostgreSQL et SQL Server écrivent string_agg(nom, ', ').

WITH ROLLUP ajoute des lignes de sous-total et de total général. La colonne regroupée y vaut NULL ; la fonction GROUPING() vaut 1 sur ces lignes, ce qui permet de les étiqueter :

SELECT IF(GROUPING(id_technicien), 'Total', id_technicien) AS technicien,
       SUM(duree_min) AS minutes
FROM intervention
GROUP BY id_technicien WITH ROLLUP;

PostgreSQL et SQL Server écrivent GROUP BY ROLLUP (id_technicien). MariaDB accepte WITH ROLLUP mais ne propose pas GROUPING() : tant que la colonne regroupée ne contient pas de NULL, IFNULL(id_technicien, 'Total') fait l'affaire.

Agrégats conditionnels

Un CASE à l'intérieur d'un agrégat compte ou additionne seulement certaines lignes. C'est la technique du tableau croisé : une ligne par technicien, une colonne par mois.

SELECT id_technicien,
       SUM(CASE WHEN MONTH(date_intervention) = 9  THEN 1 ELSE 0 END) AS septembre,
       SUM(CASE WHEN MONTH(date_intervention) = 10 THEN 1 ELSE 0 END) AS octobre,
       COUNT(*) AS total
FROM intervention
GROUP BY id_technicien
ORDER BY id_technicien;

Le total d'Antoine Mercier (10) dépasse la somme des deux mois : son intervention du 31 août n'est dans aucune colonne. COUNT(CASE WHEN ... THEN 1 END) donne le même résultat, puisque COUNT ignore les NULL produits quand la condition est fausse. MySQL accepte aussi SUM(MONTH(date_intervention) = 9), une comparaison valant 1 ou 0, mais cette écriture n'est pas portable.

Le piège de la moyenne des moyennes

La durée moyenne d'une intervention est de 73,8 minutes (1 255 minutes pour 17 interventions). La moyenne des trois durées moyennes par technicien, elle, vaut 80,3 : (127,5 + 49,2 + 64,3) / 3. Ce n'est pas une erreur de calcul, c'est une autre question. La moyenne des moyennes donne le même poids à chaque technicien, qu'il ait fait 4 ou 7 interventions. Antoine Mercier, peu d'interventions mais longues, pèse autant que Moussa Diallo.

SELECT ROUND(AVG(duree_min), 1) AS moyenne_globale FROM intervention;

Exercices

SELECT marque,
       COUNT(*) AS nb_postes,
       SUM(prix_achat) AS valeur_totale,
       ROUND(AVG(prix_achat)) AS prix_moyen
FROM poste
GROUP BY marque
ORDER BY valeur_totale DESC;

SELECT id_ticket, COUNT(*) AS nb_interventions, SUM(duree_min) AS minutes
FROM intervention
GROUP BY id_ticket
HAVING SUM(duree_min) > 60
ORDER BY minutes DESC;

SELECT id_service, COUNT(*) AS effectif
FROM employe
GROUP BY id_service
HAVING COUNT(*) >= 3
ORDER BY id_service;

SELECT id_service, COUNT(*) AS effectif
FROM employe
WHERE date_embauche < '2024-01-01'
GROUP BY id_service
HAVING COUNT(*) >= 3
ORDER BY id_service;

SELECT COUNT(*) AS total,
       SUM(CASE WHEN priorite = 'basse'    THEN 1 ELSE 0 END) AS basse,
       SUM(CASE WHEN priorite = 'normale'  THEN 1 ELSE 0 END) AS normale,
       SUM(CASE WHEN priorite = 'haute'    THEN 1 ELSE 0 END) AS haute,
       SUM(CASE WHEN priorite = 'critique' THEN 1 ELSE 0 END) AS critique
FROM ticket;

SELECT id_technicien, MAX(date_intervention) AS derniere, id_ticket
FROM intervention
GROUP BY id_technicien;

SELECT i.id_technicien, i.date_intervention AS derniere, i.id_ticket
FROM intervention i
WHERE i.date_intervention = (SELECT MAX(i2.date_intervention)
                             FROM intervention i2
                             WHERE i2.id_technicien = i.id_technicien)
ORDER BY i.id_technicien;