SQL Server

Fonctions d’agrégation dans SQL Server : COUNT, SUM, AVG, MIN et MAX

Apprenez à résumer les lignes de SQL Server avec COUNT, SUM, AVG, MIN et MAX sur Customers et Orders.

Par JaviPublié 12 min de lectureDébutant

Jusqu’ici, les requêtes de SQL Server Foundations renvoyaient des lignes de clients ou de commandes. D’autres questions demandent un résumé : combien de commandes existe-t-il, quel est leur montant total, ou quelle est la plus élevée ? Une fonction d’agrégation lit plusieurs lignes et les résume en une valeur. Cette leçon utilise les dix clients et les huit commandes de JaviBuildsLab, puis prépare le regroupement de la leçon suivante. Consultez la leçon sur NULL pour compter les champs facultatifs et WHERE pour choisir les lignes qui alimentent un résumé.

Compter les lignes et les valeurs connues

COUNT(*) compte les lignes en entrée :

Requête SQL: Compter les lignes et les valeurs connuesT-SQL
SELECT COUNT(*) AS CustomerCount
FROM dbo.Customers;
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

La table de démonstration contient dix clients : le résultat est 10. L’astérisque signifie que l’on compte les lignes, même si une colonne de certaines lignes contient NULL. Il ne s’agit pas de compter chaque cellule.

COUNT(colonne) compte uniquement les valeurs qui ne sont pas NULL :

Requête SQL: Compter les lignes et les valeurs connues (2)T-SQL
SELECT COUNT(Email) AS CustomersWithEmail
FROM dbo.Customers;
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le résultat est 9, car l’adresse d’Isla est NULL. Comme l’explique la leçon sur NULL, une valeur absente est différente d’une chaîne vide. COUNT(*) répond à « combien de lignes client ? », tandis que COUNT(Email) répond à « combien ont une adresse connue ? ». COUNT renvoie un nombre entier.

  1. dbo.Orders : 8 lignes
  2. COUNT(*) / SUM / AVG / MIN / MAX
  3. Une ligne de synthèse
Les agrégats transforment plusieurs lignes en une valeur récapitulative

Additionner et calculer une moyenne

SUM additionne les valeurs numériques non NULL. Amount est une colonne décimale :

Requête SQL: Additionner et calculer une moyenneT-SQL
SELECT SUM(Amount) AS TotalSales
FROM dbo.Orders;
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Les sept montants connus sont 125.50, 49.99, 310.00, 82.75, 199.00, 25.00 et 75.00. Leur somme est 867.24. Il s’agit du total des lignes sélectionnées, et non d’un montant identique pour chaque commande.

AVG calcule la moyenne arithmétique : il additionne les valeurs non NULL et divise par leur nombre. Ici, les sept montants sont renseignés ; la moyenne est 867.24 divisé par 7, soit environ 123.8914. SQL Server renvoie un résultat numérique décimal pour cette entrée décimale. La grille peut afficher plusieurs décimales : ne supposez pas qu’il s’agit d’un montant arrondi à deux décimales. Si un rapport exige une échelle d’affichage précise, définissez explicitement l’arrondi ou la conversion. Les données stockées ne changent pas.

Requête SQL: Additionner et calculer une moyenne (2)T-SQL
SELECT AVG(Amount) AS AverageOrderValue
FROM dbo.Orders;
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Une moyenne décrit l’ensemble sélectionné. Quelques valeurs élevées peuvent la faire augmenter. Vérifiez toujours quelles lignes contribuent au calcul. Une moyenne n’est ni une médiane, ni une garantie que chaque commande a ce montant.

Trouver les valeurs minimales et maximales

MIN renvoie la plus petite valeur non NULL et MAX la plus grande. Ces fonctions s’appliquent aussi aux dates :

Requête SQL: Trouver les valeurs minimales et maximalesT-SQL
SELECT
    MIN(OrderDate) AS FirstOrderDate,
    MAX(OrderDate) AS LatestOrderDate
FROM dbo.Orders;
T-SQL4 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Dans le jeu de données, la première commande date du 2025-02-01 et la plus récente du 2025-07-04. Sur une colonne numérique, les mêmes fonctions trouvent le montant minimum et maximum. Elles renvoient la valeur, pas la ligne complète qui la contient ; sélectionnez une clé séparément si vous avez besoin de la commande.

