COUNT, SUM y AVG en SQL con GROUP BY

Funciones de agregación SQL: COUNT, SUM y AVG

Bienvenido a esta lección fundamental sobre funciones de agregación en SQL. Estas funciones son herramientas esenciales que te permiten realizar cálculos sobre conjuntos de datos, obteniendo información resumida y estadísticas valiosas de tus tablas.

🎯 ¿Por qué son importantes las funciones de agregación?

Imagina que tienes una tabla con miles de registros de ventas. ¿Cómo responderías preguntas como:

• ¿Cuántas ventas realizó mi empresa?
• ¿Cuál es el ingreso total del mes?
• ¿Cuál es el promedio de compra por cliente?

Sin funciones de agregación, tendrías que contar y calcular manualmente. ¡Sería un caos! Afortunadamente, SQL nos proporciona COUNT(), SUM() y AVG() para resolver estos problemas de manera elegante y eficiente.

📖 La Función COUNT()

La función COUNT() es probablemente la más utilizada de todas. Como su nombre indica, sirve para contar el número de filas que cumplen una condición específica.

SELECT COUNT(columna) FROM tabla WHERE condición;

Ejemplo práctico con COUNT()

Consideremos nuestra tabla empleados:

Para contar cuántos empleados tenemos en total:

SELECT COUNT(*) FROM empleados;

Resultado: 6

Para contar cuántos empleados hay en el departamento de Ventas:

SELECT COUNT(*) FROM empleados WHERE departamento = 'Ventas';

Resultado: 3

COUNT() con DISTINCT

¿Quieres saber cuántos departamentos diferentes existen? Utiliza DISTINCT junto con COUNT:

SELECT COUNT(DISTINCT departamento) FROM empleados;

Resultado: 3 (Ventas, Marketing, Recursos Humanos)

➕ La Función SUM()

La función SUM() calcula la suma total de los valores numéricos en una columna. Es perfecta para calcular totales de ventas, presupuestos, salarios, y cualquier otro valor acumulable.

SELECT SUM(columna) FROM tabla WHERE condición;

Ejemplo práctico con SUM()

Para conocer el gasto total en nómina de nuestra empresa:

SELECT SUM(salario) FROM empleados;

Resultado: 13800 (suma de todos los salarios)

Para calcular el gasto en salarios solo del departamento de Marketing:

SELECT SUM(salario) FROM empleados WHERE departamento = 'Marketing';

Resultado: 4500 (2200 + 2300)

-- Si tienes: 100, 200, NULL, 300
SELECT SUM(columna) FROM tabla;
-- Resultado: 600 (ignora el NULL)

SELECT SUM(COALESCE(columna, 0)) FROM tabla;

📈 La Función AVG()

La función AVG() calcula el promedio aritmético de un conjunto de valores numéricos. Es extremadamente útil para análisis estadísticos y reportes de negocio.

SELECT AVG(columna) FROM tabla WHERE condición;

Ejemplo práctico con AVG()

Para conocer el salario promedio de todos los empleados:

SELECT AVG(salario) FROM empleados;

Resultado: 2300 (13800 / 6)

Para calcular el salario promedio por departamento:

SELECT AVG(salario) FROM empleados WHERE departamento = 'Ventas';

Resultado: 2400 (promedio de 2500, 2300 y 2400)

SELECT ROUND(AVG(salario), 2) FROM empleados;

🔧 Combinando Funciones de Agregación

Una de las grandes ventajas de SQL es que puedes usar múltiples funciones de agregación en una sola consulta. Esto te permite obtener un resumen completo de tus datos.

SELECT 
    COUNT(*) AS total_empleados,
    COUNT(DISTINCT departamento) AS num_departamentos,
    SUM(salario) AS gasto_total_nomina,
    AVG(salario) AS salario_promedio
FROM empleados;

Resultado:

"Las funciones de agregación son los ojos estadísticos de SQL. Sin ellas, analizar datos sería como intentar leer un libro contando cada letra individualmente."

📋 Usando GROUP BY con Funciones de Agregación

