Compter, additionner, mesurer

Un rapport veut rarement toutes les lignes — il veut des chiffres : combien de films au catalogue, quel budget total, quelle note moyenne. PostgreSQL peut condenser une colonne entière en un seul résultat, sans retourner chaque ligne individuelle. C'est le cœur de toute analyse chiffrée.

De la liste au chiffre

SELECT * FROM films renvoie 14 lignes — une par film. C'est utile pour parcourir un catalogue. Mais quand quelqu'un demande « combien de films ? », « quel est le budget total ? », « quelle est la note moyenne ? », il n'attend pas une liste : il attend un seul chiffre.

Les fonctions d'agrégation font exactement ça : elles lisent toutes les lignes d'une colonne et restituent une valeur résumée. La règle à retenir pour toute cette leçon : N lignes en entrée → 1 résultat en sortie.

Table films — les 14 films avec les colonnes à agréger

titreanneenotebudget_dollars
Inception20108.8160000000
Le Parrain19729.2(NULL)
Pulp Fiction19948.98000000
Amélie Poulain20018.3(NULL)
Les Marées de Titan20198.795000000
Orbite Basse20228.247350000
Les Neiges de Kervalec20158.312500000
L'Écluse de Marvaux20108.4(NULL)
Les Docks du Port-Neuf20107.918000000
Minuit moins sept20197.922400000
Un Été sans Wifi20198.36800000
Mariage à l'Improviste20016.8(NULL)
Les Lanternes de Mizuhara20168.630000000
Cinq-Boulons et la Mer Immobile20227.454900000

Quatre films n'ont pas de budget renseigné : budget_dollars est NULL pour Le Parrain, Amélie Poulain, L'Écluse de Marvaux et Mariage à l'Improviste. Les fonctions d'agrégation ne traitent pas les NULL de la même façon selon la fonction — chaque section le précise.

COUNT(*) — combien de lignes ?

COUNT(*) compte le nombre total de lignes d'une table — quelles que soient leurs valeurs, y compris les lignes avec des NULL. L'étoile signifie « toutes les lignes sans exception » ; elle n'a rien à voir avec le SELECT * de sélection de colonnes.

La requête
SELECT COUNT(*) AS nb_films FROM films
Résultat — 1 ligne · 1 ligne
nb_films
14

La requête renvoie toujours exactement 1 ligne — c'est la nature d'une agrégation sans GROUP BY. Peu importe la taille de la table : COUNT(*) produit un seul chiffre. On lui donne un alias (AS nb_films) pour nommer ce chiffre dans le résultat.

COUNT(colonne) — compter les non-NULL

COUNT(*) et COUNT(colonne) semblent identiques mais ne sont pas équivalents. COUNT(colonne) ignore les NULL : il ne compte que les lignes où la colonne a une valeur réelle.

Sur films : 4 films n'ont pas de budget renseigné. La différence apparaît clairement en plaçant les deux dans la même requête.

La requête
SELECT COUNT(*) AS nb_total, COUNT(budget_dollars) AS nb_avec_budget FROM films
Résultat — 1 ligne · 1 ligne
nb_totalnb_avec_budget
1410

La différence 14 − 10 = 4 est exactement le nombre de films sans budget. COUNT(budget_dollars) ne les compte pas car leur valeur est NULL (Le Parrain, Amélie Poulain, L'Écluse de Marvaux et Mariage à l'Improviste). Ce comportement s'applique à toute colonne nullable : COUNT(colonne) saute systématiquement les NULL, quelle que soit la colonne.

SUM — le total d'une colonne numérique

SUM(colonne) additionne toutes les valeurs d'une colonne numérique. Comme COUNT(colonne), il ignore les NULL — une valeur manquante ne vaut pas zéro, elle est simplement absente du calcul.

La requête
SELECT SUM(budget_dollars) AS budget_total FROM films
Résultat — 1 ligne · 1 ligne
budget_total
454950000

454 950 000 — la somme des dix budgets renseignés. Quatre films avaient NULL — SUM les a ignorés sans erreur. Ce n'est pas la somme « y compris les films sans budget » ; c'est uniquement le total des budgets réellement renseignés. Distinction à retenir quand une colonne a des NULL.

AVG — la moyenne

AVG(colonne) calcule la moyenne arithmétique d'une colonne numérique. Le résultat brut d'une moyenne est souvent une longue décimale peu lisible — on l'encapsule dans ROUND(..., 1) pour arrondir à une décimale. ROUND est détaillé dans la leçon « Arrondir et formater » ; pour l'instant, retiens simplement la forme combinée.

La requête
SELECT ROUND(AVG(note), 1) AS note_moyenne FROM films
Résultat — 1 ligne · 1 ligne
note_moyenne
8.3

La somme des 14 notes divisée par 14 donne 8.26… Sans ROUND, PostgreSQL renverrait 8.2642857142857143 — exact mais peu lisible. ROUND(valeur, 1) arrondit à une décimale. Comme SUM, AVG ignore les NULL : AVG(budget_dollars) calculerait la moyenne des 10 budgets renseignés (pas des 14 films), ce qui peut donner une valeur trompeuse si les NULL sont fréquents.

MIN et MAX — les extrêmes

MIN(colonne) et MAX(colonne) renvoient respectivement la valeur la plus basse et la plus haute d'une colonne. Ils fonctionnent sur les numériques (ordre numérique), les textes (ordre alphabétique) et les dates (ordre chronologique). On les place souvent ensemble dans la même requête.

La requête
SELECT MIN(annee) AS plus_ancien, MAX(annee) AS plus_recent, MIN(note) AS note_min, MAX(note) AS note_max FROM films
Résultat — 1 ligne · 1 ligne
plus_ancienplus_recentnote_minnote_max
197220226.89.2

Le Parrain (1972) est le plus ancien ; deux films de 2022 sont les plus récents. Mariage à l'Improviste (6.8) a la note la plus basse, Le Parrain (9.2) la plus haute. Comme les autres agrégats, MIN et MAX ignorent les NULL — MIN(budget_dollars) donnerait 6 800 000 (le plus petit des 10 budgets renseignés), sans tenir compte des 4 absences.

Récapitulatif

Ce que tu retiens de cette leçon :

📌 Agrégations de base — l'essentiel
COUNT(*)→ compte toutes les lignes, NULL inclus
COUNT(colonne)→ compte seulement les valeurs non-NULL
SUM(colonne)→ additionne les valeurs (NULL ignorés)
AVG(colonne)→ moyenne (NULL ignorés ; combiner avec ROUND)
MIN / MAX→ plus petite / plus grande valeur (nombres, textes, dates)
Exemple complet
SELECT COUNT(*) AS nb_films,
COUNT(budget_dollars) AS nb_avec_budget,
ROUND(AVG(note), 1) AS note_moyenne,
MIN(annee) AS plus_ancien,
MAX(annee) AS plus_recent
FROM films

💡 Bon à savoir : ces cinq fonctions travaillent ici sur toute la table — elles renvoient une seule ligne. Dans la leçon suivante, GROUP BY leur donnera une dimension nouvelle : calculer un COUNT ou un AVG par genre, par réalisateur, par décennie.

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