Dans SQL Server, le COUNT_BIG() 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.
Cette fonction fonctionne de la même manière que COUNT() une fonction. La différence est que COUNT() renvoie son résultat sous la forme d'un int , tandis que COUNT_BIG() renvoie son résultat sous la forme d'un bigint .
Donc COUNT_BIG() peut être utile si vous vous attendez à ce que votre jeu de résultats ait un très grand nombre de lignes (c'est-à-dire supérieur à 2 147 483 647).
Syntaxe
La syntaxe ressemble à ceci :
-- Aggregation Function Syntax
COUNT_BIG ( { [ [ ALL | DISTINCT ] expression ] | * } )
-- Analytic Function Syntax
COUNT_BIG ( [ 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. 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 :
USE WideWorldImportersDW; SELECT COUNT_BIG(*) AS 'Row Count' FROM Fact.[Order];
Résultat :
+-------------+ | Row Count | |-------------| | 231412 | +-------------+
Dans ce cas, il y a 231412 lignes dans Fact.[Order] tableau.
Dans ce cas, j'aurais pu utiliser COUNT() pour renvoyer le même résultat, car le nombre de lignes est suffisamment petit pour un int à gérer.
Exemple 2 - Un ensemble de résultats plus grand
Le véritable avantage d'utiliser COUNT_BIG() est lorsque votre ensemble de résultats est beaucoup plus grand que l'exemple précédent.
Exemple :
SELECT COUNT_BIG(*) AS 'Row Count' FROM ReallyBigTable;
Résultat :
+-----------------+ | Row Count | |-----------------| | 9147483648 | +-----------------+
Dans ce cas, le nombre de lignes est si grand qu'un int ne serait pas en mesure de le gérer. Heureusement, nous pouvons utiliser COUNT_BIG() , car il renvoie son résultat sous la forme d'un bigint .
Plus d'exemples
Pour plus d'exemples, voir Comment COUNT() Fonctionne dans SQL Server. Cet article fournit plus d'exemples que ceux répertoriés ici, qui s'appliquent également à COUNT_BIG() .
Une alternative :APPROX_COUNT_DISTINCT()
Si vous travaillez avec de très grands ensembles de données, vous pouvez envisager d'utiliser APPROX_COUNT_DISTINCT() au lieu de COUNT_BIG(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_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.
