COUNT() en SQL: qué es, cómo se usa y ejemplos prácticos

La función COUNT() en SQL se utiliza para contar filas en una tabla o valores dentro de una columna. Es una de las funciones de agregación más populares y se emplea en consultas de todo tipo: desde reportes simples hasta análisis de grandes volúmenes de datos.

Con COUNT() podés responder preguntas como:

  • ¿Cuántos clientes hay registrados en la base de datos?
  • ¿Cuántos pedidos se hicieron en un mes determinado?
  • ¿Cuántos productos tienen precio distinto de NULL?

Es una función esencial para cualquier persona que trabaje con bases de datos, ya que ofrece una visión rápida de la cantidad de registros que cumplen una condición determinada.

Sintaxis de COUNT()

La forma básica es:

COUNT([DISTINCT] expresión | *)

Donde:

  • COUNT(*): cuenta todas las filas, incluyendo las que tienen valores NULL.
  • COUNT(columna): cuenta solo las filas donde la columna no es NULL.
  • COUNT(DISTINCT columna): cuenta únicamente los valores distintos de esa columna DISTINCT.

Ejemplos prácticos de COUNT()

1. Contar todas las filas de una tabla

SELECT COUNT(*) AS total_clientes
FROM clientes;

👉 Devuelve el total de clientes registrados, sin importar si algunas columnas tienen NULL.

2. Contar valores no nulos en una columna

SELECT COUNT(email) AS clientes_con_email
FROM clientes;

👉 Solo cuenta a los clientes que tienen un email registrado (no NULL).

3. Contar valores distintos

SELECT COUNT(DISTINCT pais) AS paises
FROM clientes;

👉 Devuelve la cantidad de países diferentes en los que hay clientes.

4. COUNT() con GROUP BY

SELECT pais, COUNT(*) AS clientes_por_pais
FROM clientes
GROUP BY pais;

👉 Muestra cuántos clientes hay en cada país. Ejemplo clásico de uso con GROUP BY.

5. COUNT() con filtro (WHERE)

SELECT COUNT(*) AS pedidos_enero
FROM pedidos
WHERE fecha BETWEEN '2025-01-01' AND '2025-01-31';

👉 Devuelve el número de pedidos hechos en enero de 2025. Uso junto a WHERE y BETWEEN.

6. Contar registros con condiciones más complejas

SELECT COUNT(*) AS empleados_activos
FROM empleados
WHERE salario > 3000 AND activo = 1;

👉 Cuenta cuántos empleados activos tienen un salario mayor a 3000.

7. COUNT() con subconsultas

SELECT nombre,
       (SELECT COUNT(*) FROM pedidos p WHERE p.cliente_id = c.id) AS pedidos_cliente
FROM clientes c;

👉 Devuelve la cantidad de pedidos realizados por cada cliente.

8. COUNT() en funciones de ventana

SELECT cliente_id, COUNT(*) OVER (PARTITION BY cliente_id) AS pedidos_cliente
FROM pedidos;

👉 Cuenta cuántos pedidos hizo cada cliente sin necesidad de un GROUP BY. Uso de PARTITION BY.

Diferencias clave de COUNT()

  • COUNT(*): cuenta todas las filas (NULL incluido).
  • COUNT(columna): ignora filas con valores NULL en esa columna.
  • COUNT(DISTINCT columna): cuenta solo valores únicos, ignorando duplicados y NULL.

Ejemplo comparativo:

SELECT COUNT(*) AS total,
       COUNT(email) AS con_email,
       COUNT(DISTINCT email) AS emails_unicos
FROM clientes;

Usos comunes de COUNT()

  1. Obtener totales: cantidad de registros en una tabla.
  2. Control de calidad de datos: saber cuántos registros tienen un campo vacío.
  3. Agrupaciones: clientes por país, pedidos por mes, productos por categoría.
  4. Métricas de negocio: cantidad de usuarios activos, ventas realizadas, tickets resueltos.
  5. Validación de integridad: comparar la cantidad de registros de dos tablas relacionadas.

Errores comunes con COUNT()

  1. Confundir COUNT(*) con COUNT(columna):
    • COUNT(*) cuenta todas las filas.
    • COUNT(columna) ignora filas donde la columna es NULL.
  2. Olvidar DISTINCT cuando se necesitan valores únicos: SELECT COUNT(pais) FROM clientes; -- cuenta repeticiones SELECT COUNT(DISTINCT pais) FROM clientes; -- cuenta países únicos
  3. COUNT en combinación con GROUP BY mal definido: si no incluís todas las columnas no agregadas en GROUP BY, dará error en algunos motores (ej. PostgreSQL).
  4. Esperar que COUNT() devuelva 0 cuando no hay registros: en subconsultas puede devolver NULL si no hay resultados; conviene envolverlo en COALESCE. SELECT COALESCE(COUNT(*),0) FROM pedidos WHERE cliente_id=999;

Buenas prácticas con COUNT()

  • Usar COUNT(*) para contar filas completas. Es más claro y eficiente que COUNT(columna) si no hay interés en NULL.
  • Si necesitás contar con condiciones específicas, combiná con CASE: SELECT COUNT(CASE WHEN genero = 'M' THEN 1 END) AS hombres, COUNT(CASE WHEN genero = 'F' THEN 1 END) AS mujeres FROM empleados;
  • Siempre usar alias (AS total_clientes) para que el resultado sea más legible.
  • En tablas grandes, asegurarse de tener índices en las columnas de filtrado para que COUNT() sea más eficiente.
  • Evitar COUNT(DISTINCT) en tablas gigantes sin índice, ya que puede ser costoso en tiempo de ejecución.

Ejemplo avanzado: reporte de ventas

SELECT 
  cliente_id,
  COUNT(*) AS total_pedidos,
  COUNT(CASE WHEN estado = 'Entregado' THEN 1 END) AS entregados,
  COUNT(CASE WHEN estado = 'Pendiente' THEN 1 END) AS pendientes
FROM pedidos
GROUP BY cliente_id;

👉 Genera un reporte por cliente mostrando el total de pedidos, cuántos fueron entregados y cuántos están pendientes.

Preguntas frecuentes (FAQ)

1. ¿COUNT() incluye los valores NULL?
Depende:

  • COUNT(*) sí los incluye.
  • COUNT(columna) ignora los NULL.

2. ¿COUNT() siempre devuelve un número entero?
Sí, devuelve un valor entero ≥ 0.

3. ¿Qué diferencia hay entre COUNT() y SUM()?

  • COUNT() cuenta filas o valores.
  • SUM() calcula la suma de valores numéricos.

4. ¿Se puede usar COUNT() junto con otras funciones agregadas?
Sí, es común usarlo con SUM(), AVG(), MIN(), MAX() en la misma consulta.

5. ¿Puedo usar COUNT() en una subconsulta o vista?
Sí, se puede usar dentro de subconsultas, CTEs y vistas sin problema.

Conclusión

La función COUNT() en SQL es fundamental para contar filas y valores en una tabla. Permite obtener estadísticas rápidas, validar integridad de datos y generar reportes útiles.

Dominar sus diferentes usos (COUNT(*), COUNT(columna), COUNT(DISTINCT)) es clave para escribir consultas más precisas y profesionales.

Ya sea que quieras saber el total de usuarios en una aplicación, la cantidad de ventas de un mes o el número de países donde hay clientes, COUNT() es la herramienta indicada.

Practica el conteo de filas en Funciones de agregación y consulta el Glosario SQL completo.

Scroll al inicio