SQL intermedio: GROUP BY, HAVING y JOIN

En la lección anterior filtraste y ordenaste filas. Ahora darás el paso que convierte a SQL en una herramienta de análisis: resumir. Con GROUP BY obtienes en una consulta lo que en Excel hacías con una tabla dinámica (ventas por región, pedidos por canal), con HAVING filtras esos resúmenes y con JOIN combinas tablas, por ejemplo para analizar las ventas por país aunque el país esté en otra tabla. Estas tres herramientas aparecen en casi todas las pruebas técnicas de analista.

Funciones de agregación

Una función de agregación convierte muchas filas en un solo valor. Sin GROUP BY, resume la tabla entera:

SELECT COUNT(*)                  AS filas,
       COUNT(DISTINCT id_pedido) AS pedidos_unicos,
       ROUND(SUM(importe), 2)    AS ventas,
       ROUND(AVG(importe), 2)    AS ticket_promedio,
       MIN(importe)              AS minimo,
       MAX(importe)              AS maximo
FROM ventas;

Comparar COUNT(*) con COUNT(DISTINCT id_pedido) es la forma rápida de detectar duplicados en SQL: en la tabla ventas_sin_limpiar darían 200 y 197. Ten en cuenta que COUNT(columna) no cuenta los NULL: COUNT(importe) en la tabla sin limpiar devuelve 196, no 200.

GROUP BY: un resumen por grupo

GROUP BY parte la tabla en grupos (uno por cada valor distinto de la columna) y aplica la agregación a cada uno. Ventas y pedidos por región:

SELECT region,
       COUNT(*)               AS pedidos,
       ROUND(SUM(importe), 2) AS ventas
FROM ventas
GROUP BY region
ORDER BY ventas DESC;

El resultado como % de las ventas totales. Colores por país: azul México, naranja Perú, verde Colombia. Las dos capitales suman el 40,7%.

La regla de oro de GROUP BY: cada columna del SELECT debe estar en el GROUP BY o dentro de una función de agregación. Si escribes SELECT region, producto, SUM(importe) ... GROUP BY region, la base de datos no sabe qué producto mostrar para cada región; muchos sistemas dan error y SQLite devuelve uno cualquiera, lo que es peor.

Puedes calcular varias métricas a la vez. Por canal:

SELECT canal,
       COUNT(*)               AS pedidos,
       ROUND(SUM(importe), 2) AS ventas,
       ROUND(AVG(importe), 2) AS ticket_promedio
FROM ventas
GROUP BY canal
ORDER BY ventas DESC;

Detalle fino: el promedio exacto de Marketplace es 195,505. Excel lo muestra como 195,51, pero SQLite devuelve 195.5 porque guarda los decimales en binario (195,50499…). En sistemas financieros se usan columnas DECIMAL para evitar estas diferencias de centavos.

HAVING: filtra los grupos

WHERE filtra filas antes de agrupar; HAVING filtra grupos después de agrupar, y por eso puede usar funciones de agregación. ¿Qué regiones vendieron más de 4.000 USD?

SELECT region, ROUND(SUM(importe), 2) AS ventas
FROM ventas
GROUP BY region
HAVING SUM(importe) > 4000
ORDER BY ventas DESC;

Y puedes combinar ambos. Esta consulta primero se queda con los pedidos web (WHERE), luego agrupa por región y, al final, conserva las regiones cuyas ventas web superan 2.000 USD (HAVING):

SELECT region, COUNT(*) AS pedidos, ROUND(SUM(importe), 2) AS ventas_web
FROM ventas
WHERE canal = 'Web'
GROUP BY region
HAVING SUM(importe) > 2000
ORDER BY ventas_web DESC;

Tres de las cuatro regiones son peruanas: coincide con lo que viste en la tabla dinámica (en Perú, el 55,3% de las ventas es web).

Agrupar por fechas y con CASE WHEN

CASE WHEN crea una columna nueva según condiciones, como un SI anidado de Excel. Es perfecto para crear trimestres, tramos de importe o segmentos:

