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 4 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 (fictive) — les 4 films avec les colonnes à agréger
| titre | annee | note | budget_dollars |
|---|---|---|---|
| Inception | 2010 | 8.8 | 160 000 000 |
| Le Parrain | 1972 | 9.2 | (NULL) |
| Pulp Fiction | 1994 | 8.9 | 8 000 000 |
| Amélie Poulain | 2001 | 8.3 | (NULL) |
Deux films n'ont pas de budget renseigné : budget_dollars est NULL pour Le Parrain et Amélie Poulain. 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.
SELECT COUNT(*) AS nb_films
FROM films| nb_films |
|---|
| 4 |
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 : 2 films n'ont pas de budget renseigné. La différence apparaît clairement en plaçant les deux dans la même requête.
SELECT COUNT(*) AS nb_total,
COUNT(budget_dollars) AS nb_avec_budget
FROM films| nb_total | nb_avec_budget |
|---|---|
| 4 | 2 |
La différence 4 − 2 = 2 est exactement le nombre de films sans budget. COUNT(budget_dollars) ne les compte pas car leur valeur est NULL (Le Parrain et Amélie Poulain). 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.
SELECT SUM(budget_dollars) AS budget_total
FROM films| budget_total |
|---|
| 168000000.00 |
168 000 000 — Inception (160M) et Pulp Fiction (8M) additionnés. Le Parrain et Amélie Poulain 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 sera détaillé dans la prochaine leçon ; pour l'instant, retenez simplement la forme combinée.
SELECT ROUND(AVG(note), 1) AS note_moyenne
FROM films| note_moyenne |
|---|
| 8.8 |
(8.8 + 9.2 + 8.9 + 8.3) / 4 = 8.8 exactement. Sans ROUND, PostgreSQL renverrait 8.8000000000000000 — exact mais peu lisible. ROUND(valeur, 1) arrondit à une décimale. Comme SUM, AVG ignore les NULL : AVG(budget_dollars) calculerait la moyenne des 2 budgets renseignés (pas des 4 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.
SELECT MIN(annee) AS plus_ancien, MAX(annee) AS plus_recent,
MIN(note) AS note_min, MAX(note) AS note_max
FROM films| plus_ancien | plus_recent | note_min | note_max |
|---|---|---|---|
| 1972 | 2010 | 8.3 | 9.2 |
Le Parrain (1972) est le plus ancien, Inception (2010) le plus récent. Amélie Poulain (8.3) 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 8 000 000 (le plus petit des 2 budgets renseignés), sans tenir compte des 2 absences.
Récapitulatif
Ce que tu retiens de cette leçon :
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_recentFROM 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.