Aquí es donde las cosas se ponen realmente interesantes. El cláusula GROUP BY te permite segmentar tus datos en grupos y aplicar funciones de agregación a cada grupo.

Ejemplo con GROUP BY

Para obtener estadísticas de cada departamento:

SELECT 
    departamento,
    COUNT(*) AS num_empleados,
    SUM(salario) AS total_salarios,
    AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento;

Resultado:

1. SELECT departamento: Especifica la columna por la que queremos agrupar.
2. COUNT(*), SUM(salario), AVG(salario): Las funciones de agregación que calculan estadísticas para cada grupo.
3. GROUP BY departamento: Le dice a SQL que cree un grupo por cada departamento único.

🎯 Filtrando Grupos con HAVING

Ya conoces WHERE para filtrar filas individuales. Pero ¿cómo filtras grupos completos? Con HAVING.

Supongamos que solo queremos ver los departamentos con más de 2 empleados:

SELECT 
    departamento,
    COUNT(*) AS num_empleados,
    AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento
HAVING COUNT(*) > 1;

Resultado:

SELECT 
    departamento,
    COUNT(*) AS num_empleados,
    AVG(salario) AS salario_promedio
FROM empleados
WHERE salario > 2000          -- Filtra filas individuales primero
GROUP BY departamento
HAVING AVG(salario) > 2200;  -- Filtra grupos después

-- Primero: Selecciona empleados con salario > 2000
-- Segundo: Agrupa por departamento
-- Tercero: Calcula estadísticas por grupo
-- Cuarto: Muestra solo grupos con promedio > 2200

📚 Ejemplos de la Vida Real

Escenario 1: Reporte de Ventas

SELECT 
    categoria_producto,
    COUNT(*) AS total_productos_vendidos,
    SUM(cantidad) AS unidades_totales,
    SUM(cantidad * precio_unitario) AS ingreso_total,
    AVG(precio_unitario) AS precio_promedio
FROM ventas
WHERE fecha_venta BETWEEN '2024-01-01' AND '2024-12-31'
GROUP BY categoria_producto
ORDER BY ingreso_total DESC;

Escenario 2: Análisis de Clientes

SELECT 
    tipo_cliente,
    COUNT(DISTINCT id_cliente) AS clientes_unicos,
    SUM(total_compra) AS volumen_compras,
    AVG(total_compra) AS ticket_promedio
FROM ordenes
GROUP BY tipo_cliente
HAVING COUNT(*) >= 10;

🧠 Quiz de Refuerzo

📝 Resumen de la Lección

"Dominar las funciones de agregación es como aprender a leer las estadísticas de un negocio. Una vez que las entiendas, podrás transformar datos crudos en información valiosa para la toma de decisiones."

🚀 Próximos Pasos

En la próxima lección, exploraremos funciones de agregación adicionales como MIN(), MAX(), y aprenderemos sobre subconsultas para realizar análisis más sofisticados. ¡Sigue practicando con consultas reales para consolidar estos conocimientos!

Guía rápida: COUNT(*), COUNT(columna) y COUNT(DISTINCT)

Esta es la diferencia que más se pregunta en entrevistas, exámenes y ejercicios de analista de datos. Las tres expresiones empiezan con COUNT, pero no contestan lo mismo.

SELECT
  COUNT(*) AS filas,
  COUNT(email) AS emails_cargados,
  COUNT(DISTINCT pais) AS paises_unicos
FROM clientes;

SUM y AVG con valores NULL

SUM(columna) y AVG(columna) ignoran valores NULL. Eso es útil, pero puede esconder datos incompletos. Antes de explicar un promedio en un reporte, conviene comparar cuántas filas totales hay contra cuántos valores reales entraron en el cálculo.

SELECT
  COUNT(*) AS pedidos_totales,
  COUNT(total) AS pedidos_con_total,
  SUM(total) AS ingresos,
  ROUND(AVG(total), 2) AS ticket_promedio
FROM pedidos
WHERE estado = 'pagado';

WHERE vs HAVING en una consulta agregada

WHERE filtra filas antes de calcular los agregados. HAVING filtra grupos ya calculados. Si la condición usa COUNT(), SUM() o AVG(), normalmente va en HAVING.

