¿Cuál es la diferencia entre COUNT(*), COUNT(1), COUNT(nombre de columna) y COUNT(DISTINCT nombre de columna)?

¿Te has dado cuenta de que existen diferentes variaciones de la función COUNT() de SQL? Este artículo explica los distintos argumentos y sus usos.

Como usuario de SQL, probablemente estés familiarizado con la función COUNT(). Aunque es relativamente sencilla, se puede utilizar de varias formas diferentes. Y cada forma, a su vez, presenta usos muy diferente. Imagino que has visto código que contiene la función COUNT(*) o COUNT(1). Probablemente, también hayas visto otros usos de la función COUNT(), tales como COUNT(nombre de columna) y COUNT(DISTINCT nombre de columna), aunque no los hayas utilizado.

Quizás te estés preguntando qué hace cada variación de COUNT(). Pues, veámoslo.

Antes de continuar, quiero decirte que en este artículo utilizaré la función GROUP BY, pero de forma muy sencilla. Si necesitas refrescar tu memoria sobre GROUP BY, aquí hay un artículo que te guiará a través de la sintaxis y los principios generales de GROUP BY. O puedes aprender los fundamentos de GROUP BY en nuestro curso interactivo SQL para principiantes. Contiene más de 100 ejercicios prácticos de SQL para que adquieras confianza en tus habilidades de SQL a medida que avanzas.

¿Qué hace la función COUNT()?

Como puedes imaginar, la función COUNT() cuenta. ¿Pero qué es lo que cuenta? La función COUNT() pertenece a las funciones agregadas de SQL. Cuenta el número de filas que satisfacen los criterios definidos en los paréntesis. No devuelve las filas en sí, sino que muestra el número de filas que cumplen tus criterios.

Hablando de funciones agregadas, ellas son extremadamente útiles en los informes de SQL. Si quieres satisfacer tu curiosidad, hay un montón de funciones agregadas y "para agrupar" en nuestro curso Cómo crear informes básicos con SQL.

Ahora, volvamos al conteo. Existen, por supuesto, muchas y diferentes cosas que se pueden contar. Es por ello que hay diferentes variaciones de la función COUNT(). En este artículo, me concentraré en cuatro:

• COUNT(*)
• COUNT(1)
• COUNT(nombre de columna)
• COUNT(DISTINCT nombre de columna)

COUNT(*) vs COUNT(1)

Tal vez hayas visto diversas discusiones sobre las diferencias entre COUNT(*) y COUNT(1). Quizás, en el intento de encontrar respuestas, te haya confundido aún más. Pues, entonces, ¿hay alguna diferencia? La respuesta simple es no: no hay ninguna diferencia.

La función COUNT(*) cuenta el total de filas de la tabla, incluyendo los valores NULL. La semántica de COUNT(1) difiere ligeramente, y lo veremos más adelante. Sin embargo, los resultados de COUNT(*) y COUNT(1) son idénticos.

Probémoslo con una consulta de ejemplo. Supongamos que tengo una tabla llamada pedidos que contiene estas columnas:

• id_de_pedido: El ID del pedido.
• identificacion_del_cliente: El ID del cliente que realizó el pedido.
• valor_del_pedido: El valor total de los artículos pedidos, en euros.
• fecha_de_pago: La fecha de pago del pedido por parte del cliente.

Si quisiera contar el número de filas de toda la tabla, utilizaría la función COUNT() de la siguiente manera:

SELECT COUNT(*) AS numero_de_filas
FROM pedidos;

Como ves, he utilizado la función COUNT(*). El resultado aparecerá en la nueva columna numero_de_filas:

Bien, pero ¿y si en cambio utilizo COUNT(1)? Aquí está:

SELECT COUNT(1) AS numero_de_filas
FROM pedidos;

El código es esencialmente el mismo. La única diferencia es que he utilizado COUNT(1) en lugar de COUNT(*). ¿Y el resultado? Devuelve el mismo número de filas:

Hay un error común que supone que "1" en COUNT(1) significa "contar los valores de la primera columna y devolver el número de filas". De esa idea errónea se deriva una segunda: que COUNT(1) es más rápido porque contará sólo la primera columna, mientras que COUNT(*) utilizará toda la tabla para llegar al mismo resultado.

