In SQL is de COUNT() functie is een verzamelfunctie die het aantal gevonden items in een groep teruggeeft.
U kunt COUNT() . gebruiken in meerdere delen van een query. U kunt het bijvoorbeeld gebruiken in de SELECT lijst, of de HAVING clausule bij het filteren van groepen.
Voorbeeldtabel
Stel dat we de volgende tabel hebben:
SELECT * FROM Pets;Resultaat:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
De volgende voorbeelden gebruiken de COUNT() functie bij het opvragen van deze tabel.
Voorbeeld
Hier is een eenvoudig voorbeeld om aan de slag te gaan.
SELECT COUNT(*) AS Count
FROM Pets;Resultaat:
+---------+ | Count | |---------| | 8 | +---------+
Dit vertelt ons dat er 8 rijen in de tabel zijn. Dat weten we omdat we het asterisk-jokerteken (* . hebben gebruikt) ) om alle rijen en alle kolommen op te geven.
Tel een specifieke kolom
U kunt ook een bepaalde kolom opgeven om te tellen. De COUNT() functie telt alleen niet-NULL resultaten, dus als u een kolom specificeert die NULL . bevat waarden, worden die waarden niet meegeteld.
Hier is een voorbeeld om te laten zien wat ik bedoel.
SELECT COUNT(DOB) AS Count
FROM Pets;Resultaat:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
In dit geval de Pets tabel bevat twee NULL waarden in de DOB kolom (twee huisdieren hebben hun geboortedatum niet opgegeven), en dus COUNT(DOB) geeft 6 terug, in plaats van 8 toen we COUNT(*) gebruikten .
De reden COUNT(*) in het vorige voorbeeld alle rijen retourneerde, is omdat die twee rijen deed gegevens in de andere kolommen hebben.
In mijn voorbeeld heeft mijn DBMS hier ook een waarschuwing over geretourneerd. U kunt wel of geen waarschuwing krijgen, afhankelijk van uw DBMS en uw specifieke configuratie.
Gefilterde resultaten
De COUNT() functie telt de rijen die door de query worden geretourneerd. Dus als u de resultaten filtert, wordt het resultaat van COUNT() zal dat weerspiegelen.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Resultaat:
+---------+ | Count | |---------| | 2 | +---------+
In dit geval zijn er twee huisdieren met de naam Fluffy. Daarom zouden er twee rijen zijn geretourneerd door de zoekopdracht, en het resultaat van COUNT() is 2 .
Tel verschillende kolommen
Standaard is de COUNT() functie bevat een impliciete ALL trefwoord. Dit betekent dat het duplicaten in zijn resultaten opneemt.
Maar je hebt ook de mogelijkheid om de DISTINCT . toe te voegen trefwoord om op te geven dat alleen afzonderlijke waarden worden geretourneerd. Dat wil zeggen, u kunt specificeren dat duplicaten worden uitgesloten.
Laten we de PetName kiezen kolom. Als je naar de originele tabel hierboven kijkt, kun je zien dat de PetName kolom bevat twee rijen met dezelfde waarde (Fluffy ).
Eerst voeren we een COUNT(ALL PetName) . uit query om alle dubbele waarden in de telling op te nemen:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Resultaat:
+---------+ | Count | |---------| | 8 | +---------+
Er zijn dus acht rijen. Onthoud dat dit hetzelfde resultaat is dat we zouden krijgen als we de ALL . niet hadden opgenomen zoekwoord, omdat ALL is de standaard.
Nu voeren we een COUNT(DISTINCT PetName) om eventuele duplicaten van de telling te verwijderen.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Resultaat:
+---------+ | Count | |---------| | 7 | +---------+
Dit keer is het resultaat 7 . Dit komt omdat onze dubbele waarde is geëlimineerd. Dat wil zeggen, de dubbele waarde werd behandeld alsof er maar één waarde was.
Gebruik COUNT() met de HAVING Clausule
U kunt de COUNT() . opnemen functie in meerdere delen van een query. Het is niet alleen beperkt tot de SELECT lijst.
Hier is een voorbeeld dat COUNT() . gebruikt in zowel de HAVING clausule en de SELECT lijst.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Resultaat:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
In dit geval gebruikten we de HAVING clausule in combinatie met de GROUP BY clausule om alleen die rijen terug te geven die een COUNT(PetTypeId) . hebben groter dan 2 .
Je bent niet beperkt tot alleen de ) Operator voor beginners”>groter dan operator (> ) bij gebruik van de HAVING clausule. U kunt dezelfde operators gebruiken die u kunt gebruiken met de WHERE clausule (zoals = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , enz.).
Zie SQL-operators voor een lijst met operators die beschikbaar zijn in SQL.
Vensterfuncties
Afhankelijk van uw DBMS kunt u mogelijk een OVER . gebruiken clausule met uw COUNT() functie om een vensterfunctie te creëren.
Een vensterfunctie voert een aggregatie-achtige bewerking uit op een set queryrijen. Het produceert een resultaat voor elke queryrij. Dit in tegenstelling tot een aggregatiebewerking, waarbij queryrijen worden gegroepeerd in een enkele resultaatrij.
Hier is een voorbeeld om het concept te demonstreren.
We hebben de Pets al gezien tafel. Onze database heeft ook een Owners tabel, en het bevat de volgende gegevens:
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
We kunnen gegevens uit deze tabellen halen en ze presenteren als één resultaatset door een join te gebruiken.
We kunnen ook de COUNT() . gebruiken functie met de OVER clausule om een vensterfunctie op de gegevens toe te passen.
SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;Resultaat:
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
In dit geval gebruikten we de OVER clausule met onze COUNT() clausule om de telling te verdelen in alleen de naam van de eigenaar.
Het resultaat is dat eigenaren met meerdere huisdieren op meerdere rijen worden weergegeven (omdat elk huisdier ook moet worden weergegeven), en elke rij bevat het totale aantal huisdieren van die eigenaar.
Dit concept kan ook worden toegepast op andere statistische functies in SQL, zoals SUM() , MIN() , MAX() , en AVG() .
COUNT_BIG()
Als u serieus grote datasets in SQL Server meetelt, kan het zijn dat de COUNT() functie geeft een fout omdat het nummer te hoog is. Dit gebeurt alleen als uw aantal groter is dan 2.147.483.647.
In dergelijke gevallen kunt u COUNT_BIG() . gebruiken , die geschikt is voor veel grotere aantallen.
Zie hoe COUNT_BIG() Werkt in SQL Server en COUNT() vs COUNT_BIG() voor een meer gedetailleerde uitleg.
ANSI SQL-standaard
De COUNT() functie wordt vermeld in de SQL-standaard en is beschikbaar in de meeste (zo niet alle) van de belangrijkste DBMS'en, en werkt vrijwel hetzelfde voor alle DBMS'en.
Voor codevoorbeelden gedaan in verschillende DBMS'en, zie SQLite COUNT() , SQL Server COUNT() , en MySQL COUNT() .