Hur COUNT() fungerar i SQL Server

I SQL Server, COUNT() 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.

Syntax

Syntaxen ser ut så här:

-- Aggregationsfunktionssyntax COUNT ({[[ALLA | DISTINCT] uttryck] | *}) - Analytisk funktionssyntax COUNT ([ALLA] { uttryck | *}) ÖVER ([])

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, utom bild , ntext , eller text . 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:

VÄLJ ANTAL(*) SOM "Radräkning"Från artister;

Resultat:

+-------------+| Antal rader ||-------------|| 16 |+--------------+

I det här fallet finns det 16 rader i Artister bord.

Bara för att vara säker, här är de:

VÄLJ *FRÅN artister;

Resultat:

+------------+------------------------+-------- ------+-------------+| ArtistId | Artistnamn | AktivFrån | CountryId ||------------+------------------------+--------- -----+--------------------|| 1 | Iron Maiden | 1975-12-25 | NULL || 2 | AC/DC | 1973-01-11 | NULL || 3 | Allan Holdsworth | 1969-01-01 | NULL || 4 | Buddy Rich | 1919-01-01 | NULL || 5 | Devin Townsend | 1993-01-01 | NULL || 6 | Jim Reeves | 1948-01-01 | NULL || 7 | Tom Jones | 1963-01-01 | NULL || 8 | Maroon 5 | 1994-01-01 | NULL || 9 | Manuset | 2001-01-01 | NULL || 10 | Tänd | 1988-06-26 | NULL || 11 | Black Sabbath | 1968-01-01 | NULL || 12 | Michael lär sig rocka | 1988-03-15 | NULL || 13 | Carabao | 1981-01-01 | NULL || 14 | Karnivool | 1997-01-01 | NULL || 15 | Tokyos fåglar | 2004-01-01 | NULL || 16 | Bodyjar | 1990-01-01 | NULL |+------------+------------------------+-------- -----+--------------------+

Som förväntat returneras 16 rader.

Lägg märke till att CountryId kolumnen innehåller inget annat än nullvärden. Detta kommer att vara användbart för nästa exempel.

Exempel 2 – Ange en kolumn

I det föregående exemplet användes en asterisk (* ) för att ange alla rader. Detta resulterar i att alla rader räknas, oavsett om det finns dubbletter eller om några innehåller nollvärden.

Du kan också ange en viss kolumn. När du gör detta räknas inte nollvärden. Det vill säga alla rader som innehåller ett nullvärde för den kolumnen räknas inte.

Här är ett exempel med CountryId kolumn som nämnts i föregående exempel:

VÄLJ ANTAL(CountryId) SOM 'Row Count'FROM artister;

Resultat:

+-------------+| Antal rader ||-------------|| 0 |+-------------+

Som vi såg i föregående exempel är alla rader för denna kolumn NULL . Därför är det resulterande radantalet noll.

Låt oss lägga till några värden i den kolumnen:

UPDATE ArtistsSET CountryId =2WHERE ArtistName IN ( 'AC/DC', 'Karnivool', 'Birds of Tokyo', 'Bodyjar' );

Låt oss nu räkna raderna för den kolumnen igen:

VÄLJ ANTAL(CountryId) SOM 'Row Count'FROM artister;

Resultat:

+-------------+| Antal rader ||-------------|| 4 |+-------------+

Exempel 3 – Med DISTINKT

Det här exemplet använder DISTINCT sats för att endast returnera distinkta rader (d.v.s. icke-dubbletter).

I föregående exempel uppdaterade jag tabellen så att samma CountryId tillämpades på fyra artister (jag använde SET CountryId = 2 för alla fyra artisterna). Detta resulterade i fyra rader med samma CountryId .

Här är vad som händer om jag räknar hur många distinkta CountryId s finns i den tabellen:

SELECT COUNT(DISTINCT CountryId) 'Distinct CountryIds'FROM Artists;

Resultat:

+------------------------------+| Distinkta CountryIds ||-----------------------------|| 1 |+------------------------------+

Detta är att vänta, eftersom även om det finns fyra rader med ett CountryId , det är fortfarande bara ett distinkt CountryId .

Bara för att vara säker, låt oss köra den tillsammans med dess "icke distinkta" version:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Resultat:

+----------------+------------+| Icke distinkt | Distinkt ||----------------+------------|| 4 | 1 |+----------------+------------+

Så den icke distinkta versionen visar hur många gånger CountryId visas i tabellen, medan DISTINCT versionen räknar flera förekomster som 1.

Låt oss lägga till ytterligare ett CountryId till bordet:

UPDATE ArtistsSET CountryId =1WHERE ArtistName ='Carabao';

Och kör nu frågan igen:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Resultat:

+----------------+------------+| Icke distinkt | Distinkt ||----------------+------------|| 5 | 2 |+----------------+------------+

Exempel 4 – Använd en WHERE-klausul

Här är ett snabbt exempel med en WHERE klausul.

VÄLJ ANTAL(*) SOM 'Row Count'FROM ArtistsWHERE ActiveFrom>='2000-01-01';

Resultat:

+-------------+| Antal rader ||-------------|| 2 |+-------------+

Exempel 5 – Med GROUP BY

Här är ett exempel på att gruppera artisterna i en kolumn och sedan räkna alla album för varje artist i den andra kolumnen.

Exempel:

VÄLJ Artistnamn, COUNT(al.AlbumId) 'Antal album'FRÅN artister arINNER JOIN Album ALON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Number of Albums' DESC;

Resultat:

+------------------------+------------------------+ | Artistnamn | Antal album ||------------------------+------------------------ || Iron Maiden | 5 || Michael lär sig rocka | 3 || Manuset | 3 || Tom Jones | 3 || Devin Townsend | 3 || Allan Holdsworth | 2 || Buddy Rich | 1 || AC/DC | 1 || Jim Reeves | 1 |+------------------------+--------------------+

Exempel 6 – Med HAVING-klausulen

Vi kan justera det föregående exemplet så att det bara inkluderar de artister som har fler än ett visst antal album. Vi kan göra detta med hjälp av HAVING klausul.

VÄLJ Artistnamn, COUNT(al.AlbumId) 'Antal album'FRÅN artister arINNER JOIN Albums ALON al.ArtistId =ar.ArtistIdGROUP EFTER ArtistNameHAR COUNT(al.AlbumId)> 2ORDNING EFTER 'Antal album' DESC; 

 Resultat:
 
+------------------------+------------------------+ | Artistnamn | Antal album ||------------------------+------------------------ || Iron Maiden | 5 || Michael lär sig rocka | 3 || Manuset | 3 || Tom Jones | 3 || Devin Townsend | 3 |+------------------------+--------------------+
 
Exempel 7 – Partitionering med OVER-klausulen
 

 Du kan använda OVER sats med PARTITION BY för att dela upp resultaten i partitioner. 
 

 I det här exemplet använder jag OVER (PARTITION BY ArtistName) för att lista ut varje album som artisten har producerat, samt det totala antalet album för den artisten. 
 
SELECT ArtistName, AlbumName, COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Antal album från denna artist'FRÅN Artister arINNER JOIN Album ALON al.ArtistId =ar.ArtistIdORDER BY 'Antal album från denna artist' DESC; 
 

 Resultat:
 
+------------------------+--------------------------- -----+---------------------------------------------+| Artistnamn | Albumnamn | Antal album från denna artist ||------------------------+---------------- ----------+--------------------------------------------|| Iron Maiden | Powerslave | 5 || Iron Maiden | Någonstans i tiden | 5 || Iron Maiden | Piece of Mind | 5 || Iron Maiden | Mördare | 5 || Iron Maiden | Ingen bön för de döende | 5 || AC/DC | Powerage | 3 || AC/DC | Back in Black | 3 || AC/DC | Rock or Bust | 3 || Michael lär sig rocka | Blå natt | 3 || Michael lär sig rocka | Evigheten | 3 || Michael lär sig rocka | Skandinavien | 3 || Devin Townsend | Ziltoid den Allvetande | 3 || Devin Townsend | Förluster av Cool | 3 || Devin Townsend | Epicloud | 3 || Tom Jones | Långt borttappad resväska | 3 || Tom Jones | Beröm och skuld | 3 || Tom Jones | Med kom Jones | 3 || Allan Holdsworth | Hela natten fel | 2 || Allan Holdsworth | De sexton männen från Tain | 2 || Buddy Rich | Big Swing Face | 1 || Jim Reeves | Singing Down the Lane | 1 || Manuset | Inget ljud utan tystnad | 1 |+------------------------+---------------------- ----+--------------------------------------------+
 

 Observera att detta gör att antalet artister och album upprepas över flera rader, men detta kan förväntas när vi också vill lista ut varje album på sin egen rad.
 
Exempel 8 – Med STRING_AGG()
 

 Om du inte vill att antalet artister och album ska upprepas över flera rader som i föregående exempel, kan du alltid använda STRING_AGG() funktion för att mata ut albumen som en lista. I det här fallet skulle du inte behöva OVER klausul.
 

 Exempel:
 
SELECT ArtistName, STRING_AGG(AlbumName, ', ') 'Albums', COUNT(AlbumId) 'Count'FROM Artists arINNER JOIN Album ALON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER BY 'Count' DESC;
 

 Resultat:
 
+------------------------+--------------------------- -------------------------------------------------- ----------+---------+| Artistnamn | Album | Räkna ||------------------------+---------------------- -------------------------------------------------- --------+---------|| Iron Maiden | Powerslave, Somewhere in Time, Piece of Mind, Killers, No Prayer for the Dieing | 5 || AC/DC | Powerage, tillbaka i svart, rock eller byst | 3 || Michael lär sig rocka | Blue Night, Eternity, Scandinavia | 3 || Devin Townsend | Ziltoid den Allvetande, Casualties of Cool, Epicloud | 3 || Tom Jones | Lång förlorad resväska, beröm och skuld, tillsammans kom Jones | 3 || Allan Holdsworth | All Night Wrong, The Sexteen Men of Tain | 2 || Buddy Rich | Big Swing Face | 1 || Jim Reeves | Singing Down the Lane | 1 || Manuset | Inget ljud utan tystnad | 1 |+------------------------+---------------------- -------------------------------------------------- --------+---------+
 
MÅNGA rader?
 

 COUNT() funktion returnerar sitt resultat som en int data typ. Om du har så många rader att resultatet blir större än vad int kan hantera, försök med COUNT_BIG() istället.
 

 COUNT_BIG() fungerar på samma sätt som COUNT() , förutom att dess resultat returneras som en bigint datatypsvärde.
 

 Du kan också överväga att använda APPROX_COUNT_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() och 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.