Línea de fondo

Use COUNT(field) o COUNT(*), y quédese con él constantemente, y si su base de datos lo permite COUNT(tableHere) o COUNT(tableHere.*), use eso.

En resumen, no uses COUNT(1) para nada. Es un pony de un solo truco, que rara vez hace lo que quieres, y en esos raros casos es equivalente a count(*)

Use count(*) para contar

Use * para todas sus consultas que necesitan contar todo, incluso para uniones, use *

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

Pero no use COUNT(*) para Se une a la izquierda, ya que devolverá 1 incluso si la tabla subordinada no coincide con nada de la tabla padre

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

No se deje engañar por aquellos que aconsejan que cuando se usa * en CUENTA, obtiene toda la fila de su mesa, diciendo que * es lento. El * en SELECT COUNT(*) y SELECT * no tiene relación el uno con el otro, son cosas completamente diferentes, solo comparten un símbolo común, es decir, *.

Una sintaxis alternativa

De hecho, si no está permitido nombrar un campo como al igual que su nombre de tabla, RDBMS language designer podría dar COUNT(tableNameHere) la misma semántica que COUNT(*). Ejemplo:

Para contar filas podríamos tener esto:

SELECT COUNT(emp) FROM emp

Y podrían hacerlo más simple: {[51]]}

SELECT COUNT() FROM emp

Y para la IZQUIERDA se une, podríamos tener esto:

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

Pero no pueden hacer eso (COUNT(tableNameHere)) ya que el estándar SQL permite nombrar un campo con el mismo nombre que el nombre de su tabla:

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
)

Contando con null

Y también, no es una buena práctica para hacer un campo nullable si su nombre coincide con el nombre de la tabla. Supongamos que tiene valores 'Banana', 'Apple', NULL, 'Pears' en el campo fruit. Esto no contará todas las filas, solo dará 3, no 4

SELECT count(fruit) FROM fruit

Aunque algunos RDBMS hacen ese tipo de principio (para contar las filas de la tabla, acepta el nombre de la tabla como parámetro de CONTEO), esto funcionará en Postgresql (si no hay un campo subordinate en cualquiera de las dos tablas a continuación, es decir, siempre y cuando no haya conflicto de nombres entre el nombre del campo y la tabla nombre):

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

Pero eso podría causar confusión más adelante si agregamos un campo subordinate en la tabla, ya que contará el campo(que podría ser nullable), no las filas de la tabla.

Así que para estar en el lado seguro, use:

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

count(1): El pony de un solo truco

En particular para COUNT(1), es un pony de un solo truco , funciona bien solo en una consulta de tabla:

SELECT COUNT(1) FROM tbl

Pero cuando usas joins, ese truco no funcionará en consultas multi-tabla sin su semántica estar confundido, y en particular no se puede escribir:

-- 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

Entonces, ¿cuál es el significado de CONTAR(1) aquí?

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

Es esto...?

-- 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

O esto...?

-- 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

Por un pensamiento cuidadoso, se puede inferir que COUNT(1) es lo mismo que COUNT(*), independientemente del tipo de unión. Pero para el resultado de las uniones izquierdas, no podemos moldear COUNT(1) para trabajar como: COUNT(subordinate.boss_id), COUNT(subordinate.*)

Así que simplemente use cualquiera de los siguientes:

-- 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

Funciona en Postgresql, está claro que desea cuenta la cardinalidad del conjunto

-- 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

Otra forma de contar la cardinalidad del conjunto, muy similar al inglés (simplemente no hagas una columna con un nombre igual que el nombre de su tabla): 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

No puedes hacer esto: 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

Puedes hacer esto, pero esto produce un resultado incorrecto: 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