SELECT
  categoria,
  COUNT(*) AS ventas,
  SUM(total) AS ingresos
FROM pedidos
WHERE estado = 'pagado'
GROUP BY categoria
HAVING SUM(total) >= 100000
ORDER BY ingresos DESC;

Ejercicios resueltos para practicar

1. Contar pedidos pagados: usá COUNT(*) con WHERE estado = 'pagado'.
2. Ventas por categoría: usá GROUP BY categoria, COUNT(*) y SUM(total).
3. Ticket promedio por país: usá AVG(total) con GROUP BY pais y redondeá con ROUND().
4. Clientes únicos: usá COUNT(DISTINCT cliente_id) para no contar compras repetidas del mismo cliente.
5. Categorías fuertes: agregá HAVING COUNT(*) >= 10 para mostrar solo grupos con volumen suficiente.

Caso de entrevista: métricas SQL para un dashboard

En entrevistas para analista de datos, soporte técnico, backend junior o producto, las agregaciones suelen aparecer como una pregunta de reporte: "mostrame ventas por mes", "contá usuarios activos" o "calculá ticket promedio por categoría". La respuesta fuerte no es solo escribir COUNT(); es mostrar columnas con nombres claros, filtros correctos y una interpretación del resultado.

Consulta completa para ventas mensuales

SELECT
  DATE_TRUNC('month', created_at) AS mes,
  COUNT(*) AS pedidos_pagados,
  COUNT(DISTINCT cliente_id) AS clientes_unicos,
  SUM(total) AS ingresos,
  ROUND(AVG(total), 2) AS ticket_promedio
FROM pedidos
WHERE estado = 'pagado'
GROUP BY mes
HAVING COUNT(*) >= 5
ORDER BY mes DESC;

Cómo explicarla en una entrevista

• WHERE deja solo pedidos pagados antes de calcular métricas.
• GROUP BY mes agrupa las filas por mes para crear una serie temporal.
• COUNT(*) mide volumen de pedidos.
• COUNT(DISTINCT cliente_id) evita contar varias compras del mismo cliente como clientes diferentes.
• SUM(total) mide ingresos y AVG(total) mide ticket promedio.
• HAVING COUNT(*) >= 5 elimina meses con muy pocos datos para evitar conclusiones débiles.

Variantes útiles para portfolio

Para convertir esta lección en evidencia laboral, armá un README con tres consultas, una captura del resultado y una explicación corta: qué pregunta responde cada query, qué tabla usa, qué filtro aplica y qué decisión permitiría tomar.

Práctica guiada: reporte de ventas con agregaciones

Usá este ejemplo para practicar una consulta típica de analista junior: resumir pedidos por país y detectar dónde hay más ventas.

SELECT
  pais,
  COUNT(*) AS pedidos,
  SUM(total) AS ingresos,
  AVG(total) AS ticket_promedio
FROM pedidos
WHERE estado = 'pagado'
GROUP BY pais
ORDER BY ingresos DESC;

Cómo leer el resultado

• pedidos: cantidad de filas pagadas por país.
• ingresos: suma de la columna total en cada país.
• ticket_promedio: promedio de compra de los pedidos pagados.
• ORDER BY ingresos DESC: deja arriba el país con mayor facturación.

Errores comunes con agregaciones

• Usar COUNT(columna) esperando contar todas las filas, aunque esa columna puede traer NULL.
• Seleccionar columnas no agregadas sin incluirlas en GROUP BY.
• Filtrar resultados agregados con WHERE en vez de HAVING.
• Olvidar que AVG() ignora valores NULL, por lo que el promedio puede cambiar si faltan datos.

Ejemplo con HAVING

SELECT
  pais,
  COUNT(*) AS pedidos,
  SUM(total) AS ingresos
FROM pedidos
WHERE estado = 'pagado'
GROUP BY pais
HAVING COUNT(*) >= 10
ORDER BY ingresos DESC;

Fuente oficial: PostgreSQL Aggregate Functions documenta que count(*) cuenta filas, sum suma valores no nulos y avg calcula el promedio de valores no nulos.