No SQL Server, o
COUNT_BIG() função e a função COUNT() fazer essencialmente a mesma coisa:retornar o número de itens encontrados em um grupo. Basicamente, você pode usar essas funções para descobrir quantas linhas estão em uma tabela ou conjunto de resultados. Em muitos casos, você poderá escolher o que preferir. No entanto, há uma diferença entre essas duas funções que pode determinar que você use uma sobre a outra.
A diferença é que
COUNT() retorna seu resultado como um int , enquanto COUNT_BIG() retorna seu resultado como um bigint . Em outras palavras, você precisará usar
COUNT_BIG() se você espera que seus resultados sejam maiores que 2.147.483.647 (ou seja, se a consulta retornar mais de 2.147.483.647 linhas). Exemplo 1 – Quando COUNT() está OK
Aqui está um exemplo básico mostrando um cenário em que tanto
COUNT() e COUNT_BIG() pode ser usado:USE WideWorldImportersDW; SELECT COUNT(*) AS 'COUNT', COUNT_BIG(*) AS 'COUNT_BIG' FROM Fact.[Order];
Resultado:
+---------+-------------+ | COUNT | COUNT_BIG | |---------+-------------| | 231412 | 231412 | +---------+-------------+
Podemos ver que existem 231412 linhas no Fact.[Order] tabela.
Nesse caso, ambas as funções podem lidar com isso, porque a contagem de linhas é pequena o suficiente para ser armazenada em um int bem como um grande .
No entanto, se o resultado for tão grande que um int não pudesse armazená-lo, então só poderíamos usar
COUNT_BIG() . Exemplo 2 – Quando COUNT_BIG() é obrigatório
Aqui está um exemplo de onde você precisa usar
COUNT_BIG() . SELECT COUNT_BIG(*) AS 'Row Count' FROM ReallyBigTable;
Resultado:
+-----------------+ | Row Count | |-----------------| | 9147483648 | +-----------------+
Nesse caso, a contagem de linhas é tão grande que um int não seria capaz de lidar com isso. Felizmente podemos usar
COUNT_BIG() , porque retorna seu resultado como um bigint . Verificando o tipo de dados de ambas as funções
Quando olhamos para os exemplos anteriores, não podemos realmente ver o nome do tipo de dados. Podemos apenas supor que
COUNT() retorna seus resultados como um int e COUNT_BIG() usa bigint porque é isso que a documentação da Microsoft diz (embora saibamos que o segundo exemplo não pode ser um int porque o valor é muito grande para um int ). Podemos usar o
sp_describe_first_result_set procedimento armazenado para verificar o tipo de dados de retorno de cada uma dessas funções. Verifique o tipo de dados para COUNT()
EXEC sp_describe_first_result_set N'SELECT COUNT(*) FROM Fact.[Order]', null, 0;
Resultado (usando saída vertical):
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
Sim, há muitas informações que não precisamos, mas se você olhar para o system_type_name coluna, você verá que seu valor é int . Isso nos diz que nossa consulta retornou seus resultados como um int , como esperado. Você também pode ver que o max_length e precisão os valores são consistentes com o int tipo de dados.
Verifique o tipo de dados para COUNT_BIG()
Para este exemplo, tudo o que precisamos fazer é substituir
COUNT(*) com COUNT_BIG(*) :EXEC sp_describe_first_result_set N'SELECT COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Resultado (usando saída vertical):
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
Desta vez podemos ver que system_type_name é grande . Isso nos diz que nosso
COUNT_BIG() consulta retornou seus resultados como um bigint , como esperado. O
max_length
e
precisão
os valores também são consistentes com o bigint tipo de dados. By the way, uma maneira mais rápida de fazer o acima é combinar ambas as funções na consulta ao chamar o procedimento armazenado.
Assim:
EXEC sp_describe_first_result_set N'SELECT COUNT(*), COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Isso produzirá duas linhas, uma para cada função no
SELECT demonstração. 
