Funciones de agregación básicas en SQL

Lección 4.1 · Tiempo de lectura: ~8 min · Tareas de práctica ↓

Las funciones de agregación de SQL convierten conjuntos de filas en métricas de resumen: recuento, suma, promedio, mínimo y máximo. En esta lección practicarás los agregados más habituales con ejemplos de Sakila y aprenderás a elegir la forma de contar adecuada para cada tarea. Al terminar, usarás con seguridad COUNT, SUM, AVG, MIN y MAX en SQL analítico.

En las lecciones anteriores te centraste en seleccionar filas individuales. Ahora pasamos al siguiente paso importante: calcular valores de resumen a partir de los datos.

Las funciones de agregación son esenciales en informes y analítica, porque responden rápidamente a preguntas como "¿cuántos?", "¿cuánto en total?" y "¿cuál es el promedio?".

Funciones de agregación principales

COUNT(): cuenta filas

Sintaxis básica:

COUNT(expression)

Ejemplo:

SELECT COUNT(*) AS total_payments
FROM payment;

Resultado: la consulta devuelve el número total de filas de la tabla payment.

COUNT(column) frente a COUNT(*)

Estas formas se parecen, pero se comportan de manera distinta:

• COUNT(*) cuenta todas las filas del resultado.
• COUNT(column) cuenta solo las filas en las que column no es NULL.

Si una columna contiene NULL, COUNT(column) puede ser menor que COUNT(*).

SELECT
    COUNT(*) AS total_rentals,
    COUNT(return_date) AS returned_rentals
FROM rental;

Explicación: total_rentals cuenta todos los alquileres, mientras que returned_rentals cuenta solo las filas con return_date rellenada.

COUNT(DISTINCT ...): cuenta valores únicos

Cuando necesitas el número de valores únicos y no solo el número de filas, usa COUNT(DISTINCT column).

SELECT COUNT(DISTINCT customer_id) AS unique_customers
FROM payment;

Resultado: la consulta devuelve cuántos clientes distintos hicieron pagos, aunque un cliente tenga muchas filas de pago.

En la práctica esto es importante para preguntas como "¿cuántos clientes distintos compraron?", en las que un simple COUNT(*) contaría de más por las filas repetidas.

SUM(): calcula un total

SELECT SUM(amount) AS total_amount
FROM payment;

Resultado: devuelve la suma total de la columna amount.

SUM(amount) ignora los NULL. Si todos los valores son NULL, el resultado es NULL.

AVG(): calcula un promedio

SELECT AVG(amount) AS average_amount
FROM payment;

Resultado: devuelve el importe medio calculado sobre las filas que no son NULL.

Si necesitas que las filas con NULL cuenten en el denominador, usa uno de estos enfoques:

SELECT
    AVG(amount) AS avg_ignore_null,
    AVG(COALESCE(amount, 0)) AS avg_include_null_as_zero,
    SUM(amount) / COUNT(*) AS avg_sum_div_all_rows
FROM payment;

MAX(): encuentra el valor máximo

SELECT MAX(amount) AS max_amount
FROM payment;

Resultado: devuelve el valor más grande de amount.

MIN(): encuentra el valor mínimo

SELECT MIN(amount) AS min_amount
FROM payment;

Resultado: devuelve el valor más pequeño de amount.

Tanto MIN() como MAX() ignoran los NULL. Si todos los valores son NULL, devuelven NULL.

MIN(column) frente a ORDER BY ... LIMIT 1

No siempre son equivalentes.

SELECT MIN(column_name)
FROM table_name;

SELECT column_name
FROM table_name
ORDER BY column_name
LIMIT 1;

• MIN(column_name) busca el mínimo entre los valores que no son NULL.
• ORDER BY ... LIMIT 1 devuelve la primera fila después de ordenar.
• Si tu SGBD coloca los NULL primero al ordenar, la segunda consulta puede devolver NULL, mientras que MIN() sigue devolviendo el mínimo no NULL.

Un equivalente fiable de MIN():

SELECT column_name
FROM table_name
WHERE column_name IS NOT NULL
ORDER BY column_name
LIMIT 1;

Uso práctico

Contar clientes

SELECT COUNT(*) AS total_customers
FROM customer;

Ventas totales por empleado

SELECT
    staff_id,
    SUM(amount) AS staff_total
FROM payment
GROUP BY staff_id;

Pago medio por cliente

SELECT
    customer_id,
    AVG(amount) AS avg_payment
FROM payment
GROUP BY customer_id;

Contar clientes únicos que han pagado

SELECT COUNT(DISTINCT customer_id) AS paying_customers
FROM payment;

Preguntas frecuentes

¿Qué diferencia hay entre COUNT(*) y COUNT(column)?

COUNT(*) cuenta todas las filas del resultado. COUNT(column) cuenta solo las filas en las que la columna indicada no es NULL.

¿Cuándo usar COUNT(DISTINCT ...)?

Úsalo cuando necesites el número de valores únicos y no el total de filas; por ejemplo, los clientes distintos en lugar del total de pagos.

¿Por qué AVG puede devolver un valor inesperado?

Porque AVG(column) ignora los NULL. Si quieres que esas filas cuenten en el denominador, usa COALESCE o divide SUM(column) entre COUNT(*).

Preguntas de entrevista

¿Qué son las funciones de agregación en SQL?

Son funciones que calculan un resumen sobre varias filas, como el recuento (COUNT), la suma (SUM) o el promedio (AVG). Devuelven un valor por grupo o para todo el resultado.

¿Qué diferencia hay entre COUNT(*), COUNT(column) y COUNT(DISTINCT column)?

COUNT(*) cuenta todas las filas, COUNT(column) cuenta los valores no NULL de esa columna y COUNT(DISTINCT column) cuenta los valores únicos no NULL.

¿Cómo pueden MIN y ORDER BY ... LIMIT 1 devolver resultados distintos?

Si una columna contiene NULL y el SGBD coloca los NULL primero al ordenar, ORDER BY ... LIMIT 1 puede devolver NULL, mientras que MIN() devuelve el mínimo no NULL.

Puntos clave de esta lección:

• Las funciones de agregación ofrecen métricas de resumen rápidamente.
• COUNT(*), COUNT(column) y COUNT(DISTINCT ...) resuelven tareas de recuento distintas.
• SUM, AVG, MIN y MAX suelen ignorar los NULL, lo que afecta al análisis.
• COUNT(DISTINCT ...) es esencial cuando necesitas entidades únicas y no el total de filas.
• Tratar bien los NULL influye directamente en la exactitud de los informes.