Hur COUNT_BIG() fungerar i SQL Server

I SQL Server, COUNT_BIG() funktion returnerar antalet objekt som finns i en grupp. Du kan använda den för att ta reda på hur många rader som finns i en tabell eller resultatuppsättning.

Den här funktionen fungerar på samma sätt som COUNT() fungera. Skillnaden är att COUNT() returnerar resultatet som en int , medan COUNT_BIG() returnerar resultatet som en bigint .

Därför COUNT_BIG() kan vara praktiskt om du förväntar dig att din resultatuppsättning har ett mycket stort antal rader (dvs. större än 2 147 483 647).

Syntax

Syntaxen ser ut så här:

-- Aggregation Function Syntax  
COUNT_BIG ( { [ [ ALL | DISTINCT ] expression ] | * } )  
  
-- Analytic Function Syntax  
COUNT_BIG ( [ ALL ] { expression | * } ) OVER ( [  ] )

ALL tillämpar den aggregerade funktionen på alla värden. Detta är standardvärdet.

DISTINCT anger att funktionen returnerar antalet unika icke-nullvärden.

expression är ett uttryck av vilken typ som helst. Aggregatfunktioner och underfrågor stöds inte i uttrycket.

* anger att alla rader ska räknas och returneras, inklusive dubbletter av rader och rader som innehåller nollvärden. COUNT(*) tar inga parametrar och stöder inte användningen av DISTINCT . Det kräver inte heller ett uttryck parameter (eftersom den inte använder information om någon särskild kolumn).

OVER ( [ <partition_by_clause> ] delar resultatuppsättningen som produceras av FROM sats i partitioner som funktionen tillämpas på. Om det inte anges, behandlar funktionen alla rader i frågeresultatuppsättningen som en enda grupp.

Exempel 1 – Grundläggande användning

Här är ett grundläggande exempel som visar hur den här funktionen fungerar:

USE WideWorldImportersDW;
SELECT COUNT_BIG(*) AS 'Row Count' 
FROM Fact.[Order];

Resultat:

+-------------+
| Row Count   |
|-------------|
| 231412      |
+-------------+

I det här fallet finns det 231412 rader i Fakta.[Order] bord.

I det här fallet kunde jag ha använt COUNT() för att returnera samma resultat, eftersom radantalet är tillräckligt litet för en int att hantera.

Exempel 2 – En större resultatuppsättning

Den verkliga fördelen med att använda COUNT_BIG() är när din resultatuppsättning är mycket större än föregående exempel.

Exempel:

SELECT COUNT_BIG(*) AS 'Row Count' 
FROM ReallyBigTable;

Resultat:

+-----------------+
| Row Count       |
|-----------------|
| 9147483648      |
+-----------------+

I det här fallet är radantalet så stort att en int inte skulle kunna hantera det. Lyckligtvis kan vi använda COUNT_BIG() , eftersom det returnerar sitt resultat som en bigint .

Fler exempel

För fler exempel, se Hur COUNT() Fungerar i SQL Server. Den artikeln ger fler exempel än vad som anges här, som alla även är tillämpliga på COUNT_BIG() .

Ett alternativ:APPROX_COUNT_DISTINCT()

Om du arbetar med mycket stora datamängder kan du överväga att använda APPROX_COUNT_DISTINCT() istället för COUNT_BIG(DISTINCT ) i vissa fall.

APPROX_COUNT_DISTINCT() returnerar ett ungefärligt värde snarare än ett exakt värde. Den är dock utformad för att vara mycket mer lyhörd än COUNT_BIG() , så det kan vara användbart för tillfällen då lyhördhet är viktigare än precision.

Det är utformat för att returnera unika, icke-nullvärden, så det skulle bara vara relevant för tillfällen då du normalt skulle använda DISTINCT sats med COUNT_BIG() .

Observera också att APPROX_COUNT_DISTINCT() vid skrivande stund är i offentlig förhandsvisningsstatus.