Plusieurs agrégats peuvent apparaître dans une requête :

Requête SQL: Trouver les valeurs minimales et maximales (2)T-SQL
SELECT
    COUNT(*) AS OrderCount,
    SUM(Amount) AS TotalSales,
    AVG(Amount) AS AverageOrderValue,
    MIN(Amount) AS SmallestOrder,
    MAX(Amount) AS LargestOrder
FROM dbo.Orders;
T-SQL7 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le résultat comporte une ligne : 8 commandes, un total de 867.24, une moyenne d’environ 123.8914, un minimum de 25.00 et un maximum de 310.00. Sans GROUP BY, SQL Server résume tout le jeu d’entrée en un seul ensemble. Cette ligne n’est pas une liste détaillée des commandes.

Filtrer les lignes avant le calcul

Les agrégats résument les lignes restantes après FROM et WHERE. Pour compter et additionner les commandes terminées :

Requête SQL: Filtrer les lignes avant le calculT-SQL
SELECT
    COUNT(*) AS CompletedOrders,
    SUM(Amount) AS CompletedSales
FROM dbo.Orders
WHERE Status = N'Complete';
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Dans le jeu de démonstration, la valeur réelle est Complete (au singulier). Quatre lignes correspondent, pour un total de 449.49. WHERE élimine d’abord les autres lignes ; seules les commandes retenues sont comptées et additionnées. C’est le filtrage vu dans la leçon WHERE. GROUP BY calculera ensuite des synthèses distinctes par statut ou par client.

NULL et DISTINCT

COUNT(*) compte les lignes même si certaines colonnes sont NULL. COUNT(colonne) ignore les valeurs NULL de cette colonne. SUM, AVG, MIN et MAX ignorent également leurs entrées NULL. Si un groupe ne contient aucune valeur non NULL, ces agrégats renvoient NULL. Si aucune ligne ne correspond à la requête, COUNT(*) renvoie 0 et les quatre autres fonctions renvoient NULL. Dans le jeu actuel, Amount accepte NULL et une commande n’a pas de montant connu ; OrderDate est NOT NULL. Les exemples ci-dessous montrent comment les agrégats traitent cette ligne.

DISTINCT permet à COUNT de compter les valeurs uniques non NULL :

Requête SQL: NULL et DISTINCTT-SQL
SELECT COUNT(DISTINCT CustomerId) AS CustomersWithOrders
FROM dbo.Orders;
T-SQL2 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le résultat est 4 : les clients 1, 2, 4 et 7 ont passé des commandes. DISTINCT s’applique aux valeurs comptées ; la table n’est pas modifiée. Utilisez-le pour répondre à une question sur les clients uniques, et non pour masquer des lignes inattendues.

Choisir la fonction adaptée à la question

Commencez par formuler précisément ce que vous voulez savoir. « Combien de lignes ? » appelle généralement COUNT(*). « Combien de lignes ont une valeur connue dans cette colonne facultative ? » appelle COUNT(colonne). Pour additionner des valeurs numériques, utilisez SUM ; pour calculer leur moyenne arithmétique, AVG ; pour les limites d’une date ou d’un nombre, MIN et MAX. Ces fonctions ne répondent pas à la même question : un nombre qui semble plausible peut tout de même être incorrect pour le besoin visé.

Par exemple, compter Email ne donne pas le nombre de clients : un client peut exister sans adresse connue. Compter OrderId compte les commandes, car chaque commande possède un identifiant non NULL. COUNT(DISTINCT CustomerId) indique combien de clients différents apparaissent dans les commandes en entrée. Dans une future requête groupée, ces choix pourront s’appliquer séparément à chaque groupe ; ici, ils résument l’ensemble des lignes.

La somme et la moyenne dépendent elles aussi des lignes sélectionnées. Avec une condition WHERE, elles ne décrivent plus toutes les commandes. Si vous joignez Orders à une table de détail contenant plusieurs lignes par commande, le montant de la commande peut être répété ; sa somme après la jointure risquerait alors d’être multipliée. Gardez le grain des lignes à l’esprit, comme dans la leçon sur le grain des jointures. Un agrégat ne sait pas si une répétition est accidentelle ou voulue : il calcule simplement sur les lignes fournies.

