Comment utiliser COUNT() avec GROUP BY : 5 exemples pratiques

L'utilisation de la fonction COUNT() avec GROUP BY est l'une des constructions SQL les plus courantes dans les requêtes agrégées. Lisez cet article pour découvrir comment utiliser correctement COUNT() avec GROUP BY à l'aide de 5 exemples.

Dans cet article, nous allons expliquer l'importance d'utiliser COUNT avec GROUP BY. Nous expliquerons pourquoi cette combinaison est essentielle en SQL et comment elle permet d'analyser et de résumer les données en fonction de critères spécifiques. Cette combinaison permet aux utilisateurs d'extraire des informations significatives, de calculer des nombres et de générer des résumés statistiques à partir de grands ensembles de données.

Si vous souhaitez revoir en profondeur les concepts SQL de base tels que COUNT() et GROUP BY, je vous recommande notre cours interactif SQL pour les débutants interactif. Il contient 129 exercices qui vous aideront à revoir tous les concepts SQL clés.

Comment utiliser COUNT() et GROUP BY

Si vous êtes ici juste pour une réponse rapide, voici le TLDR :

La manière correcte d'utiliser COUNT() avec GROUP BY est illustrée dans la requête ci-dessous :

SELECT 
  Store,
  COUNT(*) as NumberOfSales, 
FROM Sales
GROUP BY Store;

Décomposons le résultat pour comprendre comment fonctionne cette requête. Les lignes ayant la même valeur dans la colonne Store sont regroupées. Imaginez un tableau intermédiaire dans lequel ces lignes sont regroupées et marquées de couleurs différentes, comme dans l'image ci-dessous. Il s'agirait de notre tableau intermédiaire contenant uniquement la colonne Store, puisqu'il s'agit de la colonne qui fait partie de notre déclaration SELECT.

La base de données compte ensuite logiquement le nombre de lignes dans chaque groupe à l'aide de la fonction COUNT(*). Ce décompte représente le nombre de commandes pour chaque magasin.

Une fois les lignes comptées, il n'est pas nécessaire d'avoir des lignes en double avec la même valeur de magasin. Ainsi, GROUP BY réduira le nombre de lignes aux seules valeurs uniques. En d'autres termes, il se débarrasse des lignes individuelles et nous donne un résumé de chaque groupe. Nous obtenons le résultat suivant :

Quand utiliser GROUP BY

GROUP BY est une clause SQL qui regroupe les lignes en fonction des valeurs d'une ou de plusieurs colonnes. Elle est souvent utilisée en combinaison avec des fonctions d'agrégation telles que COUNT(), SUM(), AVG(), MAX() et MIN() pour effectuer des calculs sur des données groupées.

La clause GROUP BY est utile lorsque vous souhaitez

• Effectuer des calculs et des agrégations sur des sous-ensembles de données.
• Générer des statistiques sommaires et des mesures pour différents groupes ou catégories.
• Identifier des modèles et des tendances au sein de groupes spécifiques.
• Générer des rapports et analyser des données en fonction de différentes dimensions ou attributs.
• Appliquer des filtres et des conditions sur des données groupées, à l'aide de la méthode HAVING.

En résumé, GROUP BY est utilisé pour organiser et résumer les données en fonction de colonnes, de fonctions ou d'expressions spécifiques, ce qui vous permet d'obtenir des informations et d'effectuer des calculs sur des groupes distincts au sein d'un ensemble de données.

Quand utiliser la fonction COUNT()

COUNT() La fonction COUNT() est l'une des fonctions agrégées les plus courantes de SQL. Elle renvoie le nombre de lignes qui correspondent à une condition spécifiée ou qui sont incluses dans un ensemble de résultats. Elle est souvent utilisée pour récupérer le nombre total d'enregistrements dans une table ou pour calculer le nombre d'occurrences d'une valeur particulière dans une colonne.

5 exemples d'utilisation de COUNT() avec GROUP BY

Maintenant que nous avons passé en revue les scénarios de base dans lesquels COUNT() et GROUP BY sont utilisés, passons à des exemples plus complexes. Nous commencerons par des exemples simples, puis nous passerons à des scénarios plus complexes.

Exemple n° 1 : Groupement par une seule colonne

Le scénario le plus simple que vous puissiez rencontrer est celui qui consiste à GROUP BY une seule colonne. Dans l'exemple suivant, nous avons besoin de savoir comment le nombre d'employés de notre société est réparti entre les différents titres de poste.

Avant de voir la solution SQL à ce scénario, examinons les données de l'échantillon. Il s'agit de la employees table :

En utilisant la fonction COUNT avec GROUP BY sur la colonne JobTitle, nous pouvons obtenir une ventilation du nombre d'employés dans chaque rôle spécifique. Vous pouvez voir la requête et le résultat (basé sur les données de l'échantillon) ci-dessous :

