Comment COUNT () fonctionne dans SQL Server

Dans SQL Server, le COUNT() La fonction renvoie le nombre d'éléments trouvés dans un groupe. Vous pouvez l'utiliser pour savoir combien de lignes se trouvent dans un tableau ou un ensemble de résultats.

Syntaxe

La syntaxe ressemble à ceci :

-- Syntaxe de la fonction d'agrégation COUNT ( { [ [ ALL | DISTINCT ] expression ] | * } ) -- Syntaxe de la fonction analytique COUNT ( [ ALL ] { expression | * } ) OVER ( [  ] )

ALL applique la fonction d'agrégation à toutes les valeurs. C'est la valeur par défaut.

DISTINCT spécifie que la fonction renvoie le nombre de valeurs uniques non nulles.

expression est une expression de n'importe quel type, sauf image , texte , ou texte . Les fonctions d'agrégation et les sous-requêtes ne sont pas prises en charge dans l'expression.

* spécifie que toutes les lignes doivent être comptées et renvoyées, y compris les lignes en double et les lignes contenant des valeurs nulles. COUNT(*) ne prend aucun paramètre et ne prend pas en charge l'utilisation de DISTINCT . Il ne nécessite pas non plus d'expression paramètre (car il n'utilise pas d'informations sur une colonne particulière).

