Dans SQL Server, le COUNT_BIG() fonction et le COUNT() faire essentiellement la même chose :renvoyer le nombre d'éléments trouvés dans un groupe. Fondamentalement, vous pouvez utiliser ces fonctions pour savoir combien de lignes se trouvent dans un tableau ou un ensemble de résultats.
Dans de nombreux cas, vous pourrez choisir celui que vous préférez. Cependant, il existe une différence entre ces deux fonctions qui pourrait vous obliger à utiliser l'une plutôt que l'autre.
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 .
En d'autres termes, vous devrez utiliser COUNT_BIG() si vous vous attendez à ce que ses résultats soient supérieurs à 2 147 483 647 (c'est-à-dire si la requête renvoie plus de 2 147 483 647 lignes).
Exemple 1 - Lorsque COUNT() est OK
Voici un exemple de base montrant un scénario où à la fois COUNT() et COUNT_BIG() peut être utilisé :
USE WideWorldImportersDW; SELECT COUNT(*) AS 'COUNT', COUNT_BIG(*) AS 'COUNT_BIG' FROM Fact.[Order];
Résultat :
+---------+-------------+ | COUNT | COUNT_BIG | |---------+-------------| | 231412 | 231412 | +---------+-------------+
Nous pouvons voir qu'il y a 231412 lignes dans le Fact.[Order] tableau.
Dans ce cas, les deux fonctions peuvent le gérer, car le nombre de lignes est suffisamment petit pour être stocké dans un int ainsi qu'un bigint .
Cependant, si le résultat était si gros qu'un int ne pourrait pas le stocker, alors nous ne pourrions utiliser que COUNT_BIG() .
Exemple 2 - Lorsque COUNT_BIG() est requis
Voici un exemple où vous auriez besoin d'utiliser COUNT_BIG() .
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 .
Vérification du type de données des deux fonctions
Lorsque nous examinons les exemples précédents, nous ne pouvons pas réellement voir le nom du type de données. Nous ne pouvons que supposer que COUNT() renvoie ses résultats sous la forme d'un int et COUNT_BIG() utilise bigint parce que c'est ce que dit la documentation Microsoft (bien que nous sachions que le deuxième exemple ne peut pas être un int car la valeur est trop grande pour un int ).
Nous pouvons utiliser le sp_describe_first_result_set procédure stockée pour vérifier le type de données de retour de chacune de ces fonctions.
Vérifiez le type de données pour COUNT()
EXEC sp_describe_first_result_set N'SELECT COUNT(*) FROM Fact.[Order]', null, 0;
Résultat (en utilisant la sortie verticale) :
is_hidden | 0 column_ordinal | 1 name | NULL is_nullable | 1 system_type_id | 56 system_type_name | int max_length | 4 precision | 10 scale | 0 collation_name | NULL user_type_id | NULL user_type_database | NULL user_type_schema | NULL user_type_name | NULL assembly_qualified_type_name | NULL xml_collection_id | NULL xml_collection_database | NULL xml_collection_schema | NULL xml_collection_name | NULL is_xml_document | 0 is_case_sensitive | 0 is_fixed_length_clr_type | 0 source_server | NULL source_database | NULL source_schema | NULL source_table | NULL source_column | NULL is_identity_column | 0 is_part_of_unique_key | NULL is_updateable | 0 is_computed_column | 0 is_sparse_column_set | 0 ordinal_in_order_by_list | NULL order_by_is_descending | NULL order_by_list_length | NULL tds_type_id | 38 tds_length | 4 tds_collation_id | NULL tds_collation_sort_id | NULL
Oui, il y a beaucoup d'informations dont nous n'avons pas besoin, mais si vous regardez le system_type_name colonne, vous verrez que sa valeur est int . Cela nous indique que notre requête a renvoyé ses résultats sous la forme d'un int , comme prévu. Vous pouvez également voir que la max_length et précision les valeurs sont cohérentes avec le int type de données.
Vérifiez le type de données pour COUNT_BIG()
Pour cet exemple, il suffit de remplacer COUNT(*) avec COUNT_BIG(*) :
EXEC sp_describe_first_result_set N'SELECT COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Résultat (en utilisant la sortie verticale) :
is_hidden | 0 column_ordinal | 1 name | NULL is_nullable | 1 system_type_id | 127 system_type_name | bigint max_length | 8 precision | 19 scale | 0 collation_name | NULL user_type_id | NULL user_type_database | NULL user_type_schema | NULL user_type_name | NULL assembly_qualified_type_name | NULL xml_collection_id | NULL xml_collection_database | NULL xml_collection_schema | NULL xml_collection_name | NULL is_xml_document | 0 is_case_sensitive | 0 is_fixed_length_clr_type | 0 source_server | NULL source_database | NULL source_schema | NULL source_table | NULL source_column | NULL is_identity_column | 0 is_part_of_unique_key | NULL is_updateable | 0 is_computed_column | 0 is_sparse_column_set | 0 ordinal_in_order_by_list | NULL order_by_is_descending | NULL order_by_list_length | NULL tds_type_id | 38 tds_length | 8 tds_collation_id | NULL tds_collation_sort_id | NULL
Cette fois, nous pouvons voir que
system_type_name
est
bigint
. Cela nous indique que notre COUNT_BIG() la requête a renvoyé ses résultats en tant que bigint , comme prévu. La
max_length
et
précision
les valeurs sont également cohérentes avec le bigint type de données.
Soit dit en passant, un moyen plus rapide de faire ce qui précède consiste à combiner les deux fonctions dans une requête lors de l'appel de la procédure stockée.
Comme ceci :
EXEC sp_describe_first_result_set N'SELECT COUNT(*), COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Cela produira deux lignes, une pour chaque fonction dans le SELECT déclaration.