SELECT 
  JobTitle, 
  COUNT(*) AS NumberOfEmployees
FROM employees
GROUP BY JobTitle;

Cet exemple fonctionne de la même manière que notre requête initiale. GROUP BY regroupe les lignes des employés ayant le même titre de poste. La fonction COUNT() compte ensuite les lignes de chaque groupe. GROUP BY réduit ensuite les lignes de chaque groupe, en ne conservant que la valeur de la colonne JobTitle et le compte.

Exemple n° 2 : Groupement par plusieurs colonnes

Bien entendu, vous pouvez regrouper les lignes en fonction de plusieurs colonnes.

Dans cet exemple, nous allons examiner un exemple de tableau orders contenant des informations de base sur les commandes :

Nous devons écrire une requête qui indiquera le nombre de commandes passées par chaque client et le site ProductCategory de cette commande. Cela signifie que nous devons renvoyer le site CustomerID et la catégorie à laquelle appartient la commande.

La requête ressemblera à ceci :

SELECT
  CustomerID,
  ProductCategory,
  COUNT(*) AS NumberOfOrders
FROM orders
GROUP BY CustomerID, ProductCategory;

Le résultat de l'exécution de cette requête peut être vu ci-dessous :

Notre requête regroupe les lignes en fonction de deux colonnes : CustomerID et ProductCategory. Cela signifie que GROUP BY regroupe les lignes ayant les mêmes valeurs de CustomerID et ProductCategory en un seul groupe. (Les lignes pour CustomerID 101 et la catégorie Electronics sont dans un groupe, mais les lignes pour CustomerID 101 et la catégorie Home Goods sont dans un groupe différent). Les lignes de chaque groupe sont ensuite comptées par COUNT().

Exemple 3 : Utilisation de WHERE avec COUNT() et GROUP BY

Notre exemple précédent analysait un scénario dans lequel nous voulions créer un agrégat de toutes les informations de notre orders tableau. Mais parfois, nous pouvons vouloir découper ces informations et ne voir que les commandes des catégories sélectionnées.

En utilisant le même échantillon de données que précédemment, nous allons maintenant écrire une requête qui montre les mêmes informations pour les commandes qui tombent dans les catégories "Accessoires" ou "Vêtements" ProductCategory.

Pour ce faire, nous pouvons utiliser la requête de l'exemple 2 et ajouter une clause WHERE. Cette clause filtrera les enregistrements pour lesquels ProductCategory est égal à "Accessoires" ou "Vêtements".

SELECT
  CustomerID,
  ProductCategory,
  COUNT(*) AS NumberOfOrders
FROM orders
WHERE ProductCategory IN (‘Accessories’, ‘Clothing’)
GROUP BY CustomerID, ProductCategory;

Si la manière dont la base de données a généré les résultats à l'aide de la requête ci-dessus n'est pas tout à fait intuitive, voici une explication étape par étape de ce qui s'est passé en coulisses :

1. Tout d'abord, la base de données analyse la table orders et lit toutes les lignes.
2. Elle applique ensuite la condition de filtrage dans WHERE ProductCategory IN (‘Accessories’, ‘Clothing’ ) pour filtrer les lignes. Après cette étape, seules les lignes dont la catégorie de produit est "Accessoires" ou "Vêtements" sont prises en compte pour la suite du traitement.
3. Les lignes filtrées sont ensuite regroupées en fonction des valeurs des colonnes CustomerID et ProductCategory, spécifiées dans la clause GROUP BY.
4. Pour chacune des combinaisons uniques de CustomerID et ProductCategory, la fonction COUNT(*) est appliquée. Cette fonction compte le nombre de lignes dans chaque groupe.
5. Le résultat final comprend CustomerID, ProductCategory et le nombre de commandes (indiqué dans la colonne NumberOfOrders ) pour chaque groupe.

En résumé, la base de données filtre les lignes qui respectent la condition de filtrage spécifiée. Elle les regroupe ensuite en fonction des colonnes spécifiées dans la clause GROUP BY, puis calcule le nombre de commandes dans chacun de ces groupes. Le résultat final comprendra CustomerID, ProductCategory et le nombre correspondant de commandes pour chaque combinaison unique de CustomerID et ProductCategory.

Exemple 4 : Utilisation de ORDER BY avec COUNT() et GROUP BY

Si l'on examine le résultat de l'exemple 4, on constate que certaines lignes de la sortie sont mélangées. Cela s'explique par le fait que les colonnes de la liste GROUP BY nécessitent généralement - mais ne garantissent pas - un tri de la sortie sur la base de la liste des colonnes de la section GROUP BY.

Mais si, par exemple, nous devons organiser les résultats en fonction de différentes conditions (par exemple, une chronologie ou une date), nous devrons utiliser une clause ORDER BY:

