MySQL incluye un COUNT() función, que le permite averiguar cuántas filas se devolverían de una consulta. Esta función forma parte del estándar SQL y se puede utilizar con la mayoría de los sistemas de gestión de bases de datos relacionales.
El COUNT() La función también se puede usar para afectar los resultados de una consulta si es necesario, por ejemplo, devolviendo solo aquellos resultados que tienen un recuento de filas mayor que una cantidad determinada.
Este artículo contiene ejemplos de COUNT() uso en MySQL.
Los datos
Primero, estos son los datos que usaremos para los ejemplos en esta página:
SELECT * FROM Tasks;
Resultado:
+--------+-------------------+-----------------+ | TaskId | TaskName | TaskDescription | +--------+-------------------+-----------------+ | 1 | Do garden | NULL | | 2 | Feed cats | NULL | | 3 | Paint roof | NULL | | 4 | Take dog for walk | NULL | | 5 | Relax | NULL | | 6 | Feed cats | NULL | +--------+-------------------+-----------------+
Cuenta todas las filas de una tabla
Puedes usar COUNT() para devolver el número total de filas en una tabla:
SELECT COUNT(*) FROM Tasks;
Resultado:
+----------+ | COUNT(*) | +----------+ | 6 | +----------+
Esto devuelve el número de filas en la tabla porque no proporcionamos ningún criterio para reducir los resultados.
Restringir los resultados
Cuando agregamos un WHERE cláusula que reduce el conjunto de resultados, obtenemos un número más pequeño:
SELECT COUNT(*) FROM Tasks WHERE TaskName LIKE '%cat%';
Resultado:
+----------+ | COUNT(*) | +----------+ | 2 | +----------+
Columna única frente a asterisco (*)
Todos los ejemplos anteriores usan un asterisco para aplicar el conteo a todas las columnas. Como con cualquier consulta, el asterisco es opcional y se usa como comodín para devolver todas las columnas. Entonces, al usar COUNT() función, también tiene la opción de proporcionar columnas específicas (a diferencia de todas las columnas) como argumento.
Ejemplo:
SELECT COUNT(TaskName) FROM Tasks;
Resultado:
+-----------------+ | COUNT(TaskName) | +-----------------+ | 6 | +-----------------+
Si bien este ejemplo devuelve el mismo resultado que obtuvimos cuando usamos el asterisco, ese no siempre será necesariamente el caso. Por ejemplo, esto es lo que sucede si especificamos una columna diferente:
SELECT COUNT(TaskDescription) FROM Tasks;
Resultado:
+------------------------+ | COUNT(TaskDescription) | +------------------------+ | 0 | +------------------------+
En este caso obtenemos cero, porque esa columna en particular contiene valores nulos en cada fila.
Ejemplo:Distinto
Puede agregar el DISTINCT argumento para devolver solo el número de filas con diferentes no NULL valores.
Es posible que haya notado que el TaskName la columna tiene un valor duplicado ("Alimentar gatos" aparece dos veces). Esto podría causar problemas si no desea que se cuenten los duplicados.
Así es como se ve si aplicamos DISTINCT argumento al TaskName columna:
SELECT COUNT(DISTINCT TaskName) FROM Tasks;
Resultado:
+--------------------------+ | COUNT(DISTINCT TaskName) | +--------------------------+ | 5 | +--------------------------+
Entonces, aunque la tabla contiene seis filas, dos de ellas están duplicadas. Por lo tanto, esos dos se cuentan como uno, obtenemos un resultado de cinco.
Ejemplo:la cláusula HAVING
También puede usar COUNT() con el HAVING cláusula para limitar un conjunto de resultados en función del número de filas que se devolverían.
Aquí hay un ejemplo que usa un conjunto de datos diferente a los ejemplos anteriores:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 1;
Resultado:
+------------------------+-------------+ | ArtistName | Album Count | +------------------------+-------------+ | Iron Maiden | 5 | | Devin Townsend | 3 | | Michael Learns to Rock | 3 | | Tom Jones | 3 | | Allan Holdsworth | 2 | +------------------------+-------------+
Esta consulta devuelve solo aquellos artistas que han lanzado más de 1 álbum. Esto es lo que sucede cuando aumentamos el valor en HAVING cláusula:
USE Music;
SELECT ar.ArtistName,
COUNT(al.AlbumName) 'Album Count'
FROM Artists ar
INNER JOIN Albums al
ON ar.ArtistId = al.ArtistId
GROUP BY ar.ArtistName
HAVING COUNT(al.AlbumName) > 4;
Resultado:
+-------------+-------------+ | ArtistName | Album Count | +-------------+-------------+ | Iron Maiden | 5 | +-------------+-------------+
