Jak funguje COUNT() na serveru SQL Server

V SQL Server, COUNT() Funkce vrací počet položek nalezených ve skupině. Můžete jej použít ke zjištění, kolik řádků je v tabulce nebo sadě výsledků.

Syntaxe

Syntaxe vypadá takto:

-- Syntaxe agregační funkce COUNT ( { [ [ ALL | DISTINCT ] výraz ] | * } ) -- Syntaxe analytické funkce COUNT ( [ ALL ] { expression | * } ) OVER ( [  ] )

ALL aplikuje agregační funkci na všechny hodnoty. Toto je výchozí hodnota.

DISTINCT určuje, že funkce vrací počet jedinečných hodnot bez hodnoty null.

expression je výraz jakéhokoli typu, kromě obrázku , ntext nebo text . Agregační funkce a poddotazy nejsou ve výrazu podporovány.

* určuje, že by měly být spočítány a vráceny všechny řádky, včetně duplicitních řádků a řádků, které obsahují hodnoty null. COUNT(*) nemá žádné parametry a nepodporuje použití DISTINCT . Také to nevyžaduje výraz parametr (protože nepoužívá informace o žádném konkrétním sloupci).

OVER ( [ <partition_by_clause> ] rozděluje sadu výsledků vytvořenou FROM klauzule do oddílů, na které je funkce aplikována. Pokud není zadáno, funkce považuje všechny řádky sady výsledků dotazu za jednu skupinu.

Příklad 1 – Základní použití

Zde je základní příklad ukazující, jak tato funkce funguje:

SELECT COUNT(*) AS 'Row Count'FROM Artists;

Výsledek:

+--------------+| Počet řádků ||--------------|| 16 |+-------------+

V tomto případě je v Umělci 16 řádků tabulka.

Pro jistotu zde jsou:

SELECT *FROM Artists;

Výsledek:

+------------+------------------------+-------- ------+-------------+| ArtistId | Jméno umělce | AktivníOd | CountryId ||------------+------------------------+--------- -----+-------------|| 1 | Iron Maiden | 1975-12-25 | NULL || 2 | AC/DC | 1973-01-11 | NULL || 3 | Allan Holdsworth | 1969-01-01 | NULL || 4 | Buddy Rich | 1919-01-01 | NULL || 5 | Devin Townsend | 1993-01-01 | NULL || 6 | Jim Reeves | 1948-01-01 | NULL || 7 | Tom Jones | 1963-01-01 | NULL || 8 | Kaštanová 5 | 1994-01-01 | NULL || 9 | Skript | 2001-01-01 | NULL || 10 | Svítí | 1988-06-26 | NULL || 11 | Black Sabbath | 1968-01-01 | NULL || 12 | Michael se učí rockovat | 1988-03-15 | NULL || 13 | Carabao | 1981-01-01 | NULL || 14 | Karnivool | 1997-01-01 | NULL || 15 | Ptáci z Tokia | 2004-01-01 | NULL || 16 | Bodyjar | 1990-01-01 | NULL |+------------+------------------------+--------- -----+-------------+

Podle očekávání je vráceno 16 řádků.

Všimněte si, že CountryId sloupec neobsahuje nic jiného než hodnoty null. To bude užitečné pro další příklad.

Příklad 2 – Určení sloupce

Předchozí příklad používal hvězdičku (* ), chcete-li zadat všechny řádky. To má za následek započítání všech řádků bez ohledu na to, zda existují duplikáty nebo zda některé obsahují hodnoty null.

Můžete také určit konkrétní sloupec. Když to uděláte, nulové hodnoty se nepočítají. To znamená, že žádné řádky obsahující pro daný sloupec hodnotu null se nezapočítávají.

Zde je příklad použití CountryId sloupec, jak je uvedeno v předchozím příkladu:

SELECT COUNT(CountryId) AS 'Row Count'FROM Artists;

Výsledek:

+--------------+| Počet řádků ||--------------|| 0 |+-------------+

Jak jsme viděli v předchozím příkladu, všechny řádky pro tento sloupec jsou NULL . Výsledný počet řádků je tedy nula.

Pojďme do tohoto sloupce přidat nějaké hodnoty:

UPDATE ArtistsSET CountryId =2WHERE ArtistName IN ( 'AC/DC', 'Karnivool', 'Birds of Tokyo', 'Bodyjar');

Nyní znovu spočítejme řádky pro tento sloupec:

SELECT COUNT(CountryId) AS 'Row Count'FROM Artists;

Výsledek:

+--------------+| Počet řádků ||--------------|| 4 |+-------------+

Příklad 3 – S DISTINCT

Tento příklad používá DISTINCT klauzule vrátit pouze odlišné řádky (tj. neduplikované).

V předchozím příkladu jsem aktualizoval tabulku tak, aby měla stejné CountryId byl aplikován na čtyři umělce (použil jsem SET CountryId = 2 pro všechny čtyři umělce). Výsledkem byly čtyři řádky se stejným CountryId .

Zde je to, co se stane, když spočítám, kolik různých CountryId s jsou v této tabulce:

SELECT COUNT(DISTINCT CountryId) 'Distinct CountryIds'FROM Artists;

Výsledek:

+-----------------------+| Odlišné CountryIds ||-----------------------|| 1 |+-----------------------+

To se dá očekávat, protože ačkoli jsou zde čtyři řádky s CountryId , je to stále pouze jedno odlišné CountryId .

Pro jistotu si ji spusťte spolu s její „nerozlišenou“ verzí:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Výsledek:

+----------------+------------+| Nevýrazné | Odlišné ||----------------+------------|| 4 | 1 |+----------------+------------+

Nerozlišitelná verze tedy ukazuje, kolikrát CountryId se v tabulce objeví, zatímco DISTINCT verze počítá více výskytů jako 1.

Pojďme přidat další CountryId ke stolu:

UPDATE ArtistsSET CountryId =1WHERE ArtistName ='Carabao';

A nyní spusťte dotaz znovu:

SELECT COUNT(CountryId) 'Non Distinct', COUNT(DISTINCT CountryId) 'Distinct'FROM Artists;

Výsledek:

+----------------+------------+| Nevýrazné | Odlišné ||----------------+------------|| 5 | 2 |+----------------+------------+

Příklad 4 – Použijte klauzuli WHERE

Zde je rychlý příklad pomocí WHERE doložka.

SELECT COUNT(*) AS 'Row Count'FROM ArtistsWHERE ActiveFrom>='2000-01-01';

Výsledek:

+--------------+| Počet řádků ||--------------|| 2 |+-------------+

Příklad 5 – S GROUP BY

Zde je příklad seskupení interpretů do jednoho sloupce a poté počítání všech alb pro každého interpreta ve druhém sloupci.

Příklad:

SELECT ArtistName, COUNT(al.AlbumId) 'Počet alb'FROM Artists arINNER JOIN Alba alON al.ArtistId =ar.ArtistIdGROUP BY ArtistNameORDER PODLE 'Počet alb' DESC;

Výsledek:

+------------------------+--------------------+ | Jméno umělce | Počet alb ||------------------------+--------------------- || Iron Maiden | 5 || Michael se učí rockovat | 3 || Skript | 3 || Tom Jones | 3 || Devin Townsend | 3 || Allan Holdsworth | 2 || Buddy Rich | 1 || AC/DC | 1 || Jim Reeves | 1 |+------------------------+--------------------+ 
Příklad 6 – S doložkou HAVING
 

 Předchozí příklad můžeme upravit tak, aby zahrnoval pouze umělce, kteří mají více než určitý počet alb. Můžeme to udělat pomocí HAVING doložka.
 
SELECT ArtistName, COUNT(al.AlbumId) 'Počet alb'FROM Interpreti arINNER JOIN Alba alON al.ArtistId =ar.ArtistIdGROUP PODLE ArtistNameHAVING COUNT(al.AlbumId)> 2ORDER PODLE 'ČÍSLA alb; 

 Výsledek:
 
+------------------------+--------------------+ | Jméno umělce | Počet alb ||------------------------+--------------------- || Iron Maiden | 5 || Michael se učí rockovat | 3 || Skript | 3 || Tom Jones | 3 || Devin Townsend | 3 |+------------------------+--------------------+ 
Příklad 7 – Rozdělení pomocí klauzule OVER
 

 Můžete použít OVER klauzule s PARTITION BY k rozdělení výsledků do oddílů. 
 

 V tomto příkladu používám OVER (PARTITION BY ArtistName) vypsat každé album, které umělec produkoval, a také celkový počet alb tohoto umělce. 
 
SELECT ArtistName, AlbumName, COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Počet alb od tohoto Artist'FROM Artists arINNER JOIN Albas alON al.ArtistId =ar.ArtistIdORDER PODLE 'Počet alb' DESC; 
 

 Výsledek:
 
+------------------------+--------------------- -----+-------------------------------------+| Jméno umělce | Název alba | Počet alb od tohoto interpreta ||------------------------+----------------- ---------+-------------------------------------|| Iron Maiden | Powerslave | 5 || Iron Maiden | Někde v čase | 5 || Iron Maiden | Kousek mysli | 5 || Iron Maiden | Zabijáci | 5 || Iron Maiden | Žádná modlitba za umírající | 5 || AC/DC | Výkon | 3 || AC/DC | Zpět v černém | 3 || AC/DC | Rock nebo Bust | 3 || Michael se učí rockovat | Modrá noc | 3 || Michael se učí rockovat | Věčnost | 3 || Michael se učí rockovat | Skandinávie | 3 || Devin Townsend | Ziltoid vševěd | 3 || Devin Townsend | Oběti Cool | 3 || Devin Townsend | Epicloud | 3 || Tom Jones | Dlouho ztracený kufr | 3 || Tom Jones | Chvála a vina | 3 || Tom Jones | Along Came Jones | 3 || Allan Holdsworth | Celá noc špatně | 2 || Allan Holdsworth | Šestnáct mužů z Tainu | 2 || Buddy Rich | Big Swing Face | 1 || Jim Reeves | Singing Down the Lane | 1 || Skript | Žádný zvuk bez ticha | 1 |+------------------------+----------------------- ----+-------------------------------------+
 

 Všimněte si, že to způsobí, že se počet interpretů a alb opakuje na více řádcích, ale to se dá očekávat, když chceme každé album vypsat na samostatném řádku.
 
Příklad 8 – S STRING_AGG()
 

 Pokud nechcete, aby se každý interpret a počet alb opakoval na více řádcích jako v předchozím příkladu, můžete vždy použít STRING_AGG() funkce pro výstup alb jako seznamu. V tomto případě byste nepotřebovali OVER doložka.
 

 Příklad:
 
SELECT ArtistName, STRING_AGG(AlbumName, ', ') 'Album', COUNT(AlbumId) 'Count'FROM Artists arINNER JOIN Albas alON al.ArtistId =ar.ArtistIdGROUP BY ArtistName'ORDER BY;
 Výsledek:
 
+------------------------+--------------------- -------------------------------------------------- ---------+----------+| Jméno umělce | Alba | Počet ||------------------------+----------------------- -------------------------------------------------- --------+---------|| Iron Maiden | Powerslave, Somewhere in Time, Piece of Mind, Killers, No Prayer for the Dying | 5 || AC/DC | Powerage, Back in Black, Rock or Bust | 3 || Michael se učí rockovat | Modrá noc, věčnost, Skandinávie | 3 || Devin Townsend | Ziltoid the Omniscient, Casualties of Cool, Epicloud | 3 || Tom Jones | Dlouho ztracený kufr, Chvála a vina, Along Came Jones | 3 || Allan Holdsworth | All Night Wrong, The Sixteen Men of Tain | 2 || Buddy Rich | Big Swing Face | 1 || Jim Reeves | Singing Down the Lane | 1 || Skript | Žádný zvuk bez ticha | 1 |+------------------------+----------------------- -------------------------------------------------- --------+---------+
 
SPOUSTU řádků?
 

 COUNT() funkce vrátí výsledek jako int datový typ. Pokud máte tolik řádků, že je výsledek větší než int zvládne, zkuste COUNT_BIG() místo toho.
 

 COUNT_BIG() funguje stejně jako COUNT() , kromě toho, že jeho výsledky jsou vráceny jako bigint hodnota datového typu.
 

 Můžete také zvážit použití APPROX_COUNT_DISTINCT() v některých případech. 
 

 APPROX_COUNT_DISTINCT() vrátí přibližnou hodnotu, nikoli přesnou hodnotu. Je však navržen tak, aby byl mnohem pohotovější než COUNT() a COUNT_BIG() , takže by to mohlo být užitečné v situacích, kdy je odezva důležitější než přesnost.
 

 Je navržen tak, aby vracel jedinečné hodnoty bez nuly, takže by byl relevantní pouze v případech, kdy byste normálně používali DISTINCT klauzule s COUNT_BIG() .
 

 Všimněte si také, že v době psaní APPROX_COUNT_DISTINCT() je ve stavu veřejného náhledu.