Guide détaillé de la fonction SQL COUNT()

Vous pouvez compter sur ce guide pour vous donner des explications détaillées (avec des exemples à l'appui) sur toutes les utilisations typiques de la fonction COUNT() et de la fonction COUNT().

Connaître l'agrégation de données est une étape nécessaire pour devenir un maître du langage SQL. Cela inclut la fonction COUNT() - l'une des fonctions d'agrégation SQL les plus utilisées.

L'agrégation de données fait toujours partie des connaissances SQL de base. Le fait d'avoir des bases solides vous permet d'éviter les lacunes dans vos connaissances, ce qui facilite l'apprentissage de concepts SQL plus complexes. Vous pouvez acquérir ces bases et bien plus encore dans notre parcours d'apprentissage SQL de A à Z. Ses sept cours interactifs vous donneront une structure solide et rendront votre apprentissage systématique. Vous commencez par les bases du langage SQL, telles que la récupération de données et l'utilisation de fonctions SQL standard (dont COUNT() et d'autres fonctions agrégées). Une fois que vous avez assimilé ces notions, il est beaucoup plus facile de suivre les concepts plus avancés que ce cours vous enseigne, tels que les fonctions de fenêtre, les expressions de table courantes et les extensions GROUP BY.

Une fois que vous aurez appris tout cela, vous aurez besoin d'un peu de pratique pour le maîtriser vraiment. Pour cela, il y a le Exercices Pratiques de SQL et ses 88 exercices interactifs.

Cet article sera également pratique et vous montrera différents exemples d'utilisation de COUNT(). Pour cela, nous avons besoin d'un jeu de données approprié.

Exemple d'ensemble de données

Nous allons nous intéresser aux réalisateurs et à leurs films. Le premier tableau est, sans surprise, nommé directors. Voici la requête que vous pouvez utiliser pour reproduire cette table vous-même.

Les données de la table ressemblent à ceci :

Il s'agit d'une simple liste de réalisateurs accompagnée de quelques informations les concernant.

La deuxième table est films. Vous pouvez également créer cette table à l'aide de cette requête. Voici les données de la table :

Il s'agit d'une liste de films reliés à la table directors via la colonne director_id. Deux valeurs de director_id sont NULL. Dans le contexte de notre ensemble de données, cela signifie que la table contient des données sur ces films films. Cependant, il n'y a pas de réalisateur correspondant dans le tableau directors. En d'autres termes, nous disposons de toutes les informations sur "Dog Day Afternoon" et "The Hater", à l'exception de leur réalisateur.

Maintenant que nous connaissons les données, nous pouvons nous occuper de COUNT().

Qu'est-ce que COUNT() ?

La réponse est dans le nom : la fonction COUNT() de SQL est utilisée pour compter les lignes. Elle compte les lignes dans l'ensemble de résultats, et non dans la table. Pour être plus précis, elle comptera les lignes dans la table si votre table est un ensemble de résultats, c'est-à-dire si vous n'avez filtré les données d'aucune manière. Si vous filtrez les données, COUNT() renvoie le nombre de lignes dans les données filtrées.

Voici un exemple :

SELECT 
  COUNT(*) AS number_of_directors
FROM directors;

L'astérisque (*) dans la fonction COUNT() lui indique de compter toutes les lignes. Étant donné qu'aucun filtre n'est appliqué, le tableau entier directors sera l'ensemble des résultats. La fonction COUNT() renvoie donc le nombre de lignes du tableau :

Le nombre de lignes est de dix, ce qui, dans ce cas, représente également le nombre de directeurs.

Si l'ensemble de résultats est limité, la fonction COUNT(*) renverra une valeur différente. Supposons, par exemple, que nous souhaitions afficher le nombre d'administrateurs décédés. Cela signifie qu'il faut compter uniquement les administrateurs dont la date figure dans la colonne date_of_death. Ceux qui ont la valeur NULL sont encore en vie. Voici la requête :

SELECT 
  COUNT(*) AS number_of_dead_directors
FROM directors
WHERE date_of_death IS NOT NULL;

Nous avons obtenu ce que nous voulions en filtrant les données à l'aide de la clause WHERE. Voici le résultat :

Quatre directeurs ne sont plus en vie.

COUNT() et GROUP BY

En règle générale, la fonction COUNT() est utilisée avec la clause GROUP BY. Pour vous rafraîchir la mémoire, GROUP BY est une clause qui regroupe toutes les lignes ayant la même valeur. Habituellement, les groupes sont des colonnes spécifiques de l'ensemble de données. Pour plus d'informations, lisez cet article sur l'utilisation de GROUP BY.

Voici un exemple d'utilisation de GROUP BY avec COUNT(*):

SELECT 
  country_of_birth,
  COUNT(*) AS number_of_directors
FROM directors
GROUP BY country_of_birth
ORDER BY country_of_birth;

Nous voulons afficher tous les pays et le nombre de directeurs qui y sont nés. Nous sélectionnons le pays et utilisons COUNT(*) pour afficher le nombre de réalisateurs. Nous spécifions ensuite la colonne country_of_birth dans GROUP BY.

Chaque colonne du tableau qui apparaît dans SELECT doit également apparaître dans GROUP BY. C'est logique, car vous voulez voir le nombre de réalisateurs par pays de naissance et afficher ces pays simultanément.

Enfin, la sortie est triée par ordre alphabétique de pays à l'aide de ORDER BY country_of_birth:

Il y a un réalisateur pour chaque pays, à l'exception de la France et des États-Unis.

Si vous avez besoin de plus d'exemples, voici l'article qui montre comment utiliser GROUP BY avec les fonctions agrégées de SQL.

Utilisation de COUNT() avec une expression ou une colonne

Vous n'êtes pas limité à l'écriture d'un astérisque dans COUNT(). Il peut également être utilisé avec une colonne ou une expression, comme dans l'instruction CASE WHEN.

La différence est que COUNT(expression) ne compte que les valeurs nonNULL de l'expression. COUNT(*) comptera également les valeurs NULL.

Par exemple, essayons de dresser la liste de toutes les langues cinématographiques et du nombre de réalisateurs qui ont produit des films dans ces langues. Il semble que nous ayons toutes les données dans le tableau films.

Que se passerait-il si nous utilisions COUNT(*)?

SELECT 
  language,
  COUNT(*) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Au total, cette sortie montre les 12 films qui apparaissent dans le tableau. Attention : c'est faux !

La raison ? N'oubliez pas que COUNT(*) compte le nombre de lignes dans l'ensemble de données, y compris les NULL. Cette sortie ne représente donc pas du tout le nombre de réalisateurs ! Puisque nous avons compté les lignes du tableau filmsil est maintenant évident que nous avons compté le nombre de films, et non de réalisateurs !

En d'autres termes, il y a huit films en anglais, un en polonais et trois en espagnol. Ce résultat n'a rien à voir avec le nombre de réalisateurs !

Serait-il préférable d'utiliser COUNT(director_id)? Nous devrions essayer :

SELECT 
  language,
  COUNT(director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Nous sélectionnons les langues et comptons les réalisateurs via leur identifiant : director_id. Le résultat est groupé et trié par langue.

Le résultat diffère du précédent, analysons-le.

Ce que nous avons fait de bien en comptant director_id, c'est que nous nous sommes débarrassés des films avec NULLs dans director_id. C'est particulièrement évident pour la langue polonaise - le nombre de réalisateurs est de zéro. Pourquoi ? Parce qu'il n'y a qu'un seul film polonais et qu'il a un NULL dans director_id, donc il n'est pas compté.

Ce qui est moins évident, c'est qu'un film de ce type est également "manquant" en anglais. Il s'agit de Dog Day Afternoon, parce qu'il a également un NULL dans director_id.

Au total, le résultat montre dix réalisateurs parce qu'il y a dix enregistrements dans la table films avec des valeurs non NULL dans la colonne director_id.

Mais si vous revenez à la table filmsvous pouvez voir que certains ID d'administrateurs apparaissent plusieurs fois. Donc, oui, nous avons indiqué le nombre d'administrateurs, mais nous avons également inclus tous les administrateurs chaque fois qu'ils apparaissent dans le tableau. En d'autres termes, nous avons inclus les valeurs en double.

Ce résultat est donc plus proche de ce que nous voulions obtenir, mais il n'est pas encore tout à fait correct. Le fait de compter les identifiants des administrateurs en double gonfle le résultat, c'est-à-dire qu'il indique un nombre irréaliste d'administrateurs individuels.

Pour résoudre ce problème de duplication, il faudrait utiliser COUNT() avec DISTINCT.

COUNT(expression) avec DISTINCT

Maintenant que vous avez appris à utiliser COUNT() avec un nom de colonne, il est temps d'apprendre à l'utiliser avec DISTINCT.

La clause DISTINCT supprime les doublons. Lorsqu'elle est utilisée avec COUNT(expression), cela signifie que la fonction ne comptera que les instances uniques d'une colonne/expression.

Reprenons le même exemple que ci-dessus, mais avec DISTINCT:

SELECT 
  language,
  COUNT(DISTINCT director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Remarquez que DISTINCT est écrit dans la fonction COUNT(). Il précède la colonne que vous voulez compter. Voici les résultats :

Le résultat montre trois réalisateurs avec des films en anglais, zéro en polonais et deux en espagnol. Attendez un peu ! N'est-ce pas un résultat radicalement différent de celui que nous avons obtenu lorsque nous avons utilisé COUNT(director_id) sans DISTINCT?

Voici le résultat précédent :

Vous rendez-vous compte de ce qui s'est passé ici ? Sans DISTINCT, nous avons compté toutes les valeurs de director_id. La bonne façon de trouver le nombre de directeurs dans cet exemple est donc d'utiliser COUNT() avec DISTINCT.

Attention : Utilisation de COUNT() avec LEFT JOIN

Enfin, utilisons nos deux tables simultanément. Imaginez que vous souhaitiez obtenir tous les réalisateurs et le nombre de leurs films.

Vous penseriez (à juste titre) que vous avez besoin de LEFT JOIN. C'est un bon début ! Il se peut qu'il y ait des réalisateurs dans le tableau directors qui n'ont pas de films dans notre films tableau.

Comme nous voulons afficher la liste de tous les réalisateurs, LEFT JOIN est le bon choix. Pour compter le nombre de films, vous aurez peut-être envie d'utiliser COUNT(*). Voici la requête :

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(*) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name
ORDER BY d.id;

Nous avons sélectionné les colonnes nécessaires et utilisé COUNT(*). Les deux tables sont jointes sur la colonne contenant les identifiants des réalisateurs.

Les résultats sont regroupés par ID et nom des réalisateurs et triés par ID. Et les résultats :

Il semble que chaque réalisateur ait au moins un film. Au total, cela fait 15 films. Attendez un peu ! Cela ne me semble pas correct ! Il n'y a que 12 films dans le tableau films.

De plus, nous savons pertinemment qu'il n'y a pas de films de Stanley Kubrick dans le tableau. Comment se fait-il que la sortie indique qu'il en a un ? Les données relatives à tous les autres réalisateurs sont-elles également erronées ? Oui. L'utilisation de COUNT(*) n'est pas la bonne solution dans ce cas. LEFT JOIN renverra une ligne pour tous les réalisateurs, même celui qui n'a pas été trouvé dans le tableau films. Et COUNT(*) compte toutes ces lignes, même celles qui n'ont pas de films correspondants.

Au lieu de COUNT(*), utilisez COUNT() avec le nom de la colonne. Quelle colonne doit-on compter ? La méthode la plus sûre consiste à compter les identificateurs uniques, c'est-à-dire l'identifiant de la colonne dans le tableau films.

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(f.id) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name;

La requête est pratiquement la même que précédemment, à l'exception de l'utilisation différente de COUNT(). Et voici ce qu'elle renvoie :

C'est tout à fait ça ! Si vous additionnez les valeurs, vous verrez qu'il y a dix films au total. Pourquoi pas 12 ? Parce que deux films ont été réalisés par des réalisateurs qui n'existent pas dans notre ensemble de données, c'est-à-dire qu'ils ont des NULL dans la colonne director_id de la table films.

Pour consolider ce que vous avez appris ici, consultez d'autres exemples d'utilisation de COUNT().

COUNT() est aussi simple qu'un, deux, trois !

Ce n'était pas difficile, n'est-ce pas ? Ces exemples simples vous ont montré toutes les variantes d'utilisation de COUNT(). La fonction elle-même n'est pas difficile à comprendre. Mais, comme vous l'avez vu, il y a plusieurs façons de l'utiliser, et chacune d'entre elles peut donner un résultat différent.

Le choix de l'utilisation de COUNT() devient plus facile avec la pratique. La fonction Exercices Pratiques de SQL est précisément conçu à cette fin. Vous pouvez également essayer ces sept exemples d'utilisation de la fonction COUNT().

Outre la pratique, il est important que vous connaissiez vos données et que vous sachiez ce que vous voulez en faire. Lorsque tout cela est clair pour vous, COUNT() devient vraiment une fonction facile. Vous pouvez compter là-dessus ! Jeu de mots.