I SQL er COUNT() funktion er en aggregeret funktion, der returnerer antallet af elementer fundet i en gruppe.
Du kan bruge COUNT() i flere dele af en forespørgsel. For eksempel kan du bruge det i SELECT listen eller HAVING klausul ved filtrering af grupper.
Eksempeltabel
Antag, at vi har følgende tabel:
SELECT * FROM Pets;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Følgende eksempler vil bruge COUNT() funktion, når du forespørger i denne tabel.
Eksempel
Her er et enkelt eksempel for at komme i gang.
SELECT COUNT(*) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 8 | +---------+
Dette fortæller os, at der er 8 rækker i tabellen. Vi ved det, fordi vi brugte stjerne-jokertegnet (* ) for at angive alle rækker og alle kolonner.
Tæl en specifik kolonne
Du kan også angive en bestemt kolonne, der skal tælles. COUNT() funktion tæller kun ikke-NULL resultater, så hvis du angiver en kolonne, der indeholder NULL værdier, vil disse værdier ikke blive talt med.
Her er et eksempel for at vise, hvad jeg mener.
SELECT COUNT(DOB) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
I dette tilfælde er Kæledyr tabel indeholder to NULL værdier i DOB kolonne (to kæledyr har ikke oplyst deres fødselsdato), og så COUNT(DOB) returnerer 6 i stedet for 8, når vi brugte COUNT(*) .
Årsagen COUNT(*) i det forrige eksempel returnerede alle rækker, fordi de to rækker gjorde har data i de andre kolonner.
I mit eksempel returnerede mit DBMS også en advarsel om dette. Du kan muligvis ikke få en advarsel, afhængigt af dit DBMS og din specifikke konfiguration.
Filtrerede resultater
COUNT() funktion tæller rækkerne, der returneres af forespørgslen. Så hvis du filtrerer resultaterne, er resultatet af COUNT() vil afspejle det.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+ | Count | |---------| | 2 | +---------+
I dette tilfælde er der to kæledyr med navnet Fluffy. Derfor ville to rækker være blevet returneret af forespørgslen og resultatet af COUNT() er 2 .
Tæl forskellige kolonner
Som standard er COUNT() funktion inkluderer en implicit ALL søgeord. Det betyder, at den inkluderer dubletter i sine resultater.
Men du har også mulighed for at tilføje DISTINCT nøgleord for at angive, at der kun returneres forskellige værdier. Det vil sige, at du kan angive, at det udelukker dubletter.
Lad os vælge PetName kolonne indeholder to rækker med samme værdi (Fluffy ).
Først kører vi en COUNT(ALL PetName) forespørgsel for at inkludere alle duplikerede værdier i optællingen:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 8 | +---------+
Så der er otte rækker. Husk, at dette er det samme resultat, som vi ville få, hvis vi ikke havde inkluderet ALL søgeord, fordi ALL er standard.
Nu kører vi en COUNT(DISTINCT PetName) for at fjerne eventuelle dubletter fra optællingen.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 7 | +---------+
Denne gang er resultatet 7 . Dette skyldes, at vores duplikatværdi blev elimineret. Det vil sige, at duplikatværdien blev behandlet, som om der kun var én værdi.
Ved brug af COUNT() med HAVING Klausul
Du kan inkludere COUNT() fungerer i flere dele af en forespørgsel. Det er ikke kun begrænset til SELECT liste.
Her er et eksempel, der bruger COUNT() i både HAVING klausulen og SELECT liste.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Resultat:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
I dette tilfælde brugte vi HAVING klausul i forbindelse med GROUP BY klausul for kun at returnere de rækker, der har en COUNT(PetTypeId) på større end 2 .
Du er ikke begrænset til kun ) Operatør for begyndere">større end operatør (> ) når du bruger HAVING klausul. Du kan bruge de samme operatorer, som du kan bruge med WHERE klausul (såsom = , ) Operatør for begyndere">< , =) Operatør for begyndere">>= , IN , LIKE osv.).
Se SQL-operatører for en liste over tilgængelige operatorer i SQL.
Vinduefunktioner
Afhængigt af dit DBMS, kan du muligvis bruge en OVER klausul med din COUNT() funktion for at oprette en vinduesfunktion.
En vinduesfunktion udfører en aggregatlignende operation på et sæt forespørgselsrækker. Det producerer et resultat for hver forespørgselsrække. Dette er i modsætning til en aggregeret operation, som grupperer forespørgselsrækker i en enkelt resultatrække.
Her er et eksempel for at demonstrere konceptet.
Vi har allerede set Kæledyr bord. Vores database har også en Ejere tabel, og den indeholder følgende data:
+-----------+-------------+------------+----------------+-------------------+ | 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] | +-----------+-------------+------------+----------------+-------------------+
Vi kan hente data fra disse tabeller og præsentere dem som ét resultatsæt ved at bruge en join.
Vi kan også bruge COUNT() funktion med OVER klausul for at anvende en vinduesfunktion til dataene.
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;Resultat:
+---------------+-----------+----------------------------------+ | 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 | +---------------+-----------+----------------------------------+
I dette tilfælde brugte vi OVER klausul med vores COUNT() klausul for at opdele antallet til kun ejerens navn.
Resultatet er, at ejere med flere kæledyr vises på flere rækker (fordi hvert kæledyr også skal vises), og hver række indeholder det samlede antal af denne ejers kæledyr.
Dette koncept kan også anvendes på andre aggregerede funktioner i SQL, såsom SUM() , MIN() , MAX() og AVG() .
COUNT_BIG()
Hvis du tæller seriøst store datasæt i SQL Server, vil du muligvis opdage, at COUNT() funktion producerer en fejl, fordi tallet er for højt. Dette vil kun ske, dit antal er større end 2.147.483.647.
I sådanne tilfælde kan du bruge COUNT_BIG() , som kan tage højde for meget større antal.
Se hvordan COUNT_BIG() Virker i SQL Server og COUNT() vs COUNT_BIG() for en mere detaljeret forklaring.
ANSI SQL Standard
COUNT() funktion er opført i SQL-standarden, og den er tilgængelig i de fleste (hvis ikke alle) af de store DBMS'er og fungerer stort set det samme på tværs af dem.
For kodeeksempler udført i forskellige DBMS'er, se SQLite COUNT() , SQL Server COUNT() , og MySQL COUNT() .