SIG DCG (UE8) : Bases de données, SQL et processus

Cette fiche fait partie du pack DCG UE8 · Systèmes d'information de gestion

Quiz, textes à trous et flashcards sur ce chapitre et les 33 autres, avec un tuteur IA. Paiement unique, 29 €.

Voir le pack

Défie tes amis

10 questions sur toute la matière. Tu joues d'abord, puis tu envoies le lien à qui tu veux.

SQL : fonctions d'agrégation, regroupements et restriction sur les groupes

À retenir

Cadre programme : DCG, programme 2025 (arrêté du 4 août 2025, première session 2027), UE 8 « Systèmes d'information de gestion », partie 2 « Gérer des données du système d'information », sous-partie 2.1 « Structurer et manipuler des données via les bases de données », rubrique 2.1.2 « Manipuler des données d'une base de données ».

Pourquoi c'est central à l'examen : le contrôle de gestion et la comptabilité raisonnent en totaux, en moyennes et en classements (chiffre d'affaires par client, nombre de commandes par mois). Les clauses GROUP BY et HAVING figurent dans la liste officielle des instructions SQL du programme ; elles sont l'occasion d'erreurs de raisonnement classiques que l'épreuve sait exploiter.

01Les fonctions d'agrégation

Une fonction d'agrégation résume plusieurs lignes en une seule valeur.

FonctionRésultatRemarque
COUNT(*)Nombre de lignesCompte aussi les lignes pleines de NULL
COUNT(colonne)Nombre de valeurs non nulles de la colonneIgnore les NULL
COUNT(DISTINCT colonne)Nombre de valeurs différentes non nulles
SUM(expression)SommeIgnore les NULL ; renvoie NULL si aucune valeur
AVG(expression)MoyenneCalculée sur les valeurs non nulles seulement
MIN(expression), MAX(expression)Plus petite, plus grande valeurValable sur nombres, textes, dates

Tous les exemples utilisent la base du fil rouge.

À retenir

CATEGORIE (CodeCat, LibCat)

PRODUIT (RefProduit, Designation, PrixHT, Stock, #CodeCat)

CLIENT (NumClient, NomClient, Ville, Courriel)

COMMANDE (NumCommande, DateCommande, #NumClient)

LIGNE_COMMANDE (#NumCommande, #RefProduit, Quantite)

SELECT COUNT(*) AS NbClients,
       COUNT(Courriel) AS NbCourriels,
       COUNT(DISTINCT Ville) AS NbVilles
FROM CLIENT;
NbClientsNbCourrielsNbVilles
755

Sept clients, mais seulement cinq courriels (deux sont NULL) et cinq villes différentes. COUNT(*) et COUNT(Courriel) ne comptent donc pas la même chose.

SELECT SUM(Stock * PrixHT) AS ValeurStock,
       MIN(PrixHT) AS PrixMini,
       MAX(PrixHT) AS PrixMaxi
FROM PRODUIT;
ValeurStockPrixMiniPrixMaxi
60403150
SELECT AVG(PrixHT) AS PrixMoyenInformatique
FROM PRODUIT
WHERE CodeCat = 'INF';
PrixMoyenInformatique
18.50

Sans GROUP BY, une requête qui contient une fonction d'agrégation renvoie une seule ligne pour l'ensemble des lignes retenues par WHERE. Elle ne peut alors contenir aucune colonne isolée : mélanger SELECT Designation, MAX(PrixHT) n'a pas de sens, et la norme l'interdit (certains systèmes l'acceptent et renvoient une ligne arbitraire, ce qui est faux).

1.1 L'agrégat d'un ensemble vide

La somme d'un ensemble vide est NULL, pas zéro. Le produit P08 n'a jamais été commandé :

SELECT SUM(Quantite) AS QteVendue,
       COALESCE(SUM(Quantite), 0) AS QteVendueOuZero
FROM LIGNE_COMMANDE
WHERE RefProduit = 'P08';
QteVendueQteVendueOuZero
NULL0

COALESCE (cours 15) remplace le NULL par zéro quand on veut afficher ou réutiliser un nombre. COUNT(*), lui, renvoie 0 pour un ensemble vide.

02Les regroupements : GROUP BY

2.1 Principe

GROUP BY partage les lignes en groupes de valeurs identiques sur une ou plusieurs colonnes, puis calcule les fonctions d'agrégation groupe par groupe. Le résultat contient une ligne par groupe.

SELECT NumClient, COUNT(*) AS NbCommandes
FROM COMMANDE
GROUP BY NumClient
ORDER BY NumClient;
NumClientNbCommandes
13
21
31
42
61

La table COMMANDE est partagée en cinq groupes (un par client ayant commandé), et COUNT(*) compte les lignes de chaque groupe. Les clients sans commande ne figurent pas : ils n'ont aucune ligne à regrouper.

2.2 La règle du SELECT

Dans une requête avec GROUP BY, la clause SELECT ne peut contenir que :

  1. des colonnes qui figurent dans le GROUP BY ;
  2. des fonctions d'agrégation ;
  3. des constantes.

Toute autre colonne n'a pas de valeur unique pour un groupe : la requête est incorrecte.

2.3 Regrouper sur un résultat de jointure

Le chiffre d'affaires par client demande de rapprocher quatre tables, puis de regrouper.

SELECT CL.NumClient, CL.NomClient,
       SUM(L.Quantite * P.PrixHT) AS CA
FROM CLIENT CL
     INNER JOIN COMMANDE C ON C.NumClient = CL.NumClient
     INNER JOIN LIGNE_COMMANDE L ON L.NumCommande = C.NumCommande
     INNER JOIN PRODUIT P ON P.RefProduit = L.RefProduit
GROUP BY CL.NumClient, CL.NomClient
ORDER BY CA DESC;
NumClientNomClientCA
4Mairie de Tours980.00
6Lycée Michelet555.00
1Boulangerie Lemoine322.50
3Garage Perrin50.00
2Cabinet Aubert37.00

On a regroupé sur NumClient et NomClient : NomClient est dans le SELECT, il doit donc figurer dans le GROUP BY. Le nom ne change pas à l'intérieur d'un groupe, cela ne modifie pas les groupes.

2.4 Regrouper sur plusieurs colonnes

Chaque combinaison de valeurs forme un groupe. L'expression qui calcule le mois doit être répétée dans GROUP BY : on ne peut pas y utiliser un alias défini dans SELECT. Au sens strict, la norme SQL-92 n'admet dans GROUP BY que des colonnes ; le regroupement sur une expression comme EXTRACT est accepté par tous les SGBDR et relève des versions ultérieures de la norme.

SELECT P.CodeCat, EXTRACT(MONTH FROM C.DateCommande) AS Mois,
       SUM(L.Quantite) AS QuantiteVendue
FROM COMMANDE C
     INNER JOIN LIGNE_COMMANDE L ON L.NumCommande = C.NumCommande
     INNER JOIN PRODUIT P ON P.RefProduit = L.RefProduit
GROUP BY P.CodeCat, EXTRACT(MONTH FROM C.DateCommande)
ORDER BY P.CodeCat, Mois;
CodeCatMoisQuantiteVendue
INF12
INF27
INF33
MOB26
MOB39
PAP130
PAP210
PAP375

2.5 Compter les absents : COUNT d'une colonne de la table de droite

Pour obtenir le nombre de commandes de tous les clients, y compris ceux qui n'en ont aucune, il faut une jointure externe (cours 16), et compter une colonne de la table de droite, pas COUNT(*).

SELECT CL.NumClient, CL.NomClient, COUNT(C.NumCommande) AS NbCommandes
FROM CLIENT CL LEFT JOIN COMMANDE C ON C.NumClient = CL.NumClient
GROUP BY CL.NumClient, CL.NomClient
ORDER BY CL.NumClient;
NumClientNomClientNbCommandes
1Boulangerie Lemoine3
2Cabinet Aubert1
3Garage Perrin1
4Mairie de Tours2
5Atelier Duval0
6Lycée Michelet1
7Pharmacie Roux0

Les clients 5 et 7 apparaissent avec 0 commande : COUNT(C.NumCommande) ignore les NULL de la jointure externe. Avec COUNT(*), ces deux clients afficheraient 1, car la ligne unique produite par la jointure existe bien même si elle est vide.

SELECT CL.NumClient, COUNT(*) AS NbLignes
FROM CLIENT CL LEFT JOIN COMMANDE C ON C.NumClient = CL.NumClient
WHERE CL.NumClient IN (5, 7)
GROUP BY CL.NumClient
ORDER BY CL.NumClient;
NumClientNbLignes
51
71

Teste-toi sur ce chapitre

3 questions gratuites tirées du pack DCG UE8 · Systèmes d'information de gestion

Question 1 / 3
1
Choisis ta réponse

03La restriction sur les groupes : HAVING

3.1 WHERE contre HAVING

WHEREHAVING
Porte surLes lignesLes groupes
MomentAvant le regroupementAprès le regroupement et le calcul des agrégats
Peut contenir une fonction d'agrégationNonOui
SELECT NumClient, COUNT(*) AS NbCommandes
FROM COMMANDE
WHERE COUNT(*) >= 2
GROUP BY NumClient;

Cette requête est refusée : au moment de WHERE, les groupes n'existent pas encore. La bonne écriture est :

SELECT NumClient, COUNT(*) AS NbCommandes
FROM COMMANDE
GROUP BY NumClient
HAVING COUNT(*) >= 2
ORDER BY NumClient;
NumClientNbCommandes
13
42

3.2 WHERE et HAVING ensemble

On veut les clients dont le chiffre d'affaires, calculé sur les commandes de février et mars seulement, dépasse 300 € HT. La restriction de dates porte sur les lignes (WHERE), la restriction de chiffre d'affaires sur les groupes (HAVING).

SELECT CL.NomClient, SUM(L.Quantite * P.PrixHT) AS CA
FROM CLIENT CL
     INNER JOIN COMMANDE C ON C.NumClient = CL.NumClient
     INNER JOIN LIGNE_COMMANDE L ON L.NumCommande = C.NumCommande
     INNER JOIN PRODUIT P ON P.RefProduit = L.RefProduit
WHERE C.DateCommande BETWEEN DATE '2026-02-01' AND DATE '2026-03-31'
GROUP BY CL.NumClient, CL.NomClient
HAVING SUM(L.Quantite * P.PrixHT) > 300
ORDER BY CA DESC;
NomClientCA
Mairie de Tours980
Lycée Michelet555

La Boulangerie Lemoine, qui dépasse 300 € sur l'ensemble de l'année, n'y figure plus : sa première commande, de janvier, est écartée avant le regroupement.

04L'ordre logique d'exécution

Une requête s'écrit dans un ordre, mais le SGBDR l'évalue dans un autre. Comprendre cet ordre explique la plupart des règles ci-dessus.

Ordre d'exécutionClauseRôle
1FROM et jointuresConstruire l'ensemble de lignes de départ
2WHEREÉliminer des lignes
3GROUP BYFormer les groupes
4HAVINGÉliminer des groupes
5SELECTCalculer les colonnes et les agrégats, donner les alias
6ORDER BYTrier le résultat

Conséquences : WHERE ne connaît ni les agrégats ni les alias de SELECT ; HAVING ne connaît pas les alias non plus (on y répète l'expression) ; ORDER BY, évalué en dernier, peut utiliser les alias.

05Méthode pour une requête de synthèse

  1. Identifier la maille : « par client », « par mois et par catégorie » : ce sont les colonnes du GROUP BY.
  2. Identifier l'agrégat : un nombre (COUNT), un total (SUM), une moyenne (AVG), un extrême (MIN, MAX).
  3. Construire le FROM avec les jointures nécessaires.
  4. Séparer les conditions : celles sur les lignes vont dans WHERE, celles sur un agrégat dans HAVING.
  5. Vérifier le SELECT : colonnes du GROUP BY et agrégats uniquement.
  6. Choisir le tri : sur une colonne, un alias ou un agrégat.

Exemples corrigés

Cas 1 : un tableau de bord clients pour la direction commerciale

Énoncé. Pour chaque client ayant commandé, la direction veut le nombre de commandes, le chiffre d'affaires HT et le panier moyen (chiffre d'affaires divisé par le nombre de commandes), du plus gros chiffre d'affaires au plus petit, en ne conservant que les clients dont le chiffre d'affaires dépasse 100 € HT. Conclure par une recommandation.

Corrigé. La maille est le client. Les colonnes viennent de quatre tables. Le nombre de commandes se compte par COUNT(DISTINCT C.NumCommande), car après jointure avec LIGNE_COMMANDE une commande occupe plusieurs lignes : COUNT(*) compterait les lignes de commande, pas les commandes. Le seuil de 100 € porte sur un agrégat : HAVING.

SELECT CL.NomClient,
       COUNT(DISTINCT C.NumCommande) AS NbCommandes,
       SUM(L.Quantite * P.PrixHT) AS CA,
       SUM(L.Quantite * P.PrixHT) / COUNT(DISTINCT C.NumCommande) AS PanierMoyen
FROM CLIENT CL
     INNER JOIN COMMANDE C ON C.NumClient = CL.NumClient
     INNER JOIN LIGNE_COMMANDE L ON L.NumCommande = C.NumCommande
     INNER JOIN PRODUIT P ON P.RefProduit = L.RefProduit
GROUP BY CL.NumClient, CL.NomClient
HAVING SUM(L.Quantite * P.PrixHT) > 100
ORDER BY CA DESC;
NomClientNbCommandesCAPanierMoyen
Mairie de Tours2980.00490.00
Lycée Michelet1555.00555.00
Boulangerie Lemoine3322.50107.50

Le chiffre d'affaires total de ces clients est de 1857.5 € HT sur 1944.5 € HT pour l'ensemble de l'entreprise.

Recommandation.

À retenir

Trois clients, la Mairie de Tours, le Lycée Michelet et la Boulangerie Lemoine, réalisent plus de 95 % du chiffre d'affaires (1 857,50 € sur 1 944,50 €). La mairie est le premier client en chiffre d'affaires (980 €) ; le panier moyen le plus élevé est celui du lycée (555 €, une seule commande), contre 490 € pour la mairie et 107,50 € pour la boulangerie. Sans données de coûts, on ne peut rien dire de la rentabilité de ces clients. Cette concentration est un risque autant qu'une force : la perte d'un seul de ces comptes coûterait plus que l'ensemble des clients écartés par le seuil (cabinet Aubert, garage Perrin). Je recommande un suivi commercial prioritaire de ces trois comptes et, pour les clients à faible panier, une offre de regroupement de commandes.

Cas 2 : le chiffre d'affaires par catégorie et par mois

Énoncé. La direction veut le chiffre d'affaires hors taxes par catégorie de produit (libellé de la catégorie) et par mois, avec le total par ligne, trié par catégorie puis par mois. Elle s'intéresse ensuite uniquement aux couples dont le chiffre d'affaires dépasse 200 €.

Corrigé. La maille est le couple (catégorie, mois). Le libellé vient de CATEGORIE, le mois de COMMANDE, le prix de PRODUIT, la quantité de LIGNE_COMMANDE.

SELECT CAT.LibCat, EXTRACT(MONTH FROM C.DateCommande) AS Mois,
       SUM(L.Quantite * P.PrixHT) AS CA
FROM CATEGORIE CAT
     INNER JOIN PRODUIT P ON P.CodeCat = CAT.CodeCat
     INNER JOIN LIGNE_COMMANDE L ON L.RefProduit = P.RefProduit
     INNER JOIN COMMANDE C ON C.NumCommande = L.NumCommande
GROUP BY CAT.LibCat, EXTRACT(MONTH FROM C.DateCommande)
ORDER BY CAT.LibCat, Mois;
LibCatMoisCA
Informatique150.00
Informatique297.00
Informatique375.00
Mobilier2660.00
Mobilier3590.00
Papeterie1120.00
Papeterie245.00
Papeterie3307.50

Pour ne garder que les couples au-dessus de 200 €, on ajoute HAVING en répétant l'expression de l'agrégat :

SELECT CAT.LibCat, EXTRACT(MONTH FROM C.DateCommande) AS Mois,
       SUM(L.Quantite * P.PrixHT) AS CA
FROM CATEGORIE CAT
     INNER JOIN PRODUIT P ON P.CodeCat = CAT.CodeCat
     INNER JOIN LIGNE_COMMANDE L ON L.RefProduit = P.RefProduit
     INNER JOIN COMMANDE C ON C.NumCommande = L.NumCommande
GROUP BY CAT.LibCat, EXTRACT(MONTH FROM C.DateCommande)
HAVING SUM(L.Quantite * P.PrixHT) > 200
ORDER BY CAT.LibCat, Mois;
LibCatMoisCA
Mobilier2660.00
Mobilier3590.00
Papeterie3307.50

Note à la direction.

À retenir

Le mobilier réalise 660 € HT en février et 590 € HT en mars, et rien en janvier : son chiffre d'affaires dépend d'un petit nombre de grosses commandes (la mairie en février, le lycée et la mairie en mars). La papeterie, régulière mais faible, dépasse 200 € uniquement en mars grâce à la commande du lycée, et l'informatique n'atteint jamais ce seuil. Le profil repose sur très peu de clients : avant de bâtir un plan de stock sur ces chiffres, il faut les confirmer sur un historique plus long.

Vocabulaire essentiel

TermeDéfinition
Fonction d'agrégationFonction qui résume plusieurs lignes en une valeur (COUNT, SUM, AVG, MIN, MAX)
RegroupementPartage des lignes en groupes de valeurs identiques (GROUP BY)
Restriction sur les groupesÉlimination de groupes selon un agrégat (HAVING)
MailleNiveau auquel on agrège (par client, par mois)
Panier moyenChiffre d'affaires divisé par le nombre de commandes
COUNT(DISTINCT x)Nombre de valeurs distinctes non nulles de x

Points clés à retenir

  1. Une fonction d'agrégation renvoie une valeur pour un ensemble de lignes ; COUNT(*) compte les lignes, COUNT(col) les valeurs non nulles.
  2. GROUP BY crée une ligne par groupe ; le SELECT ne contient que des colonnes du GROUP BY et des agrégats.
  3. WHERE filtre avant le regroupement et ne contient pas d'agrégat ; HAVING filtre après et en contient.
  4. L'ordre d'exécution est FROM, WHERE, GROUP BY, HAVING, SELECT, ORDER BY.
  5. Les alias de SELECT ne sont utilisables que dans ORDER BY.
  6. Pour compter des absents, jointure externe et COUNT d'une colonne de la table de droite.
  7. La somme d'un ensemble vide est NULL : COALESCE pour obtenir zéro.
  8. Après une jointure, une commande occupe autant de lignes que de lignes de commande : COUNT(DISTINCT ...) pour compter les commandes.

Pièges fréquents

  1. Mettre un agrégat dans WHERE : la requête est refusée ; c'est HAVING.
  2. Oublier une colonne du SELECT dans le GROUP BY.
  3. Utiliser COUNT(*) après une jointure externe pour compter les absents : on obtient 1 au lieu de 0.
  4. Compter des commandes avec COUNT(*) après avoir joint les lignes de commande : on compte les lignes.
  5. Mettre une condition de ligne dans HAVING : elle marche parfois, mais elle filtre trop tard et coûte cher ; la placer dans WHERE.
  6. Utiliser un alias dans GROUP BY ou HAVING : répéter l'expression.
  7. Croire que AVG divise par le nombre de lignes : elle divise par le nombre de valeurs non nulles.
  8. Oublier que SUM d'un ensemble vide vaut NULL et non zéro.

Q&R pour le tuteur IA

Q : Quelle différence entre WHERE et HAVING ? R : WHERE filtre les lignes avant le regroupement et ne peut pas contenir de fonction d'agrégation. HAVING filtre les groupes après le calcul des agrégats et peut en contenir.

Q : Quelle différence entre COUNT(*) et COUNT(colonne) ? R : COUNT(*) compte toutes les lignes ; COUNT(colonne) ne compte que celles où la colonne n'est pas NULL.

Q : Que peut contenir le SELECT d'une requête avec GROUP BY ? R : Uniquement des colonnes figurant dans le GROUP BY et des fonctions d'agrégation. Toute autre colonne n'a pas de valeur unique pour un groupe.

Q : Comment obtenir le nombre de commandes de chaque client, y compris ceux qui n'en ont pas ? R : Par un LEFT JOIN de CLIENT vers COMMANDE, puis COUNT(C.NumCommande) avec GROUP BY sur le client : le compte d'une colonne de la table de droite vaut 0 pour les clients sans commande.

Q : Pourquoi ne peut-on pas utiliser un alias de SELECT dans le WHERE ? R : Parce que WHERE est évalué avant SELECT : l'alias n'existe pas encore. Il faut répéter l'expression ; seul ORDER BY, évalué en dernier, accepte les alias.

Q : Comment calculer un panier moyen ? R : En divisant le chiffre d'affaires par le nombre de commandes distinctes : SUM(L.Quantite * P.PrixHT) / COUNT(DISTINCT C.NumCommande), regroupé par client.

Tu as lu le cours. Passe maintenant à la pratique :

SIG DCG (UE8) : Bases de données, SQL et processus

Ajoute gratuitement le Kit à ton espace, puis utilise tes jetons pour générer un quiz, créer des flashcards ou poser tes questions au Tuteur IA.

DCG UE8 · Systèmes d'information de gestion · 29 €

Voir le pack