SELECT CASE
         WHEN fecha < '2025-04-01' THEN 'T1'
         WHEN fecha < '2025-07-01' THEN 'T2'
         WHEN fecha < '2025-10-01' THEN 'T3'
         ELSE 'T4'
       END AS trimestre,
       COUNT(*) AS pedidos,
       ROUND(SUM(importe), 2) AS ventas
FROM ventas
GROUP BY trimestre
ORDER BY trimestre;

Para agrupar por mes, cada sistema tiene su función: en SQLite strftime('%m', fecha), en PostgreSQL DATE_TRUNC('month', fecha), en MySQL MONTH(fecha). El cuarto trimestre, mes a mes, fue: octubre 4.798,8 (15 pedidos), noviembre 4.967,8 (23) y diciembre 5.920,4 (32).

JOIN: combina tablas

La tabla ventas tiene la región pero no el país; el país está en la tabla regiones. JOIN las une usando la columna que comparten, igual que BUSCARX en Excel, pero para todas las filas a la vez. Hay cuatro tipos principales:

Ventas por país con INNER JOIN. Las letras v y r son alias de tabla para escribir menos:

SELECT r.pais,
       COUNT(*)                 AS pedidos,
       ROUND(SUM(v.importe), 2) AS ventas,
       ROUND(AVG(v.importe), 2) AS ticket_promedio
FROM ventas AS v
JOIN regiones AS r ON v.region = r.region
GROUP BY r.pais
ORDER BY ventas DESC;

Los totales coinciden con los de Excel y la tabla dinámica: 197 pedidos y 38.472,20 USD. Cuando un JOIN cuadra con una cifra conocida, puedes confiar en él.

LEFT JOIN para encontrar datos huérfanos

Ahora haz el JOIN con la tabla sin limpiar. Con INNER JOIN obtienes 192 filas en lugar de 200: ocho pedidos desaparecen sin ningún mensaje. Para ver cuáles, usa LEFT JOIN y quédate con los que no encontraron país:

SELECT '[' || s.region || ']' AS region, COUNT(*) AS filas
FROM ventas_sin_limpiar AS s
LEFT JOIN regiones AS r ON s.region = r.region
WHERE r.pais IS NULL
GROUP BY s.region
ORDER BY filas DESC, s.region;

Los corchetes (concatenados con ||) hacen visible el espacio de «Lima ». Este patrón, LEFT JOIN + IS NULL, es una de las comprobaciones de calidad más útiles que existen.

El orden en que se ejecuta una consulta

1. FROM y JOINArma la tabla de trabajoToma las tablas y las une.
2. WHEREFiltra filasDescarta las filas que no cumplen la condición.
3. GROUP BYForma gruposUna «caja» por cada valor distinto.
4. HAVINGFiltra gruposDescarta grupos según sus agregados.
5. SELECTCalcula columnasAgregaciones, alias y CASE.
6. ORDER BY y LIMITOrdena y cortaDevuelve el resultado final.

Errores comunes (y qué hacer en su lugar)

SELECT r.pais, v.canal,
       COUNT(*)                 AS pedidos,
       ROUND(SUM(v.importe), 2) AS ventas
FROM ventas AS v
JOIN regiones AS r ON v.region = r.region
GROUP BY r.pais, v.canal
HAVING COUNT(*) >= 20
ORDER BY ventas DESC;

Resumen

• COUNT, SUM, AVG, MIN y MAX resumen filas; COUNT(DISTINCT) ayuda a detectar duplicados.
• GROUP BY crea un resumen por grupo; toda columna no agregada del SELECT debe estar en él.
• WHERE filtra filas antes de agrupar; HAVING filtra grupos después.
• JOIN combina tablas: INNER conserva solo coincidencias y LEFT conserva toda la tabla izquierda.
• LEFT JOIN + IS NULL encuentra datos huérfanos: en la tabla sin limpiar, 8 filas sin país.

En la próxima lección: Visualización de datos: cómo elegir el gráfico correcto. Convertirás estos resultados en gráficos que se entienden de un vistazo.