Wanneer u met databases werkt, wilt u soms weten hoeveel rijen er door een query worden geretourneerd, zonder de resultaten van de query daadwerkelijk te retourneren. Of soms wil je gewoon weten hoeveel rijen er in een bepaalde tabel zitten.
In SQL Server kunt u T-SQL's COUNT() . gebruiken functie om het aantal rijen terug te geven dat in een zoekopdracht zou worden geretourneerd.
De gegevens
Dit zijn de gegevens die we zullen gebruiken in de voorbeelden op deze pagina:
SELECT * FROM Tasks;
Resultaat:
TaskId TaskName TaskDescription TaskCode ------ ------------ --------------- -------- 1 Feed cats TBA null 2 Water dog TBA null 3 Feed garden TBA null 4 Paint carpet TBA null 5 Clean roof TBA null 6 Feed cats TBA null
Voorbeeld – Tel alle rijen in een tabel
Hier is een voorbeeld van het gebruik van de COUNT() functie om het totale aantal rijen in een tabel te retourneren:
SELECT COUNT(*) FROM Tasks;
Resultaat:
6
Dit retourneert het aantal rijen in de tabel omdat we geen criteria hebben opgegeven om de resultaten te verfijnen.
Voorbeeld – Criteria toevoegen
Hier is een voorbeeld van het tellen hoeveel rijen zouden worden geretourneerd op basis van een bepaald criterium:
SELECT COUNT(*) FROM Tasks WHERE TaskName LIKE '%dog%' OR TaskName LIKE '%cat%';
Resultaat:
3
Voorbeeld – Specificeer een enkele kolom
De vorige voorbeelden gebruiken allemaal een asterisk om de telling op alle kolommen toe te passen. Je hebt ook de mogelijkheid om een specifieke kolom op te geven.
Voorbeeld:
SELECT COUNT(TaskName) FROM Tasks;
Resultaat:
6
Hoewel dit voorbeeld hetzelfde resultaat oplevert dat we kregen toen we de asterisk gebruikten, is dat niet altijd het geval. Dit is bijvoorbeeld wat er gebeurt als we een andere kolom specificeren:
SELECT COUNT(TaskCode) FROM Tasks;
Resultaat:
0
In dit geval krijgen we nul, omdat die bepaalde kolom null-waarden bevat in elke rij.
Voorbeeld – Duidelijk
U kunt de DISTINCT . toevoegen argument om alleen het aantal unieke (niet-null) waarden te retourneren.
Het is je misschien opgevallen dat elke rij in onze TaskDescription kolom dezelfde waarde (“TBA”) bevat. En de TaskName kolom heeft ook een dubbele waarde (“Feed cats” verschijnt twee keer). Dit kan problemen veroorzaken als u niet wilt dat duplicaten worden geteld.
Zo ziet het eruit als we de DISTINCT . toepassen argument aan de TaskName kolom:
SELECT COUNT(DISTINCT TaskName) FROM Tasks;
Resultaat:
5
En hier wordt het toegepast tegen de TaskDescription tabel (waar alle waarden identiek zijn):
SELECT COUNT(DISTINCT TaskDescription) FROM Tasks;
Resultaat:
1
Voorbeeld – De HAVING-clausule
U kunt ook COUNT() . gebruiken met de HAVING clausule om een resultaatset te beperken op basis van het aantal rijen dat zou worden geretourneerd.
Voorbeeld:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 1;
Resultaat:
ArtistName Album Count ------------------------- ----------- Allan Holdsworth 2 Devin Townsend 3 Iron Maiden 5 Michael Learns to Rock 3 Tom Jones 3
Dit voorbeeld gebruikt een andere database dan de vorige voorbeelden. Het geeft alleen artiesten terug die meer dan 1 album hebben uitgebracht. We kunnen dat aantal veranderen, hoeveel albums we ook willen:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 4;
Resultaat:
ArtistName Album Count ------------------------- ----------- Iron Maiden 5
De COUNT_BIG() Functie
T-SQL heeft ook een COUNT_BIG() functie die precies werkt als COUNT() , behalve dat COUNT() retourneert een int gegevenstype en COUNT_BIG() retourneert een grote gegevenstype.
Deze functie kan handig zijn voor geïndexeerde views met gegroepeerde queries. Mogelijk vindt u dit als u een index probeert te maken voor een weergave die COUNT(*) . bevat , dat u een foutmelding als deze krijgt:
Cannot create index on view "Music.dbo.AlbumsByArtist" because it uses the aggregate COUNT. Use COUNT_BIG instead.
In dergelijke gevallen, de weergave wijzigen om COUNT_BIG(*) te gebruiken zou het probleem moeten oplossen.