V SQL, COUNT() function je agregační funkce, která vrací počet položek nalezených ve skupině.
Můžete použít COUNT() ve více částech dotazu. Můžete jej například použít v SELECT nebo HAVING klauzule při filtrování skupin.
Ukázková tabulka
Předpokládejme, že máme následující tabulku:
SELECT * FROM Pets;Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Následující příklady budou používat COUNT() funkce při dotazu na tuto tabulku.
Příklad
Zde je jednoduchý příklad, jak začít.
SELECT COUNT(*) AS Count
FROM Pets;Výsledek:
+---------+ | Count | |---------| | 8 | +---------+
To nám říká, že v tabulce je 8 řádků. Víme to, protože jsme použili zástupný znak hvězdička (* ) specifikovat všechny řádky a všechny sloupce.
Počítání konkrétního sloupce
Můžete také určit konkrétní sloupec, který se má počítat. COUNT() funkce počítá pouze jiné než NULL výsledky, takže pokud zadáte sloupec, který obsahuje NULL hodnoty, tyto hodnoty se nebudou počítat.
Zde je příklad, který demonstruje, co tím myslím.
SELECT COUNT(DOB) AS Count
FROM Pets;Výsledek:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
V tomto případě Pets tabulka obsahuje dvě NULL hodnoty v DOB sloupec (dva domácí mazlíčci neuvedli své datum narození), a tak COUNT(DOB) vrátí 6 místo 8, když jsme použili COUNT(*) .
Důvod COUNT(*) v předchozím příkladu vrátil všechny řádky, protože tyto dva řádky uvedly mít data v ostatních sloupcích.
V mém příkladu můj DBMS také vrátil varování o tomto. V závislosti na vaší DBMS a vaší konkrétní konfiguraci se může nebo nemusí zobrazit varování.
Filtrované výsledky
COUNT() Funkce počítá řádky vrácené dotazem. Pokud tedy filtrujete výsledky, výsledek COUNT() to bude odrážet.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Výsledek:
+---------+ | Count | |---------| | 2 | +---------+
V tomto případě jsou to dva mazlíčci se jménem Fluffy. Dotaz by tedy vrátil dva řádky a výsledek COUNT() je 2 .
Počítání odlišných sloupců
Ve výchozím nastavení COUNT() funkce obsahuje implicitní ALL klíčové slovo. To znamená, že ve výsledcích zahrnuje duplikáty.
Ale máte také možnost přidat DISTINCT klíčové slovo pro určení, že budou vráceny pouze odlišné hodnoty. To znamená, že můžete určit, že to vylučuje duplikáty.
Vyberme PetName sloupec. Pokud se podíváte na původní tabulku výše, můžete vidět, že PetName sloupec obsahuje dva řádky se stejnou hodnotou (Fluffy ).
Nejprve spustíme COUNT(ALL PetName) dotaz k zahrnutí všech duplicitních hodnot do počtu:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Výsledek:
+---------+ | Count | |---------| | 8 | +---------+
Existuje tedy osm řádků. Pamatujte, že toto je stejný výsledek, jaký bychom dostali, kdybychom nezahrnuli ALL klíčové slovo, protože ALL je výchozí.
Nyní spustíme COUNT(DISTINCT PetName) k odstranění všech duplikátů z počítání.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Výsledek:
+---------+ | Count | |---------| | 7 | +---------+
Tentokrát je výsledek 7 . Důvodem je, že naše duplicitní hodnota byla odstraněna. To znamená, že s duplicitní hodnotou bylo zacházeno, jako by existovala pouze jedna hodnota.
Pomocí COUNT() pomocí HAVING Ustanovení
Můžete zahrnout COUNT() funkce ve více částech dotazu. Není omezeno pouze na SELECT seznam.
Zde je příklad, který používá COUNT() v obou HAVING klauzule a SELECT seznam.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Výsledek:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
V tomto případě jsme použili HAVING klauzule ve spojení s GROUP BY klauzule vrátit pouze ty řádky, které mají COUNT(PetTypeId) větší než 2 .
Nejste omezeni pouze na ) Operátor pro začátečníky”>větší než operátor (> ) při použití HAVING doložka. Můžete použít stejné operátory, které můžete použít s WHERE klauzule (například = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , atd.).
Seznam operátorů dostupných v SQL naleznete v části Operátory SQL.
Funkce okna
V závislosti na vašem DBMS možná budete moci použít OVER klauzule s vaším COUNT() funkce pro vytvoření funkce okna.
Funkce okna provádí operaci podobnou agregaci na sadě řádků dotazu. Vytváří výsledek pro každý řádek dotazu. To je na rozdíl od agregované operace, která seskupuje řádky dotazu do jednoho řádku výsledku.
Zde je příklad pro demonstraci konceptu.
Už jsme viděli Pets stůl. Naše databáze má také Owners tabulka a obsahuje následující údaje:
+-----------+-------------+------------+----------------+-------------------+ | 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] | +-----------+-------------+------------+----------------+-------------------+
Můžeme načíst data z těchto tabulek a prezentovat je jako jednu sadu výsledků pomocí spojení.
Můžeme také použít COUNT() funkce s OVER klauzule k aplikaci funkce okna na 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;Výsledek:
+---------------+-----------+----------------------------------+ | 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 | +---------------+-----------+----------------------------------+
V tomto případě jsme použili OVER klauzule s naším COUNT() klauzule k rozdělení počtu pouze na jméno vlastníka.
Výsledkem je, že majitelé s více mazlíčky jsou zobrazeni na více řádcích (protože každé domácí zvíře musí být také zobrazeno) a každý řádek obsahuje celkový počet mazlíčků tohoto majitele.
Tento koncept lze také aplikovat na další agregační funkce v SQL, jako je SUM() , MIN() , MAX() a AVG() .
COUNT_BIG()
Pokud na serveru SQL počítáte opravdu velké datové sady, možná zjistíte, že COUNT() funkce způsobí chybu, protože číslo je příliš vysoké. To se stane pouze váš počet je větší než 2 147 483 647.
V takových případech můžete použít COUNT_BIG() , která dokáže pokrýt mnohem větší počty.
Viz Jak COUNT_BIG() Funguje v SQL Server a COUNT() vs COUNT_BIG() pro podrobnější vysvětlení.
Standard ANSI SQL
COUNT() funkce je uvedena ve standardu SQL a je k dispozici ve většině (ne-li ve všech) hlavních DBMS a funguje v nich téměř stejně.
Příklady kódu provedené v různých DBMS najdete v SQLite COUNT() , SQL Server COUNT() a MySQL COUNT() .