Hoe COUNT_BIG() werkt in SQL Server

In SQL Server, de COUNT_BIG() functie retourneert het aantal items dat in een groep is gevonden. Je kunt het gebruiken om erachter te komen hoeveel rijen er in een tabel of resultatenset zitten.

Deze functie werkt vergelijkbaar met de COUNT() functie. Het verschil is dat COUNT() geeft het resultaat terug als een int , terwijl COUNT_BIG() geeft het resultaat terug als een bigint .

Daarom COUNT_BIG() kan van pas komen als u verwacht dat uw resultatenset een zeer groot aantal rijen zal hebben (d.w.z. groter dan 2.147.483.647).

Syntaxis

De syntaxis gaat als volgt:

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

ALL past de aggregatiefunctie toe op alle waarden. Dit is de standaardwaarde.

DISTINCT specificeert dat de functie het aantal unieke niet-null-waarden retourneert.

expression is een uitdrukking van elk type. Geaggregeerde functies en subquery's worden niet ondersteund in de expressie.

* geeft aan dat alle rijen moeten worden geteld en geretourneerd, inclusief dubbele rijen en rijen die null-waarden bevatten. COUNT(*) neemt geen parameters en ondersteunt het gebruik van DISTINCT . niet . Het vereist ook geen uitdrukking parameter (omdat het geen informatie over een bepaalde kolom gebruikt).

OVER ( [ <partition_by_clause> ] verdeelt de resultatenset geproduceerd door de FROM clausule in partities waarop de functie wordt toegepast. Indien niet gespecificeerd, behandelt de functie alle rijen van de queryresultatenset als een enkele groep.

Voorbeeld 1 – Basisgebruik

Hier is een eenvoudig voorbeeld dat laat zien hoe deze functie werkt:

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

Resultaat:

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

In dit geval zijn er 231412 rijen in de Fact.[Order] tafel.

In dit geval had ik COUNT() . kunnen gebruiken om hetzelfde resultaat te retourneren, omdat het aantal rijen klein genoeg is voor een int te hanteren.

Voorbeeld 2 – Een grotere resultatenset

Het echte voordeel van het gebruik van COUNT_BIG() is wanneer uw resultatenset veel groter is dan het vorige voorbeeld.

Voorbeeld:

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

Resultaat:

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

In dit geval is het aantal rijen zo groot dat een int zou het niet aankunnen. Gelukkig kunnen we COUNT_BIG() . gebruiken , omdat het het resultaat retourneert als een bigint .

Meer voorbeelden

Zie voor meer voorbeelden Hoe COUNT() Werkt in SQL Server. Dat artikel geeft meer voorbeelden dan hier vermeld, die allemaal ook van toepassing zijn op COUNT_BIG() .

Een alternatief:APPROX_COUNT_DISTINCT()

Als u met zeer grote datasets werkt, kunt u overwegen om APPROX_COUNT_DISTINCT() te gebruiken in plaats van COUNT_BIG(DISTINCT ) in sommige gevallen.

APPROX_COUNT_DISTINCT() geeft een geschatte waarde terug in plaats van een precieze waarde. Het is echter ontworpen om veel responsiever te zijn dan COUNT_BIG() , dus het kan handig zijn in tijden dat reactievermogen belangrijker is dan precisie.

Het is ontworpen om unieke, niet-null-waarden te retourneren, dus het zou alleen relevant zijn voor momenten waarop u normaal gesproken de DISTINCT zou gebruiken clausule met COUNT_BIG() .

Houd er ook rekening mee dat op het moment van schrijven APPROX_COUNT_DISTINCT() bevindt zich in de openbare voorbeeldstatus.