Guía detallada de la función COUNT() de SQL

En esta guía encontrará explicaciones detalladas (con ejemplos) de todos los usos típicos de la función CONTAR() .

Conocer la agregación de datos es un paso necesario para convertirse en un maestro de SQL. Esto incluye la función COUNT(), una de las funciones de agregación de SQL más utilizadas.

La agregación de datos sigue siendo un conocimiento básico de SQL. Contar con una base sólida garantiza que no tengas lagunas en tus conocimientos, lo que facilita el aprendizaje de conceptos SQL más complejos. Puede obtener esta base y mucho más en nuestro curso SQL de la A a la Z. Sus siete cursos interactivos le proporcionarán una estructura firme y harán que su aprendizaje sea sistemático. Empezarás con los conceptos básicos de SQL, como la recuperación de datos y el uso de funciones SQL estándar (que incluyen COUNT() y otras funciones agregadas). Una vez que tengas esto claro, te resultará mucho más fácil seguir los conceptos más avanzados que te enseña este curso, como las funciones de ventana, las expresiones comunes de tabla y las extensiones de GROUP BY.

Una vez que aprendas todo esto, necesitarás algo de práctica para dominarlo realmente. Para ello, está el Ejercicios prácticos de SQL con sus 88 ejercicios interactivos.

Este artículo también será práctico y te mostrará diferentes ejemplos de uso de COUNT(). Para ello, necesitamos un conjunto de datos adecuado.

Ejemplo de conjunto de datos

Nos ocuparemos de los directores y sus películas. La primera tabla se llama, como era de esperar directors. Aquí tienes la consulta que puedes utilizar para replicar esta tabla.

Los datos de la tabla tienen este aspecto:

Es una simple lista de directores con alguna información sobre ellos.

La segunda tabla es films. También puedes crear esta tabla utilizando esta consulta. Los datos de la tabla son los siguientes:

Es una lista de películas conectada a la tabla directors a través de la columna director_id. Dos valores de director_id son NULL. En el contexto de nuestro conjunto de datos, significa que hay datos sobre estas películas en la tabla films. Sin embargo, no hay ningún director correspondiente en la tabla directors. En otras palabras, tenemos todos los datos sobre "Tarde de perros" y "El odioso", excepto quién las dirigió.

Ahora que conocemos los datos, podemos tratar con COUNT().

¿Qué es COUNT()?

La respuesta está en el nombre: la función COUNT() de SQL se utiliza para contar filas. Cuenta filas en el conjunto de resultados, no en la tabla. Para ser más precisos, contará las filas de la tabla si ésta es un conjunto de resultados, es decir, si no se han filtrado los datos de ninguna manera. Si se filtran los datos, COUNT() devuelve el número de filas de los datos filtrados.

He aquí un ejemplo:

SELECT 
  COUNT(*) AS number_of_directors
FROM directors;

El asterisco (*) en la función COUNT() le indica que cuente todas las filas. Como no se aplican filtros, toda la directors será el conjunto de resultados. Por lo tanto, la función COUNT() devolverá el número de filas de la tabla:

El número de filas es diez, que, en este caso, también representa el número de directores.

Si el conjunto de resultados es limitado, COUNT(*) devolverá un valor diferente. Por ejemplo, supongamos que queremos mostrar el número de directores fallecidos. Esto significa contar sólo los directores que tienen una fecha en la columna date_of_death. Los que tienen valores NULL siguen vivos. Esta es la consulta:

SELECT 
  COUNT(*) AS number_of_dead_directors
FROM directors
WHERE date_of_death IS NOT NULL;

Conseguimos lo que queríamos filtrando los datos mediante la cláusula WHERE. He aquí el resultado:

Cuatro directores ya no están vivos.

COUNT() y GROUP BY

Normalmente, la función COUNT() se utiliza con la cláusula GROUP BY. Para refrescar la memoria, GROUP BY es una cláusula que agrupa todas las filas con el mismo valor. Normalmente, los grupos son columnas específicas del conjunto de datos. Para obtener más información, lea este artículo sobre cómo utilizar GROUP BY.

