W SQL COUNT() function to funkcja agregująca, która zwraca liczbę elementów znalezionych w grupie.
Możesz użyć COUNT() w wielu częściach zapytania. Na przykład możesz go użyć w SELECT lista lub HAVING klauzula podczas filtrowania grup.
Przykładowa tabela
Załóżmy, że mamy następującą tabelę:
SELECT * FROM Pets;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
W poniższych przykładach zostanie użyta funkcja COUNT() funkcja podczas odpytywania tej tabeli.
Przykład
Oto prosty przykład na początek.
SELECT COUNT(*) AS Count
FROM Pets;Wynik:
+---------+ | Count | |---------| | 8 | +---------+
To mówi nam, że w tabeli jest 8 wierszy. Wiemy to, ponieważ użyliśmy symbolu wieloznacznego gwiazdki (* ), aby określić wszystkie wiersze i wszystkie kolumny.
Policz konkretną kolumnę
Możesz również określić konkretną kolumnę do zliczenia. COUNT() funkcja liczy tylko wartości inne niż NULL wyniki, więc jeśli określisz kolumnę zawierającą NULL wartości, te wartości nie będą liczone.
Oto przykład, aby pokazać, o co mi chodzi.
SELECT COUNT(DOB) AS Count
FROM Pets;Wynik:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
W tym przypadku Pets tabela zawiera dwa NULL wartości w DOB kolumna (dwa zwierzęta nie podały daty urodzenia), więc COUNT(DOB) zwraca 6, zamiast 8, gdy użyliśmy COUNT(*) .
Powód COUNT(*) w poprzednim przykładzie zwrócono wszystkie wiersze, ponieważ te dwa wiersze zrobiły mieć dane w innych kolumnach.
W moim przykładzie mój DBMS również zwrócił ostrzeżenie o tym. Możesz otrzymać ostrzeżenie lub nie, w zależności od systemu DBMS i konkretnej konfiguracji.
Przefiltrowane wyniki
COUNT() funkcja zlicza wiersze zwrócone przez zapytanie. Więc jeśli filtrujesz wyniki, wynik COUNT() odzwierciedli to.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Wynik:
+---------+ | Count | |---------| | 2 | +---------+
W tym przypadku są dwa zwierzaki o imieniu Fluffy. Dlatego zapytanie zwróciłoby dwa wiersze, a wynik COUNT() to 2 .
Policz odrębne kolumny
Domyślnie COUNT() funkcja zawiera niejawny ALL słowo kluczowe. Oznacza to, że wyniki zawierają duplikaty.
Ale masz również możliwość dodania DISTINCT słowo kluczowe, aby określić, że zwracane są tylko odrębne wartości. Oznacza to, że możesz określić, że wyklucza duplikaty.
Wybierzmy PetName kolumna. Jeśli spojrzysz na oryginalną tabelę powyżej, zobaczysz, że PetName kolumna zawiera dwa wiersze o tej samej wartości (Fluffy ).
Najpierw uruchomimy COUNT(ALL PetName) zapytanie, aby uwzględnić wszystkie zduplikowane wartości w liczbie:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Wynik:
+---------+ | Count | |---------| | 8 | +---------+
Tak więc jest osiem rzędów. Pamiętaj, że jest to ten sam wynik, który otrzymalibyśmy, gdybyśmy nie uwzględnili ALL słowo kluczowe, ponieważ ALL jest ustawieniem domyślnym.
Teraz uruchomimy COUNT(DISTINCT PetName) aby wyeliminować wszelkie duplikaty z licznika.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Wynik:
+---------+ | Count | |---------| | 7 | +---------+
Tym razem wynik to 7 . Dzieje się tak, ponieważ nasza zduplikowana wartość została wyeliminowana. Oznacza to, że zduplikowana wartość była traktowana tak, jakby istniała tylko jedna wartość.
Korzystanie z COUNT() z HAVING Klauzula
Możesz dołączyć COUNT() funkcjonować w wielu częściach zapytania. Nie ogranicza się to tylko do SELECT lista.
Oto przykład, w którym użyto COUNT() zarówno w HAVING klauzula i SELECT lista.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Wynik:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
W tym przypadku użyliśmy HAVING klauzula w połączeniu z GROUP BY klauzula zwracająca tylko te wiersze, które mają COUNT(PetTypeId) większej niż 2 .
Nie jesteś ograniczony tylko do operatora ) dla początkujących”>większego niż operator (> ) podczas korzystania z HAVING klauzula. Możesz użyć tych samych operatorów, których używasz z WHERE klauzula (np. = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE itp.).
Zobacz Operatory SQL, aby uzyskać listę operatorów dostępnych w SQL.
Funkcje okien
W zależności od systemu DBMS możesz użyć OVER klauzula z Twoim COUNT() funkcji, aby utworzyć funkcję okna.
Funkcja okna wykonuje operację podobną do agregacji na zestawie wierszy zapytania. Daje wynik dla każdego wiersza zapytania. Jest to przeciwieństwo operacji agregującej, która grupuje wiersze zapytań w jeden wiersz wyników.
Oto przykład demonstrujący tę koncepcję.
Widzieliśmy już Pets stół. Nasza baza danych ma również Owners tabeli i zawiera następujące dane:
+-----------+-------------+------------+----------------+-------------------+ | 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] | +-----------+-------------+------------+----------------+-------------------+
Możemy pobrać dane z tych tabel i przedstawić je jako jeden zestaw wyników za pomocą złączenia.
Możemy również użyć COUNT() funkcja z OVER klauzula, aby zastosować funkcję okna do danych.
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;Wynik:
+---------------+-----------+----------------------------------+ | 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 | +---------------+-----------+----------------------------------+
W tym przypadku użyliśmy OVER klauzula z naszym COUNT() klauzula dzieląca liczbę tylko na nazwisko właściciela.
W rezultacie właściciele z wieloma zwierzętami są wyświetlani w wielu wierszach (ponieważ każde zwierzę również musi być wyświetlane), a każdy wiersz zawiera łączną liczbę zwierząt tego właściciela.
Ta koncepcja może być również zastosowana do innych funkcji agregujących w SQL, takich jak SUM() , MIN() , MAX() i AVG() .
COUNT_BIG()
Jeśli liczysz naprawdę duże zestawy danych w SQL Server, może się okazać, że COUNT() funkcja generuje błąd z powodu zbyt dużej liczby. To się stanie tylko wtedy, gdy liczba jest większa niż 2 147 483 647.
W takich przypadkach możesz użyć COUNT_BIG() , który może obsłużyć znacznie większe liczby.
Zobacz, jak COUNT_BIG() Działa w SQL Server i COUNT() w porównaniu z COUNT_BIG() dla bardziej szczegółowego wyjaśnienia.
Standard ANSI SQL
COUNT() Funkcja jest wymieniona w standardzie SQL i jest dostępna w większości (jeśli nie we wszystkich) głównych DBMS i działa w nich prawie tak samo.
Przykłady kodu wykonanego w różnych DBMS, zobacz SQLite COUNT() , SQL Server COUNT() i MySQL COUNT() .