OVER ( [ <partition_by_clause> ] divise le jeu de résultats produit par le FROM clause en partitions auxquelles la fonction est appliquée. S'il n'est pas spécifié, la fonction traite toutes les lignes du jeu de résultats de la requête comme un seul groupe.

Exemple 1 - Utilisation de base

Voici un exemple de base montrant comment cette fonction fonctionne :

SELECT COUNT(*) AS 'Row Count'FROM Artistes ;

Résultat :

+-------------+| Nombre de lignes ||-------------|| 16 |+-------------+

Dans ce cas, il y a 16 lignes dans les Artistes tableau.

Juste pour être sûr, les voici :

SÉLECTIONNER *DES Artistes ;

Résultat :

+------------+-----------------------+-------- ------+-------------+| Identifiant de l'artiste | NomArtiste | ActiveDepuis | ID Pays ||------------+-----------------------+--------- -----+-------------|| 1 | Vierge de fer | 1975-12-25 | NUL || 2 | CA/CC | 1973-01-11 | NUL || 3 | Allan Holdsworth | 1969-01-01 | NUL || 4 | Copain riche | 1919-01-01 | NUL || 5 | Devin Townsend | 1993-01-01 | NUL || 6 | Jim Reeves | 1948-01-01 | NUL || 7 | Tom Jones | 1963-01-01 | NUL || 8 | Marron 5 | 1994-01-01 | NUL || 9 | Le Scénario | 2001-01-01 | NUL || 10 | Allumé | 1988-06-26 | NUL || 11 | Sabbat noir | 1968-01-01 | NUL || 12 | Michael apprend à rocker | 1988-03-15 | NUL || 13 | Carabao | 1981-01-01 | NUL || 14 | Karnivool | 1997-01-01 | NUL || 15 | Oiseaux de Tokyo | 2004-01-01 | NUL || 16 | Bodyjar | 1990-01-01 | NULL |+------------+-----------------------+--------- -----+-------------+

Comme prévu, 16 lignes sont renvoyées.

Notez que le CountryId colonne ne contient que des valeurs nulles. Cela sera utile pour le prochain exemple.

Exemple 2 - Spécifier une colonne

L'exemple précédent utilisait un astérisque (* ) pour spécifier toutes les lignes. Ainsi, toutes les lignes sont comptées, qu'il y ait ou non des doublons ou qu'elles contiennent des valeurs nulles.

Vous pouvez également spécifier une colonne particulière. Lorsque vous faites cela, les valeurs nulles ne sont pas comptées. Autrement dit, toutes les lignes contenant une valeur nulle pour cette colonne ne sont pas comptées.

Voici un exemple utilisant le CountryId colonne comme mentionné dans l'exemple précédent :

SELECT COUNT(CountryId) AS 'Row Count'FROM Artists ;

Résultat :

+-------------+| Nombre de lignes ||-------------|| 0 |+-------------+

Comme nous l'avons vu dans l'exemple précédent, toutes les lignes de cette colonne sont NULL . Par conséquent, le nombre de lignes résultant est égal à zéro.

Ajoutons quelques valeurs dans cette colonne :

UPDATE ArtistsSET CountryId =2WHERE ArtistName IN ( 'AC/DC', 'Karnivool', 'Birds of Tokyo', 'Bodyjar' );

Comptons à nouveau les lignes de cette colonne :

SELECT COUNT(CountryId) AS 'Row Count'FROM Artists ;

Résultat :

+-------------+| Nombre de lignes ||-------------|| 4 |+-------------+

Exemple 3 - Avec DISTINCT

Cet exemple utilise le DISTINCT clause pour renvoyer uniquement des lignes distinctes (c'est-à-dire non dupliquées).

Dans l'exemple précédent, j'ai mis à jour la table afin que le même CountryId a été appliqué à quatre artistes (j'ai utilisé SET CountryId = 2 pour les quatre artistes). Cela a abouti à quatre lignes avec le même CountryId .

Voici ce qui se passe si je compte le nombre de CountryId distincts s sont dans cette table :

SELECT COUNT(DISTINCT CountryId) 'Distinct CountryIds'FROM Artists ;

Résultat :

+-----------------------+| ID de pays distincts ||-----------------------|| 1 |+-----------------------+

C'est normal, car bien qu'il y ait quatre lignes avec un CountryId , il s'agit toujours d'un seul CountryId distinct .

Juste pour être sûr, exécutons-le avec sa version "non distincte" :

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists ;

Résultat :

+----------------+------------+| non distinct | Distinct ||----------------+------------|| 4 | 1 |+------------+------------+

Ainsi, la version non distincte indique combien de fois le CountryId apparaît dans le tableau, alors que le DISTINCT la version compte plusieurs occurrences comme 1.

Ajoutons un autre CountryId au tableau :

UPDATE ArtistsSET CountryId =1WHERE ArtistName ='Carabao';

Et maintenant relancez la requête :

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists ;

Résultat :

+----------------+------------+| non distinct | Distinct ||----------------+------------|| 5 | 2 |+------------+------------+

Exemple 4 – Utiliser une clause WHERE

Voici un exemple rapide utilisant un WHERE clause.

SELECT COUNT(*) AS 'Row Count'FROM ArtistsWHERE ActiveFrom>='2000-01-01';

Résultat :

+-------------+| Nombre de lignes ||-------------|| 2 |+-------------+

Exemple 5 – Avec GROUP BY

Voici un exemple de regroupement des artistes dans une colonne, puis de comptage de tous les albums de chaque artiste dans l'autre colonne.

Exemple :

SELECT ArtistName, COUNT(al.AlbumId) 'Number of Albums'FROM Artists arINNER JOIN Albums alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Number of Albums' DESC;

Résultat :

+-----------------------+--------------------+ | NomArtiste | Nombre d'albums ||-----------------------+-------------------- || Vierge de fer | 5 || Michael apprend à rocker | 3 || Le Scénario | 3 || Tom Jones | 3 || Devin Townsend | 3 || Allan Holdsworth | 2 || Copain riche | 1 || CA/CC | 1 || Jim Reeves | 1 |+-----------------------+--------------------+ 
Exemple 6 – Avec la clause HAVING
 

 Nous pouvons modifier l'exemple précédent pour n'inclure que les artistes qui ont plus d'un certain nombre d'albums. Nous pouvons le faire en utilisant le HAVING clause.
 
SELECT ArtistName, COUNT(al.AlbumId) 'Nombre d'albums'FROM Artistes arINNER JOIN Albums alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameHAVING COUNT(al.AlbumId)> 2ORDER BY 'Nombre d'albums' DESC ; 

 Résultat :
 
+-----------------------+--------------------+ | NomArtiste | Nombre d'albums ||-----------------------+-------------------- || Vierge de Fer | 5 || Michael apprend à rocker | 3 || Le Scénario | 3 || Tom Jones | 3 || Devin Townsend | 3 |+-----------------------+--------------------+ 
Exemple 7 – Partitionnement avec la clause OVER
 

 Vous pouvez utiliser le OVER clause avec PARTITION BY pour diviser les résultats en partitions. 
 

 Dans cet exemple, j'utilise OVER (PARTITION BY ArtistName) pour répertorier chaque album que l'artiste a produit, ainsi que le nombre total d'albums pour cet artiste. 
 
SELECT ArtistName, AlbumName, COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Nombre d'albums de cet artiste'FROM Artistes arINNER JOIN Albums alON al.ArtistId =ar.ArtistIdORDER BY 'Nombre d'albums de cet artiste' DESC ; 
 

 Résultat :
 
+-----------------------+--------------------- -----+--------------------------------------+| NomArtiste | NomAlbum | Nombre d'albums de cet artiste ||------------------------+----------------- ---------+--------------------------------------------------|| Vierge de fer | Powerslave | 5 || Vierge de fer | Quelque part dans le temps | 5 || Vierge de fer | Tranquillité d'esprit | 5 || Vierge de fer | Tueurs | 5 || Vierge de fer | Pas de prière pour les mourants | 5 || CA/CC | Powerage | 3 || CA/CC | De retour en noir | 3 || CA/CC | Rocher ou buste | 3 || Michael apprend à rocker | Nuit Bleue | 3 || Michael apprend à rocker | Éternité | 3 || Michael apprend à rocker | Scandinavie | 3 || Devin Townsend | Ziltoid l'Omniscient | 3 || Devin Townsend | Victimes de Cool | 3 || Devin Townsend | Épicloud | 3 || Tom Jones | Valise perdue depuis longtemps | 3 || Tom Jones | Louange et blâme | 3 || Tom Jones | Le long est venu Jones | 3 || Allan Holdsworth | Toute la nuit est fausse | 2 || Allan Holdsworth | Les Seize Hommes de Tain | 2 || Copain riche | Grand visage de balançoire | 1 || Jim Reeves | Chanter sur la voie | 1 || Le Scénario | Pas de son sans silence | 1 |+-----------------------+---------------------- ----+--------------------------------------------------+
 

 Notez que cela entraîne la répétition du nombre d'artistes et d'albums sur plusieurs lignes, mais cela est normal lorsque nous voulons également répertorier chaque album sur sa propre ligne.
 
Exemple 8 – Avec STRING_AGG()
 

 Si vous ne voulez pas que chaque nombre d'artistes et d'albums soit répété sur plusieurs lignes comme dans l'exemple précédent, vous pouvez toujours utiliser le STRING_AGG() fonction pour afficher les albums sous forme de liste. Dans ce cas, vous n'auriez pas besoin du OVER clause.
 

 Exemple :
 
SELECT ArtistName, STRING_AGG(AlbumName, ', ') 'Albums', COUNT(AlbumId) 'Count'FROM Artistes arINNER JOIN Albums alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Count' DESC ;
 

 Résultat :
 
+-----------------------+--------------------- -------------------------------------------------- ---------+---------+| NomArtiste | Albums | Compter ||------------------------+---------------------- -------------------------------------------------- --------+---------|| Vierge de Fer | Powerslave, Quelque part dans le temps, Tranquillité d'esprit, Tueurs, Pas de prière pour les mourants | 5 || CA/CC | Powerage, Back in Black, Rock ou Bust | 3 || Michael apprend à rocker | Blue Night, Éternité, Scandinavie | 3 || Devin Townsend | Ziltoid l'Omniscient, Victimes de Cool, Epicloud | 3 || Tom Jones | Valise perdue depuis longtemps, louange et blâme, Along Came Jones | 3 || Allan Holdsworth | All Night Wrong, Les Seize Hommes de Tain | 2 || Copain riche | Grand visage de balançoire | 1 || Jim Reeves | Chanter sur la voie | 1 || Le Scénario | Pas de son sans silence | 1 |+-----------------------+---------------------- -------------------------------------------------- --------+---------+
 
BEAUCOUP de lignes ?
 

 Le COUNT() la fonction renvoie son résultat sous la forme d'un int Type de données. Si vous avez tellement de lignes que le résultat est plus grand que int peut gérer, essayez COUNT_BIG() à la place.
 

 COUNT_BIG() fonctionne de la même manière que COUNT() , sauf que ses résultats sont renvoyés sous la forme d'un bigint valeur du type de données.
 

 Vous pouvez également envisager d'utiliser APPROX_COUNT_DISTINCT() dans certains cas. 
 

 APPROX_COUNT_DISTINCT() renvoie une valeur approximative, plutôt qu'une valeur précise. Cependant, il est conçu pour être beaucoup plus réactif que COUNT() et COUNT_BIG() , cela peut donc être utile lorsque la réactivité est plus importante que la précision.
 

 Il est conçu pour renvoyer des valeurs uniques et non nulles, il ne serait donc pertinent que pour les moments où vous utiliseriez normalement le DISTINCT clause avec COUNT_BIG() .
 

 Notez également qu'au moment de la rédaction de APPROX_COUNT_DISTINCT() est en préversion publique.