Esto no es cierto. El número en el paréntesis no significa el número de la columna en la tabla. Si pones cualquier número en el paréntesis, te garantizo que el resultado será el mismo. ¿Quieres una prueba? Aquí la tienes:

SELECT COUNT(-13) AS numero_de_filas
FROM pedidos;

Si el primer error fuera cierto, el código anterior significaría que quiero contar el número de filas en la columna -13. Sólo hay cuatro columnas en la tabla pedidos, por lo que no hay una 13ª columna. Y, por supuesto, seguro que no hay columna -13, sea lo que sea lo que signifique. ¿Quieres ver el resultado del código? No te sorprendas:

Una vez más, el resultado es el mismo. Entonces, ¿qué significa el valor entre paréntesis de COUNT()? Es el valor que la función COUNT() asignará a cada fila de la tabla. La función contará entonces cuántas veces se ha asignado el asterisco (*) o (1) o (-13). Por supuesto, se asignará un número de veces igual al número de filas de la tabla. En otras palabras, COUNT(1) asigna el valor del paréntesis (el número 1, en este caso) a cada fila de la tabla, y luego la misma función cuenta cuántas veces se ha asignado el valor del paréntesis (1, en nuestro caso); naturalmente, esto siempre será igual al número de filas de la tabla. Los paréntesis pueden contener cualquier valor; lo único que no funcionará será dejar los paréntesis vacíos.

Intentemos algo tonto. En lugar de un número, pon el siguiente valor entre paréntesis: "siempre son 8 filas". Aquí está el código:

SELECT COUNT('siempre son 8 filas') AS numero_de_filas
FROM pedidos;

Ejecuta el código y ¡oh, sorpresa! el resultado es realmente ocho filas:

Como no importa el valor que pongas entre paréntesis, se deduce que COUNT(*) y COUNT(1) son precisamente iguales. Son exactamente iguales porque el valor en los paréntesis de COUNT() sólo sirve para indicar a la consulta lo que va a contar.

Si estas sentencias son precisamente iguales, entonces no hay diferencia en el rendimiento. No dejes que el asterisco (*) te haga pensar que tiene el mismo uso que en la sentencia SELECT *. No, COUNT(*) no recorrerá toda la tabla antes de devolver el número de filas, haciéndose más lento que COUNT(1).

Así que, al final, ¿quién gana en esta dramática batalla entre COUNT(*) y COUNT(1)? Nadie: es un empate; son exactamente iguales. Sin embargo, yo recomendaría usar COUNT(*), ya que es mucho más común. También es menos confuso, pues, naturalmente, hace que otros usuarios de SQL entiendan que la función contará todos los números de la tabla, incluidos los valores NULL.

COUNT(*) vs COUNT(nombre de columna)

¿Qué tal COUNT(*) vs COUNT(nombre de columna)? ¿Hay aquí alguna diferencia? Seguro que sí.

Como ya has aprendido, COUNT(*) contará todas las filas de la tabla, incluyendo los valores NULL. Por otro lado, COUNT(nombre de columna) contará todas las filas de la columna especificada, excluyendo los valores NULL.

Como ya sabes, hay ocho filas en la tabla pedidos. Veamos cuántas filas habrá cuando utilice la columna id_de_pedido para contar (imaginando que quiero ver cuántos pedidos se han realizado). Volveremos a tener ocho filas, ¿verdad? Veamos:

SELECT COUNT(id_de_pedido) AS numero_de_pedidos
FROM pedidos;

¿Obtenemos el mismo resultado? No, hay siete pedidos, no ocho.

¿Es un error? No, no lo es; en realidad sólo hay siete pedidos con un id_de_pedido; una fila tiene un NULL en lugar de un id_de_pedido propiamente dicho. A continuación, se muestra la fila que marca la diferencia:

Recuerda siempre: COUNT(nombre de columna) sólo contará las filas en las que la columna dada no sea NULL.

Hagamos algo interesante y combinemos ambas variaciones de COUNT() en una sola consulta. Supongamos que quiero ver el ID del cliente con el número total de pedidos de ese cliente. También quiero mostrar el número total de pedidos pagados por ese cliente (los pedidos pagados no tienen un valor NULL en la columna fecha_de_pago.) Así es como lo haría:

SELECT	identificacion_del_cliente,
		COUNT(*) AS numero_de_pedidos,
		COUNT(fecha_de_pago) AS numero_de_pedidos_pagados
