Compter le nombre de lignes avec COUNT() et ses variantes

La fonction COUNT() est l'une des fonctions d'agrégation les plus populaires et utiles en SQL. Son but principal — compter le nombre de lignes dans les résultats d'une requête. Si la fonction COUNT() était un super-héros dans le monde SQL, son super-pouvoir serait de trouver rapidement des réponses à des questions comme :

• Combien d'employés bossent dans la boîte ?
• Combien d'étudiants sont inscrits dans chaque faculté ?
• Combien de produits ont été vendus le mois dernier ?

La syntaxe de COUNT() est plutôt simple :

COUNT(colonne)

où colonne — c'est le nom de la colonne dont tu veux compter les lignes. Mais il y a d'autres façons de l'utiliser, qu'on va voir plus loin dans la leçon.

Allez, on commence par l'utilisation la plus basique de COUNT().

Variante 1 : Compter toutes les lignes avec COUNT(*)

Quand tu veux compter chaque ligne dans une table, peu importe si elles ont des données ou pas, tu utilises COUNT(*). L'étoile veut dire « toutes les colonnes ».

Exemple : On a une table students avec ce contenu :

On lance la requête suivante :

SELECT COUNT(*) 
FROM students;

Résultat :

La fonction COUNT(*) ne fait pas attention aux valeurs NULL dans les colonnes individuelles, parce qu'elle compte juste le nombre de lignes dans la table.

Variante 2 : Compter les lignes avec des valeurs existantes dans une colonne COUNT(colonne)

Mais si tu veux compter seulement les lignes où il y a une valeur non-NULL dans une colonne précise ? Là, tu utilises COUNT(colonne).

Exemple : on va compter le nombre d'étudiants qui ont un nom renseigné.

SELECT COUNT(name)
FROM students;

Résultat :

T'as vu la différence ? Il y a 4 lignes dans la table, mais dans l'une d'elles la colonne name contient NULL. La fonction COUNT(colonne) ignore les lignes où la valeur de la colonne est NULL.

Comparer COUNT(*) et COUNT(colonne)

Alors, c'est quoi la vraie différence entre ces deux façons d'utiliser la fonction : COUNT(*) et COUNT(colonne) ?

• COUNT(*) compte toutes les lignes dans la table, même celles avec NULL dans n'importe quelle colonne.
• COUNT(colonne) compte seulement les lignes où la colonne indiquée a une valeur différente de NULL.

Table d'exemple :

Requêtes :

-- Compte toutes les lignes.
SELECT COUNT(*) FROM students;         -- 4  -- TOTAL (toutes les lignes)

-- Compte seulement les lignes où le nom n'est pas NULL.
SELECT COUNT(name) FROM students;      -- 3  -- On compte les lignes avec un nom renseigné

-- Compte seulement les lignes où l'âge n'est pas NULL.
SELECT COUNT(age) FROM students;        -- 3  -- On compte les lignes avec un âge renseigné

Variante 3 : Compter les valeurs uniques avec COUNT(DISTINCT colonne)

Parfois, tu veux compter seulement les valeurs uniques dans une colonne. Par exemple, on veut savoir combien d'âges différents sont renseignés pour les étudiants. Là, COUNT(DISTINCT colonne) est ton pote.

Exemple :

SELECT COUNT(DISTINCT age) FROM students;

Résultat :

Fais gaffe, ici DISTINCT ignore non seulement les doublons, mais aussi les valeurs NULL.

Si tu essaies d'utiliser DISTINCT avec COUNT(*), tu vas avoir une erreur : DISTINCT ne marche que sur des colonnes précises.

Exemples d'utilisation de COUNT() dans des cas réels

Exemple 1. Compter le nombre d'étudiants

SELECT COUNT(*) AS total_students
FROM students;

Résultat :

Exemple 2. Compter les étudiants avec un âge connu

SELECT COUNT(age) AS students_with_age
FROM students;

Résultat :

Exemple 3. Compter les âges uniques

SELECT COUNT(DISTINCT age) AS unique_ages
FROM students;

Résultat :

Erreurs classiques quand tu utilises COUNT()

Penser que COUNT(colonne) va compter toutes les lignes, même si y'a des NULL.

C'est faux : COUNT(colonne) ignore les lignes où la colonne est NULL.

Utiliser COUNT(*) pour compter les valeurs uniques.

À la place, utilise COUNT(DISTINCT colonne).

Oublier de filtrer quand tu comptes des données précises.

Par exemple :

SELECT COUNT(*) FROM students WHERE age > 20;

Là, tu vas avoir seulement les étudiants de plus de 20 ans, et WHERE filtre déjà les lignes avant de compter.

Ces petits détails causent souvent des bugs logiques dans les requêtes. Fais gaffe !