He aquí un ejemplo del uso de GROUP BY con COUNT(*):

SELECT 
  country_of_birth,
  COUNT(*) AS number_of_directors
FROM directors
GROUP BY country_of_birth
ORDER BY country_of_birth;

Queremos mostrar todos los países y el número de directores nacidos en ellos. Seleccionamos el país y utilizamos COUNT(*) para mostrar el número de directores. A continuación, especificamos la columna country_of_birth en GROUP BY.

Todas las columnas de la tabla que aparecen en SELECT deben aparecer también en GROUP BY. Es lógico, porque queremos ver el número de directores por país de nacimiento y mostrar esos países simultáneamente.

Por último, la salida se ordena alfabéticamente por países utilizando ORDER BY country_of_birth:

Hay un director de cada país excepto Francia y EE.UU..

Si necesitas más ejemplos, aquí tienes el artículo que muestra cómo utilizar GROUP BY con funciones agregadas de SQL.

Uso de COUNT() con una Expresión o Columna

No está limitado a escribir un asterisco en COUNT(). También se puede utilizar con una columna o una expresión, como la sentencia CASE WHEN.

La diferencia es que COUNT(expression) cuenta sólo los valores noNULL de la expresión. COUNT(*) contará también los valores NULL.

Como ejemplo, intentemos hacer una lista de todos los idiomas de cine y el número de directores que hicieron películas en esos idiomas. Parece que tenemos todos los datos en la tabla films.

¿Qué pasaría si utilizamos COUNT(*)?

SELECT 
  language,
  COUNT(*) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

En total, esta salida muestra las 12 películas que aparecen en la tabla. Spoiler alert: ¡Esto está mal!

¿La razón? Recuerde que COUNT(*) cuenta el número de filas del conjunto de datos, incluidos los NULL. Así que este resultado no representa en absoluto el número de directores. Como contamos filas en la tabla filmses obvio que hemos contado el número de películas, ¡no de directores!

En otras palabras, hay ocho películas en inglés, una en polaco y tres en español. Este resultado no tiene nada que ver con el número de directores.

¿Sería mejor idea utilizar COUNT(director_id)? Deberíamos probarlo:

