Bottom Line

Użyj COUNT(field) lub COUNT(*) i trzymaj się tego konsekwentnie, a jeśli twoja baza danych pozwala COUNT(tableHere) lub COUNT(tableHere.*), użyj tego.

Krótko mówiąc, nie używaj COUNT(1) do niczego. Jest to kucyk jednokierunkowy, który rzadko robi to, co chcesz, a w rzadkich przypadkach jest odpowiednikiem count(*) {51]}

Użyj count(*) do liczenia

Użyj * dla wszystkich zapytań, które muszą liczyć wszystko, nawet dla łączy, użyj *

SELECT boss.boss_id, COUNT(subordinate.*)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Ale nie używaj COUNT(*) dla LEFT joins, ponieważ zwróci 1, nawet jeśli tabela podrzędna nie pasuje do niczego z tabeli nadrzędnej

SELECT boss.boss_id, COUNT(*)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Nie daj się zwieść tym, którzy doradzają, że gdy używasz * w liczeniu, pobiera cały wiersz z Twojej tabeli, mówiąc, że * jest powolny. * na SELECT COUNT(*) i SELECT * nie mają ze sobą żadnego związku, są zupełnie inną rzeczą, po prostu dzielą wspólny znak, tj. *.

Składnia alternatywna

W rzeczywistości, jeśli nie jest dozwolone nazwanie pola jako podobnie jak nazwa tabeli, projektant języka RDBMS może nadać COUNT(tableNameHere) taką samą semantykę jak COUNT(*). Przykład:

Do liczenia wierszy możemy mieć to:

SELECT COUNT(emp) FROM emp

I mogliby to uprościć:

SELECT COUNT() FROM emp

SELECT boss.boss_id, COUNT(subordinate)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Ale nie mogą tego zrobić (COUNT(tableNameHere)), ponieważ standard SQL pozwala na nazwanie pola o tej samej nazwie, co nazwa tabeli:

CREATE TABLE fruit -- ORM-friendly name
(
fruit_id int NOT NULL,
fruit varchar(50), /* same name as table name, 
                and let's say, someone forgot to put NOT NULL */
shape varchar(50) NOT NULL,
color varchar(50) NOT NULL
)

Liczenie przez null

SELECT count(fruit) FROM fruit

Chociaż niektóre RDBM stosują taką zasadę (do zliczania wierszy tabeli przyjmuje nazwę tabeli jako parametr COUNT), będzie to działać w Postgresql (jeśli nie ma pola subordinate w żadnej z dwóch poniższych tabel, tzn. tak długo, jak nie ma konfliktu nazw między nazwą pola a tabelą "nazwa": {]}

SELECT boss.boss_id, COUNT(subordinate)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Ale może to spowodować zamieszanie później, jeśli dodamy pole subordinate w tabeli, ponieważ będzie liczyć pole (które może być nullable), a nie wiersze tabeli.

Aby być po bezpiecznej stronie, użyj:

SELECT boss.boss_id, COUNT(subordinate.*)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

count(1): the one-trick pony

W szczególności do COUNT(1), jest to kucyk jednokierunkowy , działa dobrze tylko na jednym zapytaniu tabeli:

SELECT COUNT(1) FROM tbl

Ale kiedy używasz joins, ta sztuczka nie będzie działać na zapytaniach wielostolikowych bez jej semantyki jest zdezorientowany, a w szczególności nie można napisać:

-- count the subordinates that belongs to boss
SELECT boss.boss_id, COUNT(subordinate.1)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Więc jakie jest znaczenie COUNT (1) tutaj?

SELECT boss.boss_id, COUNT(1)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

-- counting all the subordinates only
SELECT boss.boss_id, COUNT(subordinate.boss_id)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

-- or is that COUNT(1) will also count 1 for boss regardless if boss has a subordinate
SELECT boss.boss_id, COUNT(*)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Poprzez uważne przemyślenie można wywnioskować, że COUNT(1) jest tym samym co COUNT(*), niezależnie od rodzaju połączenia. / Align = "LEFT" / : COUNT(subordinate.boss_id), COUNT(subordinate.*)

Więc po prostu użyj jednej z następujących opcji:

-- count the subordinates that belongs to boss
SELECT boss.boss_id, COUNT(subordinate.boss_id)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Działa na Postgresql, to jasne, że chcesz policz Kardynalność zestawu

-- count the subordinates that belongs to boss
SELECT boss.boss_id, COUNT(subordinate.*)
FROM boss
LEFT JOIN subordinate on subordinate.boss_id = boss.boss_id
GROUP BY boss.id

Inny sposób liczenia kardynalności zbioru, bardzo angielski-podobny (tylko nie rób kolumny o nazwie takiej samej jak nazwa tabeli) : http://www.sqlfiddle.com/#!1/98515/7

select boss.boss_name, count(subordinate)
from boss
left join subordinate on subordinate.boss_code = boss.boss_code
group by boss.boss_name

Nie możesz tego zrobić: http://www.sqlfiddle.com/#!1/98515/8

select boss.boss_name, count(subordinate.1)
from boss
left join subordinate on subordinate.boss_code = boss.boss_code
group by boss.boss_name

Możesz to zrobić, ale to daje zły wynik: http://www.sqlfiddle.com/#!1/98515/9

select boss.boss_name, count(1)
from boss
left join subordinate on subordinate.boss_code = boss.boss_code
group by boss.boss_name