Pour les montants numériques, souvenez-vous du dénominateur de AVG. SQL Server divise par le nombre de valeurs non NULL, et non par le nombre total de lignes si certains montants sont NULL. Sur huit commandes dont un montant est inconnu, la moyenne porte sur sept montants connus. Ce résultat peut être utile, mais le rapport doit préciser qu’il s’agit de la moyenne des valeurs enregistrées. COUNT(Amount) peut indiquer le nombre de valeurs prises en compte. Ne remplacez pas une valeur manquante par zéro sauf si zéro a réellement ce sens métier : zéro est une valeur connue, NULL indique une valeur inconnue ou absente.

MIN et MAX repèrent des limites utiles. La date la plus ancienne peut montrer le début de l’activité enregistrée ; le montant le plus élevé peut être signalé pour vérification. Ces fonctions ne renvoient pas à elles seules la ligne correspondante. Deux commandes peuvent partager le même montant maximum : sélectionner un nom client avec MAX(Amount) sans regroupement ne permet pas à SQL Server de choisir le bon nom. La leçon suivante montre comment obtenir un agrégat pour chaque groupe défini par une clé.

Avant de publier un nombre récapitulatif, notez aussi le périmètre : la table lue, les filtres appliqués et la définition de la mesure. « Somme des commandes Complete » est plus précis que « ventes » si les commandes en attente et expédiées sont exclues. Cette habitude évite de comparer deux rapports qui utilisent le même mot pour des populations différentes. Dans SSMS, relisez la requête avec les colonnes et les lignes réelles à l’écran ; vérifiez séparément le nombre de valeurs pris en compte et la somme obtenue. Une agrégation correcte dépend autant de la sélection des lignes que du choix de la fonction.

Erreurs fréquentes

Ne confondez pas COUNT(*) et COUNT(colonne) sans tenir compte de NULL. Une requête d’agrégation sans regroupement ne fournit pas le détail des commandes : elle résume l’ensemble. Vérifiez comment WHERE réduit les lignes avant d’interpréter le résultat. Une moyenne est une moyenne arithmétique ; ne supposez pas qu’elle est arrondie à deux décimales. Enfin, si une requête mélange une colonne ordinaire et des agrégats, définissez ce qu’une ligne de résultat doit représenter. La leçon 14 explique le rôle de GROUP BY.

Exercices

Exercez-vous sur JaviBuildsLab : (1) compter les clients et les courriels renseignés ; (2) calculer le total et la moyenne des commandes ; (3) trouver la première et la dernière date ; (4) compter les clients distincts ayant commandé ; (5) compter les commandes Pending.

Réponses

Requête SQL: RéponsesT-SQL
-- 1 : 10 lignes ; 9 courriels connus
SELECT COUNT(*) AS CustomerRows, COUNT(Email) AS KnownEmails FROM dbo.Customers;
-- 2 : total 867.24 ; moyenne environ 123.8914
SELECT SUM(Amount) AS Total, AVG(Amount) AS Average FROM dbo.Orders;
-- 3 : 2025-02-01 et 2025-07-04
SELECT MIN(OrderDate) AS FirstDate, MAX(OrderDate) AS LastDate FROM dbo.Orders;
-- 4 : 4
SELECT COUNT(DISTINCT CustomerId) AS CustomersWithOrders FROM dbo.Orders;
-- 5 : 2
SELECT COUNT(*) AS PendingOrders FROM dbo.Orders WHERE Status = N'Pending';
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Gardez toujours à l’esprit les lignes qui alimentent un agrégat. La question suivante est souvent : « quel est le total pour chaque statut ou client ? »

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Que calcule COUNT(*) ?
Question 2 sur 2Que renvoie AVG pour une expression numérique ?

Fondamentaux de SQL Server

Leçon 13 sur 25

Continuer vers la leçon suivante

GROUP BY expliqué dans SQL Server

Continuer vers la leçon 14

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL