SQL · Lección 05 de 15

Funciones de agregación

Las funciones de agregación resumen muchas filas en un solo valor: cuántos clientes hay, cuál es el saldo total, el score promedio. Son las herramientas que convierten datos crudos en información útil para decisiones de negocio.

80–100 min Prerrequisitos: SQL 04

Concepto teórico

Las 5 funciones esenciales

Función	Qué hace	Ignora NULL?	Ejemplo
`COUNT(*)`	Cuenta TODAS las filas	No (cuenta todo)	`COUNT(*) → 5`
`COUNT(col)`	Cuenta filas donde col NO es NULL	Sí	`COUNT(email) → 3`
`SUM(col)`	Suma valores	Sí	`SUM(saldo) → 1477000`
`AVG(col)`	Promedio	Sí	`AVG(score) → 689`
`MIN(col)`	Valor mínimo	Sí	`MIN(score) → 590`
`MAX(col)`	Valor máximo	Sí	`MAX(saldo) → 890000`

COUNT(*) vs COUNT(col): esta diferencia es CRÍTICA y aparece en entrevistas técnicas. COUNT(*) cuenta TODAS las filas sin importar nada. COUNT(email) cuenta solo las filas donde email NO es NULL. Si tenés 5 clientes y 2 no tienen email: COUNT(*) = 5, COUNT(email) = 3.

AVG y los NULLs: AVG() ignora los NULLs, no los trata como 0. Esto es importante: si tenés saldos [100, NULL, 200], AVG(saldo) = 150 (promedia solo los 2 valores existentes), NO 100 (promedio con 0 incluido). Esto puede distorsionar resultados si hay muchos NULLs.

COUNT(DISTINCT col)

Combina conteo con deduplicación: cuenta cuántos valores ÚNICOS hay en una columna.

SELECT COUNT(*) AS total_registros,
       COUNT(DISTINCT cliente) AS clientes_unicos,
       COUNT(DISTINCT ciudad) AS ciudades
FROM transacciones;

Combinar agregaciones con WHERE

WHERE filtra ANTES de agregar. Esto te permite calcular estadísticas sobre un subconjunto:

-- Promedio de score SOLO de clientes activos
SELECT AVG(score) AS avg_score_activos
FROM clientes
WHERE activo = 1;

ROUND con agregaciones

ROUND(valor, decimales) redondea. Se usa constantemente con AVG y cálculos de porcentaje:

SELECT ROUND(AVG(score), 0) AS score_promedio,
       ROUND(AVG(saldo), 2) AS saldo_promedio,
       ROUND(SUM(saldo) * 100.0 / 1000000, 1) AS pct_del_millon
FROM clientes;

En el trabajo: las funciones de agregación son el corazón de TODOS los reportes. "Total de ventas del mes", "Clientes nuevos esta semana", "Saldo promedio por segmento", "Score máximo de la cartera". Sin GROUP BY (siguiente lección), las agregaciones resumen TODA la tabla en una sola fila. Con GROUP BY, podés resumir por categoría.

Equivalencia con pandas: COUNT(*) = len(df), SUM(col) = df["col"].sum(), AVG(col) = df["col"].mean(), COUNT(DISTINCT col) = df["col"].nunique(). Las mismas operaciones, distinto lenguaje.

Ejemplos explicados paso a paso

Ejemplo 1: Las 5 funciones en acción

ejemplo_01_basicas.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, score INTEGER, saldo REAL, email TEXT);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720,150000,'garcia@mail.com');
INSERT INTO clientes VALUES (2,'López','Córdoba',680,320000,NULL);
INSERT INTO clientes VALUES (3,'Martínez','Rosario',590,45000,'martinez@mail.com');
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000,NULL);
INSERT INTO clientes VALUES (5,'Fernández','Mendoza',645,72000,'fernandez@mail.com');

SELECT
    COUNT(*) AS total_clientes,
    COUNT(email) AS con_email,
    SUM(saldo) AS saldo_total,
    ROUND(AVG(saldo), 0) AS saldo_promedio,
    MIN(score) AS score_minimo,
    MAX(score) AS score_maximo,
    MAX(saldo) - MIN(saldo) AS rango_saldos
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 2: COUNT(*) vs COUNT(col) — la diferencia clave

ejemplo_02_count.sqlSQL

CREATE TABLE clientes (id INTEGER, nombre TEXT, email TEXT, telefono TEXT);
INSERT INTO clientes VALUES (1,'García','garcia@mail.com','+5411234567');
INSERT INTO clientes VALUES (2,'López',NULL,'+5435123456');
INSERT INTO clientes VALUES (3,'Martínez','martinez@mail.com',NULL);
INSERT INTO clientes VALUES (4,'Pérez',NULL,NULL);
INSERT INTO clientes VALUES (5,'Fernández','fernandez@mail.com','+5426112233');

SELECT
    COUNT(*) AS total_filas,           -- 5 (todas las filas)
    COUNT(email) AS con_email,         -- 3 (ignora NULL)
    COUNT(telefono) AS con_telefono,   -- 3 (ignora NULL)
    COUNT(DISTINCT email) AS emails_unicos -- 3 (únicos no-NULL)
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 3: Agregaciones con WHERE

ejemplo_03_where.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','Rosario',590,45000,0);
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000,1);
INSERT INTO clientes VALUES (5,'Fernández','Mendoza',645,72000,1);

-- Solo clientes activos
SELECT
    COUNT(*) AS activos,
    ROUND(AVG(score), 0) AS score_prom,
    SUM(saldo) AS saldo_total
FROM clientes
WHERE activo = 1;

-- Solo Buenos Aires
-- SELECT COUNT(*) AS total_bsas, SUM(saldo) AS saldo_bsas
-- FROM clientes WHERE ciudad = 'Buenos Aires';

Hacé clic en ▶ Ejecutar

Ejemplo 4: Dashboard de métricas en una consulta

ejemplo_04_dashboard.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','Rosario',590,45000,0);
INSERT INTO clientes VALUES (4,'Pérez','Buenos Aires',810,890000,1);
INSERT INTO clientes VALUES (5,'Fernández','Mendoza',645,72000,1);
INSERT INTO clientes VALUES (6,'Sosa','Buenos Aires',750,210000,1);

-- Dashboard completo
SELECT
    COUNT(*) AS total,
    SUM(CASE WHEN activo = 1 THEN 1 ELSE 0 END) AS activos,
    SUM(CASE WHEN activo = 0 THEN 1 ELSE 0 END) AS inactivos,
    SUM(CASE WHEN score >= 700 THEN 1 ELSE 0 END) AS premium,
    ROUND(SUM(CASE WHEN score >= 700 THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) AS pct_premium,
    SUM(saldo) AS saldo_total,
    ROUND(AVG(saldo), 0) AS saldo_promedio,
    COUNT(DISTINCT ciudad) AS ciudades
FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 5: Estadísticas de transacciones

ejemplo_05_transacciones.sqlSQL

CREATE TABLE transacciones (id INTEGER, cliente TEXT, tipo TEXT, monto REAL, fecha TEXT);
INSERT INTO transacciones VALUES (1,'García','compra',15000,'2025-01-15');
INSERT INTO transacciones VALUES (2,'García','compra',32000,'2025-01-20');
INSERT INTO transacciones VALUES (3,'López','venta',8000,'2025-01-18');
INSERT INTO transacciones VALUES (4,'Pérez','transferencia',50000,'2025-02-01');
INSERT INTO transacciones VALUES (5,'García','venta',21000,'2025-02-05');
INSERT INTO transacciones VALUES (6,'López','compra',9500,'2025-02-10');
INSERT INTO transacciones VALUES (7,'Pérez','compra',45000,'2025-02-15');

SELECT
    COUNT(*) AS total_transacciones,
    COUNT(DISTINCT cliente) AS clientes_unicos,
    COUNT(DISTINCT tipo) AS tipos_unicos,
    SUM(monto) AS monto_total,
    ROUND(AVG(monto), 0) AS monto_promedio,
    MIN(monto) AS monto_minimo,
    MAX(monto) AS monto_maximo,
    MIN(fecha) AS primera,
    MAX(fecha) AS ultima
FROM transacciones;

Hacé clic en ▶ Ejecutar

Referencia rápida

Función	Descripción	NULLs	Equivalente pandas
`COUNT(*)`	Total de filas	Cuenta todo	`len(df)`
`COUNT(col)`	Filas no-NULL	Ignora	`df["col"].count()`
`COUNT(DISTINCT col)`	Valores únicos	Ignora	`df["col"].nunique()`
`SUM(col)`	Suma	Ignora	`df["col"].sum()`
`AVG(col)`	Promedio	Ignora	`df["col"].mean()`
`MIN(col)`	Mínimo	Ignora	`df["col"].min()`
`MAX(col)`	Máximo	Ignora	`df["col"].max()`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: COUNT(*)

Contá el total de productos. Debe incluir 5.

ejercicio_01.sqlDebe incluir "5"

CREATE TABLE productos (id INTEGER, nombre TEXT, precio REAL, stock INTEGER);
INSERT INTO productos VALUES (1,'Notebook',920000,15),(2,'Mouse',23000,150),
(3,'Teclado',46000,80),(4,'Monitor',185000,25),(5,'Auriculares',35000,200);

-- Contá productos:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: SUM

Calculá el saldo total de todos los clientes. Debe incluir 1477000.

ejercicio_02.sqlDebe incluir "1477000"

CREATE TABLE clientes (id INTEGER, nombre TEXT, saldo REAL);
INSERT INTO clientes VALUES (1,'García',150000),(2,'López',320000),
(3,'Martínez',45000),(4,'Pérez',890000),(5,'Fernández',72000);

-- Suma de saldos:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: AVG con ROUND

Calculá el score promedio redondeado a entero. Debe incluir 689.

ejercicio_03.sqlDebe incluir "689"

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

-- Promedio redondeado:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: MIN y MAX

Encontrá el score mínimo y máximo, y la diferencia (rango). Debe incluir 220.

ejercicio_04.sqlDebe incluir "220"

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

-- MIN, MAX y rango:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: COUNT(*) vs COUNT(col)

Mostrá COUNT(*) y COUNT(email) para ver la diferencia. Debe incluir 3 (los que tienen email).

ejercicio_05.sqlDebe incluir "3"

CREATE TABLE clientes (id INTEGER, nombre TEXT, email TEXT);
INSERT INTO clientes VALUES (1,'García','garcia@mail.com');
INSERT INTO clientes VALUES (2,'López',NULL);
INSERT INTO clientes VALUES (3,'Martínez','martinez@mail.com');
INSERT INTO clientes VALUES (4,'Pérez',NULL);
INSERT INTO clientes VALUES (5,'Fernández','fernandez@mail.com');

-- Mostrá ambos COUNTs:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Agregación con WHERE

Calculá saldo promedio de clientes activos de Buenos Aires. Debe incluir 416667.

ejercicio_06.sqlDebe incluir "416667"

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

-- Promedio BsAs activos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: COUNT(DISTINCT)

De una tabla de transacciones, contá transacciones totales, clientes únicos y tipos únicos. Debe incluir 3 (clientes).

ejercicio_07.sqlDebe incluir "3"

CREATE TABLE transacciones (id INTEGER, cliente TEXT, tipo TEXT, monto REAL);
INSERT INTO transacciones VALUES (1,'García','compra',1500),(2,'López','venta',800),
(3,'García','compra',3200),(4,'Pérez','transferencia',5000),
(5,'García','venta',2100),(6,'López','compra',950);

-- Conteo total, clientes únicos, tipos únicos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Porcentaje del total

Calculá qué porcentaje del saldo total representa Buenos Aires. Debe incluir un porcentaje (redondeado).

ejercicio_08.sqlDebe incluir el porcentaje

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',810000),(5,'Sosa','Buenos Aires',100000);

-- % que representa BsAs del total:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Múltiples métricas con SUM+CASE

En una sola consulta: total de ventas, cantidad de compras, cantidad de ventas, monto promedio por tipo usando SUM+CASE. Debe incluir compra.

ejercicio_09.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);

-- Dashboard de transacciones:
SELECT
    COUNT(*) AS total,
    SUM(CASE WHEN tipo = 'compra' THEN 1 ELSE 0 END) AS qty_compra,
    SUM(CASE WHEN tipo = 'venta' THEN 1 ELSE 0 END) AS qty_venta
FROM transacciones;

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte ejecutivo completo

Generá un "dashboard" en una sola fila: total clientes, activos, inactivos, % activos, saldo total, promedio, máximo, ciudades únicas, y cantidad de premium (score>=700). Debe incluir total.

ejercicio_10.sqlDebe incluir "total"

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,0),(4,'Pérez','Buenos Aires',810,890000,1),
(5,'Fernández','Mendoza',645,72000,1),(6,'Sosa','Buenos Aires',750,210000,1);

-- Dashboard completo:

Hacé clic en ▶ Ejecutar

Resumen y conexión

COUNT(*) cuenta todas las filas. COUNT(col) cuenta solo las no-NULL.
SUM, AVG, MIN, MAX ignoran NULLs automáticamente.
COUNT(DISTINCT col) cuenta valores únicos.
ROUND(valor, n) redondea a n decimales.
WHERE filtra ANTES de la agregación.
SUM(CASE WHEN ... THEN 1 ELSE 0 END) permite contar condicionalmente.

En la siguiente lección (06 · GROUP BY y HAVING) vas a aprender a agrupar datos: estadísticas POR CIUDAD, POR TIPO, POR CATEGORÍA — el equivalente de df.groupby() en pandas.

Hecho con ❤️ por Rodri Gonzalez