SQL · Lección 06 de 15

GROUP BY y HAVING

GROUP BY es el equivalente SQL de df.groupby() en pandas. Agrupa filas por una columna y aplica funciones de agregación a cada grupo: total por ciudad, promedio por tipo, conteo por categoría. Es la herramienta más poderosa para análisis de datos.

90–110 min Prerrequisitos: SQL 05

Concepto teórico

¿Qué hace GROUP BY?

Sin GROUP BY, las funciones de agregación (COUNT, SUM, AVG) resumen TODA la tabla en una sola fila. Con GROUP BY, agrupan las filas por los valores de una columna y calculan la agregación para CADA grupo:

-- Sin GROUP BY: una sola fila con el total
SELECT COUNT(*), SUM(saldo) FROM clientes;
-- → 5 | 1477000

-- Con GROUP BY: una fila POR CADA ciudad
SELECT ciudad, COUNT(*), SUM(saldo)
FROM clientes
GROUP BY ciudad;
-- → Buenos Aires | 2 | 1040000
-- → Córdoba     | 1 | 320000
-- → Rosario     | 1 | 45000
-- → Mendoza     | 1 | 72000

La regla de oro de GROUP BY

LA REGLA MÁS IMPORTANTE DE SQL: toda columna en el SELECT que NO esté dentro de una función de agregación DEBE estar en el GROUP BY. Si ponés nombre en el SELECT sin agregarlo ni agruparlo, SQL no sabe qué nombre mostrar para el grupo. Esto da error en la mayoría de los motores (PostgreSQL, MySQL strict, SQL Server).

-- ✅ CORRECTO: ciudad está en GROUP BY
SELECT ciudad, COUNT(*) FROM clientes GROUP BY ciudad;

-- ❌ INCORRECTO: nombre no está en GROUP BY ni en agregación
-- SELECT ciudad, nombre, COUNT(*) FROM clientes GROUP BY ciudad;
-- Error: "nombre" no está en GROUP BY

-- ✅ CORRECTO: nombre dentro de agregación
SELECT ciudad, GROUP_CONCAT(nombre) as nombres, COUNT(*)
FROM clientes GROUP BY ciudad;

Pensalo así: GROUP BY crea "grupos" de filas. Cada grupo se resume en UNA fila del resultado. Si agrupás por ciudad, BsAs tiene 3 clientes — ¿qué nombre mostrás para esa fila? No tiene sentido. Por eso, las columnas no agrupadas deben estar dentro de COUNT, SUM, AVG, etc.

HAVING — filtrar después de agrupar

HAVING es como WHERE pero para grupos. La diferencia:

WHERE filtra FILAS individuales ANTES de agrupar
HAVING filtra GRUPOS DESPUÉS de agrupar

-- WHERE: solo incluir clientes activos (filtra filas)
-- HAVING: solo mostrar ciudades con más de 2 clientes (filtra grupos)
SELECT ciudad, COUNT(*) AS cantidad, AVG(saldo) AS promedio
FROM clientes
WHERE activo = 1           -- filtra filas ANTES de agrupar
GROUP BY ciudad
HAVING COUNT(*) >= 2       -- filtra grupos DESPUÉS de agrupar
ORDER BY promedio DESC;

Regla HAVING: en HAVING solo podés usar funciones de agregación o columnas que estén en el GROUP BY. No podés filtrar por columnas individuales en HAVING — para eso está WHERE.

Orden de ejecución de SQL

SQL NO se ejecuta en el orden en que lo escribís. El orden real es:

Orden escrito	Orden de ejecución
1. SELECT	1. FROM — de qué tabla
2. FROM	2. WHERE — filtrar filas
3. WHERE	3. GROUP BY — agrupar
4. GROUP BY	4. HAVING — filtrar grupos
5. HAVING	5. SELECT — qué columnas
6. ORDER BY	6. ORDER BY — ordenar
7. LIMIT	7. LIMIT — limitar

Entender este orden te explica por qué WHERE no puede usar alias del SELECT, y por qué HAVING puede usar funciones de agregación pero WHERE no.

GROUP BY con múltiples columnas

Podés agrupar por más de una columna: GROUP BY ciudad, tipo crea un grupo para cada combinación única de ciudad+tipo.

En el trabajo: GROUP BY es probablemente la cláusula SQL más importante para un analista. "Ventas por mes", "saldo promedio por segmento", "cantidad de transacciones por tipo y ciudad", "clientes nuevos por semana" — todo es GROUP BY. En pandas hacés df.groupby("col").agg(...), en SQL es GROUP BY col.

Ejemplos explicados paso a paso

Ejemplo 1: GROUP BY básico — por ciudad

ejemplo_01_groupby.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720,150000);
INSERT INTO clientes VALUES (2,'López','Córdoba',680,320000);
INSERT INTO clientes VALUES (3,'Martínez','Rosario',590,45000);
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000);
INSERT INTO clientes VALUES (5,'Fernández','Córdoba',645,72000);
INSERT INTO clientes VALUES (6,'Sosa','Buenos Aires',750,210000);

-- Estadísticas por ciudad
SELECT
    ciudad,
    COUNT(*) AS cantidad,
    SUM(saldo) AS saldo_total,
    ROUND(AVG(saldo), 0) AS saldo_promedio,
    ROUND(AVG(score), 0) AS score_promedio
FROM clientes
GROUP BY ciudad
ORDER BY saldo_total DESC;

Hacé clic en ▶ Ejecutar

Ejemplo 2: HAVING — filtrar grupos

ejemplo_02_having.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720,150000);
INSERT INTO clientes VALUES (2,'López','Córdoba',680,320000);
INSERT INTO clientes VALUES (3,'Martínez','Rosario',590,45000);
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000);
INSERT INTO clientes VALUES (5,'Fernández','Córdoba',645,72000);
INSERT INTO clientes VALUES (6,'Sosa','Buenos Aires',750,210000);

-- Solo ciudades con 2+ clientes
SELECT ciudad, COUNT(*) AS cantidad, SUM(saldo) AS total
FROM clientes
GROUP BY ciudad
HAVING COUNT(*) >= 2
ORDER BY total DESC;

Hacé clic en ▶ Ejecutar

Ejemplo 3: WHERE + GROUP BY + HAVING (el combo completo)

ejemplo_03_combo.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER, saldo REAL, activo INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720,150000,1);
INSERT INTO clientes VALUES (2,'López','Córdoba',680,320000,1);
INSERT INTO clientes VALUES (3,'Martínez','Buenos Aires',590,45000,0);
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000,1);
INSERT INTO clientes VALUES (5,'Fernández','Córdoba',645,72000,1);
INSERT INTO clientes VALUES (6,'Sosa','Buenos Aires',750,210000,1);
INSERT INTO clientes VALUES (7,'Luna','Córdoba',700,180000,1);

-- Pipeline: filtrar activos → agrupar → filtrar grupos con saldo > 300K
SELECT
    ciudad,
    COUNT(*) AS clientes,
    SUM(saldo) AS saldo_total,
    ROUND(AVG(score), 0) AS score_prom
FROM clientes
WHERE activo = 1                    -- 1. filtra filas (solo activos)
GROUP BY ciudad                     -- 2. agrupa por ciudad
HAVING SUM(saldo) > 300000          -- 3. filtra grupos (saldo total > 300K)
ORDER BY saldo_total DESC;          -- 4. ordena resultado

Hacé clic en ▶ Ejecutar

Ejemplo 4: GROUP BY con múltiples columnas

ejemplo_04_multi.sqlSQL

CREATE TABLE transacciones (id INTEGER, cliente TEXT, tipo TEXT, monto REAL, mes TEXT);
INSERT INTO transacciones VALUES (1,'García','compra',15000,'2025-01');
INSERT INTO transacciones VALUES (2,'García','compra',32000,'2025-01');
INSERT INTO transacciones VALUES (3,'López','venta',8000,'2025-01');
INSERT INTO transacciones VALUES (4,'García','compra',22000,'2025-02');
INSERT INTO transacciones VALUES (5,'López','venta',12000,'2025-02');
INSERT INTO transacciones VALUES (6,'Pérez','compra',45000,'2025-02');
INSERT INTO transacciones VALUES (7,'García','venta',18000,'2025-02');