FROM pedidos
GROUP BY identificacion_del_cliente;

La consulta calculará primero el número total de pedidos utilizando COUNT(*); es decir, incluirá los valores NULL. A continuación, la parte COUNT (fecha_de_pago) AS numero_de_pedidos_pagados contará las filas de la columna fecha_de_pago que son NOT NULL. Quiero los resultados de cada cliente, así que he agrupado el resultado por la columna identificacion_del_cliente. Esto es lo que obtengo:

Se puede ver que la diferencia se produce para el cliente CU092.

Los principios de la combinación de GROUP BY y COUNT() se describen en este artículo sobre las funciones agregadas y GROUP BY en SQL. Si quieres practicar un poco más, aquí tienes cinco ejemplos de GROUP BY.

COUNT() nos permite utilizar tanto expresiones como nombres de columnas como argumento. ¿Sabes cómo encontrar el número de los pedidos superiores a 1.000 euros utilizando sólo la función COUNT()? He aquí cómo:

SELECT COUNT(CASE WHEN precio_del_pedido > 1000 THEN 1 END) 
AS pedidos_significativos
FROM pedidos;

En lugar de poner las condiciones al final de la consulta y filtrar después de que la función COUNT() haga su trabajo, podemos utilizar la expresión CASE. Eso es lo que he hecho en la consulta anterior. Se utiliza como una sentencia IF-THEN-ELSE. CASE va seguido de la condición, que se define mediante las sentencias WHEN y THEN. También puede haber una sentencia ELSE, pero es innecesaria en este caso: sólo me interesa contar el número de valores, no los valores en sí. Cada sentencia CASE termina con la sentencia END.

La sentencia COUNT() de arriba dice lo siguiente:

1. Encuentra todos los valores de la columna precio_del_pedido por encima de 1000.
2. Asigna el valor 1 (puede asignar cualquier valor que desee) a estos valores.
3. Asigna NULL a las filas con precios inferiores a 1000.
4. Cuenta el número de unos (1) asignados.
5. Muestra el resultado en la columna pedidos_significativos.

Este es el resultado:

COUNT(nombre de columna) vs COUNT (DISTINCT nombre_columna)

Probablemente, a estas alturas ya imagines cuál es la diferencia entre estas dos versiones de la función COUNT(). COUNT(nombre de columna) incluirá los valores duplicados al contar. En cambio, COUNT (DISTINCT nombre de columna) contará sólo las filas distintas (únicas) de la columna definida.

Si quieres contar el número de clientes que han hecho un pedido, quizás COUNT (nombre de columna) funcione. Probemos este código sencillo:

SELECT COUNT (identificacion_del_cliente) AS numero_de_clientes
FROM pedidos;

Esto te resulta familiar, pues ya he utilizado la función COUNT(nombre de columna). Esta vez, cuenta todas las filas de la columna identificacion_del_cliente y el resultado se muestra en la columna numero_de_clientes. Este es el resultado:

Comprobemos el resultado mirando toda la tabla pedidos:

Hay ocho filas, pero ¿es este realmente el número de clientes? Observa que los clientes CU108 y CU052 aparecen dos veces. Si quiero el número real de clientes, entonces tengo que contar cada cliente sólo una vez. ¿Cómo puedo hacerlo? Utilizando COUNT(DISTINCT identificacion_del_cliente):

SELECT COUNT(DISTINCT identificacion_del_cliente) AS numero_de_clientes
FROM pedidos;

Esta consulta también contará las filas de la columna identificacion_del_cliente, pero contará cada cliente sólo una vez. Esto se debe a la palabra clave DISTINCT. Observe el resultado:

Este es el resultado correcto: en realidad sólo hay seis clientes únicos.

¿Crees que puedes contar con COUNT()?

Ahora que entiendes algunas de las variaciones comunes de la función COUNT(), puedes crear cálculos e informes más complejos. COUNT() es una de las funciones agregadas más utilizadas, por lo que es vital que entiendas claramente las diferentes variaciones de COUNT() y sus propósitos. Si algunas de las variaciones de la función COUNT() que hemos tratado en este artículo no han quedado claras, házmelo saber en la sección de comentarios. Estaré encantado de ayudarte. Y, para practicar más el uso de COUNT(), prueba nuestro curso Cómo crear informes básicos con SQL.