En SQL, le COUNT() La fonction est une fonction d'agrégation qui renvoie le nombre d'éléments trouvés dans un groupe.
Vous pouvez utiliser COUNT() dans plusieurs parties d'une requête. Par exemple, vous pouvez l'utiliser dans le SELECT liste, ou la HAVING clause lors du filtrage des groupes.
Exemple de tableau
Supposons que nous ayons le tableau suivant :
SELECT * FROM Pets;Résultat :
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Les exemples suivants utiliseront le COUNT() fonction lors de l'interrogation de cette table.
Exemple
Voici un exemple simple pour commencer.
SELECT COUNT(*) AS Count
FROM Pets;Résultat :
+---------+ | Count | |---------| | 8 | +---------+
Cela nous indique qu'il y a 8 lignes dans le tableau. Nous le savons parce que nous avons utilisé le caractère générique astérisque (* ) pour spécifier toutes les lignes et toutes les colonnes.
Compter une colonne spécifique
Vous pouvez également spécifier une colonne particulière à compter. Le COUNT() la fonction ne compte que les non-NULL résultats, donc si vous spécifiez une colonne qui contient NULL valeurs, ces valeurs ne seront pas comptées.
Voici un exemple pour illustrer ce que je veux dire.
SELECT COUNT(DOB) AS Count
FROM Pets;Résultat :
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
Dans ce cas, les Pets table contient deux NULL valeurs dans le DOB colonne (deux animaux n'ont pas fourni leur date de naissance), et donc COUNT(DOB) renvoie 6, au lieu de 8 lorsque nous utilisions COUNT(*) .
La raison COUNT(*) dans l'exemple précédent a renvoyé toutes les lignes, c'est parce que ces deux lignes l'ont fait avoir des données dans les autres colonnes.
Dans mon exemple, mon SGBD a également renvoyé un avertissement à ce sujet. Vous pouvez ou non recevoir un avertissement, selon votre SGBD et votre configuration spécifique.
Résultats filtrés
Le COUNT() La fonction compte les lignes renvoyées par la requête. Donc, si vous filtrez les résultats, le résultat de COUNT() reflétera cela.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Résultat :
+---------+ | Count | |---------| | 2 | +---------+
Dans ce cas, il y a deux animaux de compagnie avec un nom de Fluffy. Par conséquent, deux lignes auraient été renvoyées par la requête, et le résultat de COUNT() est 2 .
Compter des colonnes distinctes
Par défaut, le COUNT() la fonction inclut un ALL implicite mot-clé. Cela signifie qu'il inclut les doublons dans ses résultats.
Mais vous avez également la possibilité d'ajouter le DISTINCT mot-clé pour spécifier que seules des valeurs distinctes sont renvoyées. Autrement dit, vous pouvez spécifier qu'il exclut les doublons.
Choisissons le PetName colonne. Si vous regardez le tableau original ci-dessus, vous pouvez voir que le PetName la colonne comprend deux lignes avec la même valeur (Fluffy ).
Nous allons d'abord exécuter un COUNT(ALL PetName) requête pour inclure toutes les valeurs en double dans le décompte :
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Résultat :
+---------+ | Count | |---------| | 8 | +---------+
Donc, il y a huit rangées. Rappelez-vous que c'est le même résultat que nous aurions obtenu si nous n'avions pas inclus le ALL mot-clé, car ALL est la valeur par défaut.
Nous allons maintenant exécuter un COUNT(DISTINCT PetName) pour éliminer les doublons du décompte.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Résultat :
+---------+ | Count | |---------| | 7 | +---------+
Cette fois, le résultat est 7 . C'est parce que notre valeur en double a été éliminée. Autrement dit, la valeur en double a été traitée comme s'il n'y avait qu'une seule valeur.
Utiliser COUNT() avec le HAVING Article
Vous pouvez inclure le COUNT() fonction dans plusieurs parties d'une requête. Ce n'est pas seulement limité au SELECT liste.
Voici un exemple qui utilise COUNT() à la fois dans le HAVING clause et le SELECT liste.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Résultat :
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
Dans ce cas, nous avons utilisé le HAVING clause en conjonction avec le GROUP BY clause pour renvoyer uniquement les lignes qui ont un COUNT(PetTypeId) supérieur à 2 .
Vous n'êtes pas limité à l'opérateur ) pour les débutants » > opérateur supérieur à (> ) lors de l'utilisation de HAVING clause. Vous pouvez utiliser les mêmes opérateurs que vous pouvez utiliser avec WHERE clause (telle que = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , etc.).
Voir Opérateurs SQL pour une liste des opérateurs disponibles dans SQL.
Fonctions de la fenêtre
Selon votre SGBD, vous pourrez peut-être utiliser un OVER clause avec votre COUNT() fonction pour créer une fonction de fenêtre.
Une fonction de fenêtre effectue une opération de type agrégat sur un ensemble de lignes de requête. Il produit un résultat pour chaque ligne de requête. Cela contraste avec une opération d'agrégation, qui regroupe les lignes de requête en une seule ligne de résultat.
Voici un exemple pour illustrer le concept.
Nous avons déjà vu les Pets table. Notre base de données a également un Owners table, et elle contient les données suivantes :
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
Nous pouvons récupérer des données à partir de ces tables et les présenter sous la forme d'un ensemble de résultats à l'aide d'une jointure.
Nous pouvons également utiliser le COUNT() fonction avec le OVER clause pour appliquer une fonction de fenêtre aux données.
SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;Résultat :
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
Dans ce cas, nous avons utilisé le OVER clause avec notre COUNT() clause pour partitionner le compte uniquement au nom du propriétaire.
Le résultat est que les propriétaires de plusieurs animaux sont affichés sur plusieurs lignes (car chaque animal doit également être affiché), et chaque ligne contient le nombre total d'animaux de ce propriétaire.
Ce concept peut également être appliqué à d'autres fonctions d'agrégation en SQL, telles que SUM() , MIN() , MAX() , et AVG() .
COUNT_BIG()
Si vous comptez des ensembles de données très volumineux dans SQL Server, vous constaterez peut-être que le COUNT() fonction produit une erreur, car le nombre est trop élevé. Cela n'arrivera que si votre nombre est supérieur à 2 147 483 647.
Dans de tels cas, vous pouvez utiliser COUNT_BIG() , qui peut prendre en charge des nombres beaucoup plus importants.
Découvrez comment COUNT_BIG() Fonctionne dans SQL Server et COUNT() contre COUNT_BIG() pour une explication plus détaillée.
Norme SQL ANSI
Le COUNT() La fonction est répertoriée dans la norme SQL, et elle est disponible dans la plupart (sinon la totalité) des principaux SGBD, et fonctionne à peu près de la même manière entre eux.
Pour des exemples de code réalisés dans divers SGBD, voir SQLite COUNT() , SQL Server COUNT() , et MySQL COUNT() .
