I SQL, COUNT() funktion är en aggregerad funktion som returnerar antalet objekt som finns i en grupp.
Du kan använda COUNT() i flera delar av en fråga. Du kan till exempel använda den i SELECT listan, eller HAVING sats vid filtrering av grupper.
Exempeltabell
Anta att vi har följande tabell:
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öljande exempel kommer att använda COUNT() funktion när du frågar den här tabellen.
Exempel
Här är ett enkelt exempel för att komma igång.
SELECT COUNT(*) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 8 | +---------+
Detta säger oss att det finns 8 rader i tabellen. Vi vet det eftersom vi använde asterisk-jokertecknet (* ) för att ange alla rader och alla kolumner.
Räkna en specifik kolumn
Du kan också ange att en viss kolumn ska räknas. COUNT() funktionen räknar endast icke-NULL resultat, så om du anger en kolumn som innehåller NULL värden, kommer dessa värden inte att räknas.
Här är ett exempel för att visa vad jag menar.
SELECT COUNT(DOB) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
I det här fallet, Husdjur Tabellen innehåller två NULL värden i DOB kolumnen (två husdjur har inte angett sitt födelsedatum) och så COUNT(DOB) returnerar 6 istället för 8 när vi använde COUNT(*) .
Orsaken COUNT(*) i föregående exempel returnerade alla rader, beror på att de två raderna gjorde har data i de andra kolumnerna.
I mitt exempel returnerade min DBMS också en varning om detta. Du får eller kanske inte får en varning, beroende på ditt DBMS och din specifika konfiguration.
Filtrerade resultat
COUNT() funktion räknar raderna som returneras av frågan. Så om du filtrerar resultaten blir resultatet av COUNT() kommer att återspegla det.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+ | Count | |---------| | 2 | +---------+
I det här fallet finns det två husdjur med namnet Fluffy. Därför skulle två rader ha returnerats av frågan och resultatet av COUNT() är 2 .
Räkna distinkta kolumner
Som standard är COUNT() funktionen inkluderar en implicit ALL nyckelord. Det betyder att den inkluderar dubbletter i sina resultat.
Men du har också möjlighet att lägga till DISTINCT nyckelord för att ange att bara distinkta värden returneras. Det vill säga, du kan ange att det utesluter dubbletter.
Låt oss välja PetName kolumn. Om du tittar på den ursprungliga tabellen ovan kan du se att PetName kolumnen innehåller två rader med samma värde (Fluffy ).
Först kör vi en COUNT(ALL PetName) fråga för att inkludera alla dubbletter av värden i antalet:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 8 | +---------+
Så det finns åtta rader. Kom ihåg att detta är samma resultat som vi skulle få om vi inte hade inkluderat ALL nyckelord, eftersom ALL är standard.
Nu kör vi en COUNT(DISTINCT PetName) för att eliminera eventuella dubbletter från räkningen.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Resultat:
+---------+ | Count | |---------| | 7 | +---------+
Den här gången är resultatet 7 . Detta beror på att vårt dubblettvärde har eliminerats. Det vill säga, dubblettvärdet behandlades som om det bara fanns ett värde.
Med COUNT() med HAVING Klausul
Du kan inkludera COUNT() fungerar i flera delar av en fråga. Det är inte bara begränsat till SELECT lista.
Här är ett exempel som använder COUNT() i både HAVING satsen och SELECT lista.
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 det här fallet använde vi HAVING sats i kombination med GROUP BY sats för att returnera bara de rader som har en COUNT(PetTypeId) större än 2 .
Du är inte begränsad till bara ) Operatör för nybörjare">större än operatör (> ) när du använder HAVING klausul. Du kan använda samma operatorer som du kan använda med WHERE klausul (som = , ) Operatör för nybörjare">< , =) Operatör för nybörjare">>= , IN , GILLA osv.).
Se SQL-operatorer för en lista över tillgängliga operatorer i SQL.
Fönsterfunktioner
Beroende på ditt DBMS kan du kanske använda en OVER sats med din COUNT() funktion för att skapa en fönsterfunktion.
En fönsterfunktion utför en aggregatliknande operation på en uppsättning frågerader. Det ger ett resultat för varje frågerad. Detta till skillnad från en aggregerad operation, som grupperar frågerader i en enda resultatrad.
Här är ett exempel för att demonstrera konceptet.
Vi har redan sett Husdjur tabell. Vår databas har också en Ägare tabell och den innehåller följande 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 hämta data från dessa tabeller och presentera dem som en resultatuppsättning genom att använda en join.
Vi kan också använda COUNT() funktion med OVER sats för att tillämpa en fönsterfunktion på data.
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 det här fallet använde vi OVER sats med vår COUNT() klausul för att dela upp antalet till bara ägarens namn.
Resultatet är att ägare med flera husdjur visas på flera rader (eftersom varje husdjur också måste visas), och varje rad innehåller det sammanlagda antalet ägares husdjur.
Det här konceptet kan också tillämpas på andra aggregerade funktioner i SQL, såsom SUM() , MIN() , MAX() och AVG() .
COUNT_BIG()
Om du räknar allvarligt stora datamängder i SQL Server kan du upptäcka att COUNT() funktionen ger ett fel, på grund av att antalet är för högt. Detta kommer bara att hända ditt antal är större än 2 147 483 647.
I sådana fall kan du använda COUNT_BIG() , som kan ta emot mycket större antal.
Se hur COUNT_BIG() Fungerar i SQL Server och COUNT() kontra COUNT_BIG() för en mer detaljerad förklaring.
ANSI SQL Standard
COUNT() funktion är listad i SQL-standarden, och den är tillgänglig i de flesta (om inte alla) av de stora DBMS:erna och fungerar ungefär likadant över dem.
För kodexempel gjorda i olika DBMS, se SQLite COUNT() , SQL Server COUNT() , och MySQL COUNT() .