SELECT 
  language,
  COUNT(director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Seleccionamos los idiomas y contamos los directores a través de su identificador: director_id. La salida se agrupa y ordena por idioma.

La salida difiere de la anterior, así que analicémosla.

Lo que hemos hecho bien al contar director_id es que nos hemos librado de las películas con NULLs en director_id. Esto es especialmente obvio en el caso del polaco: el número de directores es cero. ¿Por qué? Porque sólo hay una película polaca y tiene un NULL en director_id, así que no se cuenta.

Menos obvio es que también "falta" una de esas películas en inglés. Se trata de Dog Day Afternoon, porque también tiene un NULL en director_id.

En total, el resultado muestra diez directores porque hay diez registros en la tabla films con valores no NULL en la columna director_id.

Pero si vuelve a la tabla films, podría ver que algunas identificaciones de directores aparecen varias veces. Así que sí, mostramos el número de directores, pero también incluimos a todos los directores cada vez que aparecen en la tabla. En otras palabras, incluimos valores duplicados.

Así que este resultado se acerca más a lo que queríamos conseguir, pero sigue sin ser del todo correcto. Contar los ID duplicados de los directores infla el resultado, es decir, muestra un número irrealmente alto de directores individuales.

Lo que resolvería este problema de duplicación es utilizar COUNT() con DISTINCT.

COUNT(expresión) con DISTINCT

Ahora que ha aprendido a utilizar COUNT() con un nombre de columna, es el momento de aprender a utilizarlo con DISTINCT.

La cláusula DISTINCT elimina los duplicados. Cuando se utiliza con COUNT(expression), significa que la función contará sólo las instancias únicas de una columna/expresión.

Utilicemos el mismo ejemplo anterior, pero con DISTINCT:

SELECT 
  language,
  COUNT(DISTINCT director_id) AS number_of_directors
FROM films
GROUP BY language
ORDER BY language;

Observe que DISTINCT está escrito en la función COUNT(). Viene antes de la columna que quieres contar. Y aquí están los resultados:

El resultado muestra tres directores con películas en inglés, cero en polaco y dos en español. Un momento. ¿No es un resultado drásticamente diferente del que obtuvimos cuando utilizamos COUNT(director_id) sin DISTINCT?

Aquí está el resultado anterior:

¿Te das cuenta de lo que ha pasado aquí? Sin DISTINCT, contamos todos los valores de director_id. Así que la forma correcta de encontrar el número de directores en este ejemplo es usando COUNT() con DISTINCT.

Precaución: Uso de COUNT() con LEFT JOIN

Por último, utilicemos nuestras dos tablas simultáneamente. Imagine que desea obtener todos los directores y el número de sus películas.

Pensaría (correctamente) que necesita LEFT JOIN. Es un buen comienzo. Puede haber directores en la tabla directors que no tengan ninguna película en nuestra films tabla.

Como queremos mostrar la lista de todos los directores, LEFT JOIN es la opción correcta. Para contar el número de películas, puede que te apetezca utilizar COUNT(*). Esta es la consulta:

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(*) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name
ORDER BY d.id;

Seleccionamos las columnas necesarias y utilizamos COUNT(*). Las dos tablas se unen en la columna que contiene los ID de los directores.

El resultado se agrupa por ID y nombre de los directores y se ordena por el ID. Y los resultados:

Parece que todos los directores tienen al menos una película. En total, son 15 películas. ¡Un momento! No me parece correcto. Sólo hay 12 películas en la tabla films.

Además, sabemos a ciencia cierta que no hay películas de Stanley Kubrick en la tabla. ¿Cómo es que la salida muestra que tiene una? ¿También están mal los datos de los demás directores? Sí. Utilizar COUNT(*) no es la solución correcta en este caso. LEFT JOIN devolverá una fila para todos los directores, incluso el que no se pudo encontrar en la tabla films. Y COUNT(*) cuenta todas esas filas, incluso las que no tienen películas coincidentes.

En lugar de COUNT(*), utilice COUNT() con el nombre de la columna. ¿Qué columna debemos contar? Lo más seguro es contar los identificadores únicos, que es el id de columna de la tabla films.

SELECT 
  d.id,
  d.first_name,
  d.last_name,
  COUNT(f.id) AS number_of_films
FROM directors d
LEFT JOIN films f
ON d.id = f.director_id
GROUP BY d.id, d.first_name, d.last_name;

La consulta es prácticamente la misma que antes, salvo por el uso diferente de COUNT(). Y esto es lo que devuelve:

¡Así está mejor! Si suma los valores, verá que hay diez películas en total. ¿Por qué no doce? Porque dos películas son de directores que no existen en nuestro conjunto de datos, es decir, tienen NULLs en la columna director_id de la tabla films.

Para consolidar lo que ha aprendido aquí, eche un vistazo a algunos ejemplos más de usos de COUNT().

¡COUNT() es tan fácil como un, dos, tres!

No ha sido difícil, ¿verdad? Estos sencillos ejemplos le mostraron todas las variaciones del uso de COUNT(). La función en sí no es difícil de entender. Pero, como has visto, hay varias maneras de usarla, y cada una puede devolver un resultado diferente.

Elegir cómo usar COUNT() se hace más fácil con la práctica. El sitio Ejercicios prácticos de SQL está diseñado precisamente para eso. También puedes probar estos siete ejemplos de la función COUNT().

Aparte de la práctica, es importante que conozcas tus datos y lo que quieres conseguir con ellos. Cuando todo esto lo tengas claro, COUNT() se convertirá realmente en una función fácil. ¡Puedes contar con ella! Un juego de palabras.