-- Agrupar por tipo Y mes
SELECT
    mes,
    tipo,
    COUNT(*) AS cantidad,
    SUM(monto) AS total,
    ROUND(AVG(monto), 0) AS promedio
FROM transacciones
GROUP BY mes, tipo
ORDER BY mes, tipo;

Hacé clic en ▶ Ejecutar

Ejemplo 5: GROUP BY con CASE WHEN — agrupar por categoría calculada

ejemplo_05_case_group.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García',720,150000),(2,'López',680,320000),
(3,'Martínez',590,45000),(4,'Pérez',810,890000),(5,'Fernández',645,72000),
(6,'Sosa',750,210000),(7,'Luna',520,30000),(8,'Torres',700,180000);

-- Agrupar por categoría calculada con CASE WHEN
SELECT
    CASE
        WHEN score >= 800 THEN 'Excelente'
        WHEN score >= 700 THEN 'Bueno'
        WHEN score >= 600 THEN 'Regular'
        ELSE 'Bajo'
    END AS categoria,
    COUNT(*) AS cantidad,
    SUM(saldo) AS saldo_total,
    ROUND(AVG(saldo), 0) AS saldo_promedio,
    MIN(score) AS score_min,
    MAX(score) AS score_max
FROM clientes
GROUP BY CASE
        WHEN score >= 800 THEN 'Excelente'
        WHEN score >= 700 THEN 'Bueno'
        WHEN score >= 600 THEN 'Regular'
        ELSE 'Bajo'
    END
ORDER BY score_min DESC;

Hacé clic en ▶ Ejecutar

Referencia rápida

Concepto	Sintaxis	Cuándo usar
Agrupar	`GROUP BY col`	Estadísticas por categoría
Multi-grupo	`GROUP BY c1, c2`	Combinaciones (ciudad+mes)
Filtrar grupos	`HAVING condición_agg`	Solo grupos que cumplan
Regla de oro	Todo en SELECT → GROUP BY o agregación	SIEMPRE

WHERE vs HAVING	WHERE	HAVING
Cuándo filtra	ANTES de agrupar	DESPUÉS de agrupar
Qué filtra	Filas individuales	Grupos completos
Puede usar agregaciones?	NO	SÍ
Ejemplo	`WHERE activo = 1`	`HAVING COUNT(*) > 2`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: GROUP BY simple

Contá cuántos clientes hay por ciudad. Debe incluir Buenos Aires.

ejercicio_01.sqlDebe incluir "Buenos Aires"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720),(2,'López','Córdoba',680),
(3,'Martínez','Rosario',590),(4,'Pérez','Buenos Aires',810),(5,'Fernández','Córdoba',645);

-- Cantidad por ciudad:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: SUM por grupo

Calculá el saldo total por ciudad. Debe incluir 1040000 (BsAs).

ejercicio_02.sqlDebe incluir "1040000"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',150000),(2,'López','Córdoba',320000),
(3,'Martínez','Rosario',45000),(4,'Pérez','Buenos Aires',890000);

-- Saldo total por ciudad:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: AVG por grupo

Calculá el score promedio por ciudad (redondeado). Debe incluir 765 (BsAs).

ejercicio_03.sqlDebe incluir "765"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720),(2,'López','Córdoba',680),
(3,'Martínez','Rosario',590),(4,'Pérez','Buenos Aires',810),(5,'Fernández','Córdoba',645);

-- Score promedio por ciudad:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: HAVING básico

Mostrá solo ciudades con 2 o más clientes. Debe incluir Córdoba.

ejercicio_04.sqlDebe incluir "Córdoba"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720),(2,'López','Córdoba',680),
(3,'Martínez','Rosario',590),(4,'Pérez','Buenos Aires',810),(5,'Fernández','Córdoba',645);

-- Ciudades con 2+ clientes:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: WHERE + GROUP BY

Contá clientes ACTIVOS por ciudad. Debe incluir 3 (BsAs activos).

