In SQL Server, il COUNT_BIG() funzione e il COUNT() fare essenzialmente la stessa cosa:restituire il numero di elementi trovati in un gruppo. Fondamentalmente, puoi utilizzare queste funzioni per scoprire quante righe ci sono in una tabella o in un set di risultati.
In molti casi, potrai scegliere quello che preferisci. Tuttavia, c'è una differenza tra queste due funzioni che potrebbe imporre di utilizzare l'una sull'altra.
La differenza è che COUNT() restituisce il risultato come int , mentre COUNT_BIG() restituisce il risultato come bigint .
In altre parole, dovrai utilizzare COUNT_BIG() se si prevede che i risultati siano maggiori di 2.147.483.647 (ovvero se la query restituisce più di 2.147.483.647 righe).
Esempio 1 – Quando COUNT() è OK
Ecco un esempio di base che mostra uno scenario in cui entrambi COUNT() e COUNT_BIG() può essere utilizzato:
USE WideWorldImportersDW; SELECT COUNT(*) AS 'COUNT', COUNT_BIG(*) AS 'COUNT_BIG' FROM Fact.[Order];
Risultato:
+---------+-------------+ | COUNT | COUNT_BIG | |---------+-------------| | 231412 | 231412 | +---------+-------------+
Possiamo vedere che ci sono 231412 righe in Fact.[Order] tabella.
In questo caso, entrambe le funzioni possono gestirlo, perché il conteggio delle righe è sufficientemente piccolo da poter essere archiviato in un int oltre a un bigint .
Tuttavia, se il risultato è stato così grande che un int non è stato possibile memorizzarlo, quindi potremmo solo utilizzare COUNT_BIG() .
Esempio 2:quando è richiesto COUNT_BIG()
Ecco un esempio di dove dovresti usare COUNT_BIG() .
SELECT COUNT_BIG(*) AS 'Row Count' FROM ReallyBigTable;
Risultato:
+-----------------+ | Row Count | |-----------------| | 9147483648 | +-----------------+
In questo caso, il conteggio delle righe è così grande che un int non sarebbe in grado di gestirlo. Fortunatamente possiamo usare COUNT_BIG() , perché restituisce il risultato come bigint .
Verifica del tipo di dati di entrambe le funzioni
Quando esaminiamo gli esempi precedenti, non possiamo effettivamente vedere il nome del tipo di dati. Possiamo solo presumere che COUNT() restituisce i risultati come int e COUNT_BIG() utilizza bigint perché questo è ciò che dice la documentazione Microsoft (anche se sappiamo che il secondo esempio non potrebbe essere un int perché il valore è troppo grande per un int ).
Possiamo usare il sp_describe_first_result_set stored procedure per verificare il tipo di dati di ritorno di ciascuna di queste funzioni.
Controlla il tipo di dati per COUNT()
EXEC sp_describe_first_result_set N'SELECT COUNT(*) FROM Fact.[Order]', null, 0;
Risultato (usando l'output 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
Sì, ci sono molte informazioni di cui non abbiamo bisogno, ma se guardi il system_type_name colonna, vedrai che il suo valore è int . Questo ci dice che la nostra query ha restituito i risultati come int , come previsto. Puoi anche vedere che max_length e precisione i valori sono coerenti con int tipo di dati.
Controlla il tipo di dati per COUNT_BIG()
Per questo esempio, tutto ciò che dobbiamo fare è sostituire COUNT(*) con COUNT_BIG(*) :
EXEC sp_describe_first_result_set N'SELECT COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Risultato (usando l'output 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
Questa volta possiamo vedere quel
system_type_name
è
bigint
. Questo ci dice che il nostro COUNT_BIG() query ha restituito i risultati come bigint , come previsto. La
lunghezza_max
e
precisione
i valori sono coerenti anche con il bigint tipo di dati.
A proposito, un modo più rapido per eseguire quanto sopra consiste nel combinare entrambe le funzioni nella query quando si chiama la stored procedure.
In questo modo:
EXEC sp_describe_first_result_set N'SELECT COUNT(*), COUNT_BIG(*) FROM Fact.[Order]', null, 0;
Ciò produrrà due righe, una per ciascuna funzione in SELECT dichiarazione.