SELECT
  CustomerID,
  ProductCategory,
  COUNT(*) AS NumberOfOrders
FROM orders
WHERE ProductCategory IN (‘Accessories’, ‘Electronics’)
GROUP BY CustomerID, ProductCategory
ORDER BY ProductCategory, CustomerID;

Nous avons ajouté la clause ORDER BY avec la liste des colonnes par lesquelles nous voulons trier les données. Comme vous pouvez le constater, les données de sortie sont triées en fonction de l'ordre des colonnes énumérées.

Exemple 5 : COUNT(expression)

Jusqu'à présent, nous avons examiné des exemples simples d'utilisation de COUNT(); l'objectif était de compter toutes les lignes de l'ensemble de données ou de la table source.

Cependant, il existe des façons plus complexes d'utiliser la combinaison COUNT–GROUP BY. Pour l'expliquer, nous allons créer un nouvel exemple d'ensemble de données.

Nous disposons d'une table appelée SurveyResponses qui stocke les réponses à une enquête. Certaines questions sont facultatives, ce qui explique pourquoi certains répondants ont des valeurs de réponse NULLES ; ils ont sauté les questions facultatives. Vous pouvez voir l'échantillon de données ci-dessous :

COUNT(*) - Comptage des lignes

L'utilisation la plus courante de la fonction COUNT (et sa fonctionnalité par défaut, même si elle est utilisée avec GROUP BY) consiste à compter le nombre de lignes. Par exemple, si nous voulons compter les types de réponses aux questions d'une enquête, nous pouvons utiliser la requête suivante :

SELECT COUNT(*) AS NumberOfYesAnswers, Answer
FROM SurveyResponses
GROUP BY Answer;

Le résultat ressemblera à ceci :

Le résultat est un décompte de toutes les lignes qui correspondent à une certaine réponse. Il renvoie le nombre total de réponses à l'enquête et le type de réponse.

Comptage des valeurs NON-NULL dans une colonne

Examinons un autre exemple qui pourrait sembler produire les mêmes résultats. En fait, cet exemple présente une particularité importante : au lieu d'utiliser * comme paramètre de notre fonction COUNT(), nous utilisons COUNT() avec un nom de colonne.

Nous allons modifier la requête de l'exemple précédent. Au lieu du paramètre * pour la fonction COUNT(), nous le remplacerons par la colonne Answer. Notre nouvelle requête ressemble à ceci :

SELECT 
  COUNT(Answer) AS NumberOfAnswers, 
  AnswerFROM SurveyResponses
GROUP BY Answer;

Si nous exécutons cette nouvelle requête, nous constaterons que les résultats obtenus sont presque identiques :

Nous pouvons voir que le résultat pour la valeur de réponse NULL est passé de 1 à 0. Ceci est dû au fait que la fonction COUNT() ne prend en considération que les valeurs nonNULL lors de l'agrégation.

Auparavant, nous faisions COUNT(*), ce qui signifie implicitement compter les lignes ; COUNT(Answer) comptera les valeurs dans la colonne Answer. Et parce que nous avions 1 valeur avec NULL, la fonction ignorera ces valeurs dans son calcul - renvoyant 0 dans ce deuxième scénario.

Comptage des valeurs distinctes NON-NULL dans une colonne

Dans cette troisième variante de la fonction COUNT, nous utiliserons la même requête que dans l'exemple précédent. Cette fois, nous ajouterons le mot-clé DISTINCT avant le nom de la colonne.

SELECT 
  Answer, 
  COUNT(DISTINCT Answer) AS DistinctCount
FROM SurveyResponses
GROUP BY Answer;

Nous pouvons voir dans la sortie ci-dessus que le résultat de cette requête a transformé toutes les valeurs positives de la colonne DistinctCount en 1. L'ajout du mot-clé DISTINCT signifie que chaque fois que la fonction COUNT trouve une nouvelle valeur qu'elle n'a pas encore vue, elle ajoute cet état à sa liste et ajoute un 1 à son compte. Cependant, si elle trouve la même valeur d'état une deuxième fois ou plus, elle ne la comptera pas.

Vous voulez en savoir plus sur COUNT() et GROUP BY ?

L'utilisation de COUNT() avec GROUP BY n'est qu'une des nombreuses fonctionnalités puissantes offertes par SQL. Si vous souhaitez explorer davantage SQL et maîtriser ses capacités, je vous encourage à consulter notre cours complet SQL pour les débutants . Si vous recherchez des exercices SQL, je vous recommande notre piste La pratique du SQL qui contient plus de 600 exercices pratiques SQL.

Après avoir suivi nos cours, vous avez peut-être envie de trouver un emploi dans le domaine du langage SQL. Pour vous aider à préparer votre entretien, nous vous proposons une liste de questions d'entretien SQL qui vous donnera des exemples concrets de questions et de problèmes en SQL.