ejercicio_05.sqlDebe incluir "3"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, activo INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',1),(2,'López','Córdoba',1),
(3,'Martínez','Buenos Aires',0),(4,'Pérez','Buenos Aires',1),
(5,'Fernández','Córdoba',1),(6,'Sosa','Buenos Aires',1);

-- Activos por ciudad:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Transacciones por tipo

Agrupá transacciones por tipo: cantidad y monto total. Ordená por monto total DESC. Debe incluir compra.

ejercicio_06.sqlDebe incluir "compra"

CREATE TABLE transacciones (id INTEGER, tipo TEXT, monto REAL);
INSERT INTO transacciones VALUES (1,'compra',15000),(2,'venta',8000),(3,'compra',32000),
(4,'transferencia',50000),(5,'venta',21000),(6,'compra',9500);

-- Por tipo, ordenado por total:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: GROUP BY múltiples columnas

Agrupá transacciones por mes Y tipo. Debe incluir 2025-01.

ejercicio_07.sqlDebe incluir "2025-01"

CREATE TABLE transacciones (id INTEGER, tipo TEXT, monto REAL, mes TEXT);
INSERT INTO transacciones VALUES (1,'compra',15000,'2025-01'),(2,'venta',8000,'2025-01'),
(3,'compra',32000,'2025-01'),(4,'compra',22000,'2025-02'),(5,'venta',12000,'2025-02');

-- Por mes y tipo:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: WHERE + GROUP BY + HAVING + ORDER BY

De clientes activos, agrupá por ciudad, mostrá solo ciudades con saldo total > $200K, ordená por saldo DESC. Debe incluir Buenos Aires.

ejercicio_08.sqlDebe incluir "Buenos Aires"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, saldo REAL, activo INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',150000,1),(2,'López','Córdoba',320000,1),
(3,'Martínez','Buenos Aires',45000,0),(4,'Pérez','Buenos Aires',890000,1),
(5,'Fernández','Córdoba',72000,1),(6,'Sosa','Rosario',30000,1);

-- El combo completo:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: GROUP BY con CASE WHEN

Agrupá clientes por categoría de score (Excelente/Bueno/Regular/Bajo) y mostrá cantidad y saldo promedio por categoría. Debe incluir Excelente.

ejercicio_09.sqlDebe incluir "Excelente"

CREATE TABLE clientes (id INTEGER, nombre TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García',720,150000),(2,'López',680,320000),
(3,'Martínez',590,45000),(4,'Pérez',810,890000),(5,'Fernández',645,72000),
(6,'Sosa',750,210000),(7,'Luna',520,30000);

-- GROUP BY categoría calculada:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte gerencial por ciudad

Generá un reporte por ciudad con: cantidad de clientes, % del total, saldo total, saldo promedio, score promedio, y cantidad de premium (score>=700). Solo ciudades con 2+ clientes. Ordená por saldo total DESC. Debe incluir premium.

ejercicio_10.sqlDebe incluir "premium"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER, saldo REAL, activo INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720,150000,1),(2,'López','Córdoba',680,320000,1),
(3,'Martínez','Rosario',590,45000,1),(4,'Pérez','Buenos Aires',810,890000,1),
(5,'Fernández','Córdoba',645,72000,1),(6,'Sosa','Buenos Aires',750,210000,1),
(7,'Luna','Córdoba',700,180000,1);

-- Reporte gerencial:

Hacé clic en ▶ Ejecutar

Resumen y conexión

GROUP BY col agrupa filas y permite calcular agregaciones POR grupo.
Regla de oro: toda columna en SELECT que no esté en una agregación DEBE estar en GROUP BY.
HAVING filtra GRUPOS (después de agrupar). WHERE filtra FILAS (antes).
Múltiples columnas en GROUP BY: GROUP BY c1, c2 agrupa por combinación.
Orden de ejecución: FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT.
GROUP BY CASE WHEN ... agrupa por categorías calculadas.

En la siguiente lección (07 · JOINs INNER) vas a aprender a combinar datos de múltiples tablas — la operación que conecta clientes con sus cuentas, transacciones con productos, y más.

Recursos: W3Schools — GROUP BY

Hecho con ❤️ por Rodri Gonzalez