Las funciones de agregación de SQL calculan un solo valor a partir de muchas filas: COUNT cuenta filas, SUM suma números, AVG los promedia, y MIN y MAX encuentran el valor más pequeño y el más grande. Combinadas con GROUP BY, convierten miles de filas en un resumen, como los ingresos totales por región o los pedidos por cliente.
Casi todo reporte empieza con una agregación. ¿Cuántos pedidos recibimos? ¿Cuál es el valor promedio por pedido? ¿Qué región vendió más? Las funciones de agregación responden esas preguntas directamente en la base de datos, sin exportar los datos a una hoja de cálculo.
Esta guía explica las cinco funciones de agregación principales, GROUP BY y HAVING, cómo los valores NULL cambian los resultados, la agregación condicional y las diferencias entre bases de datos que producen números equivocados. Todos los ejemplos se probaron en PostgreSQL 17, MySQL 8.4, SQL Server 2022 y SQLite. Forma parte de un conjunto con Funciones de Texto en SQL y Funciones de Fecha en SQL.
Datos de Ejemplo para Esta Guía
Los ejemplos usan una pequeña tabla orders (pedidos). Algunos pedidos tienen descuento y otros tienen NULL (sin descuento registrado), lo que importa más adelante. Los nombres de tablas y columnas están en inglés para que coincidan con la salida de ejemplo.
CREATE TABLE orders (
id INT PRIMARY KEY,
customer VARCHAR(30),
region VARCHAR(10),
product VARCHAR(20),
quantity INT,
unit_price DECIMAL(8,2),
discount DECIMAL(4,2),
order_date DATE
);
INSERT INTO orders VALUES
(1, 'Maria Lopez', 'North', 'Laptop', 1, 900.00, 0.10, '2026-01-05'),
(2, 'James Carter', 'South', 'Monitor', 2, 250.00, NULL, '2026-01-09'),
(3, 'Maria Lopez', 'North', 'Mouse', 3, 25.00, NULL, '2026-01-15'),
(4, 'Sofia Nguyen', 'East', 'Desk', 1, 320.00, 0.05, '2026-01-22'),
(5, 'James Carter', 'South', 'Laptop', 1, 900.00, 0.15, '2026-02-03'),
(6, 'Daniel Brooks', 'West', 'Keyboard', 4, 45.00, NULL, '2026-02-11'),
(7, 'Sofia Nguyen', 'East', 'Monitor', 1, 250.00, NULL, '2026-02-18'),
(8, 'Maria Lopez', 'North', 'Desk', 2, 320.00, 0.10, '2026-02-25'),
(9, 'Daniel Brooks', 'West', 'Laptop', 2, 900.00, 0.05, '2026-03-04'),
(10, 'James Carter', 'South', 'Mouse', 5, 25.00, NULL, '2026-03-12');
Las mismas sentencias funcionan en las cuatro bases de datos. El total de cada pedido es quantity * unit_price. Los ejemplos muestran la salida de PostgreSQL; las demás bases de datos devuelven los mismos valores salvo que se indique lo contrario.
Tabla Rápida
| Función | Qué devuelve | ¿Ignora los NULL? | Sin filas |
|---|---|---|---|
COUNT(*) | Número de filas | Cuenta todas las filas | 0 |
COUNT(columna) | Número de valores que no son NULL | Sí | 0 |
COUNT(DISTINCT columna) | Número de valores distintos que no son NULL | Sí | 0 |
SUM(columna) | Total | Sí | NULL |
AVG(columna) | Promedio | Sí | NULL |
MIN(columna) / MAX(columna) | Valor más pequeño / más grande (números, fechas o texto) | Sí | NULL |
COUNT: ¿Cuántas Filas?
COUNT tiene tres formas, y la diferencia importa:
SELECT COUNT(*) AS all_rows,
COUNT(discount) AS with_discount,
COUNT(DISTINCT customer) AS customers,
COUNT(DISTINCT product) AS products
FROM orders;
all_rows | with_discount | customers | products
----------+---------------+-----------+----------
10 | 5 | 4 | 5
COUNT(*)cuenta todas las filas: 10 pedidos.COUNT(discount)cuenta solo las filas dondediscountno es NULL: 5 pedidos tuvieron descuento.COUNT(DISTINCT customer)cuenta valores distintos: los 10 pedidos vinieron de 4 clientes.
Usa COUNT(*) para contar filas, y COUNT(columna) solo cuando quieras omitir los NULL a propósito.
SUM, AVG, MIN y MAX
SELECT SUM(quantity * unit_price) AS revenue,
AVG(quantity * unit_price) AS avg_order,
MIN(quantity * unit_price) AS smallest,
MAX(quantity * unit_price) AS largest
FROM orders;
revenue | avg_order | smallest | largest
---------+----------------------+----------+---------
5690.00 | 569.0000000000000000 | 75.00 | 1800.00
Las funciones de agregación pueden trabajar sobre una expresión, como quantity * unit_price, no solo sobre una columna. Para que el promedio sea legible, redondéalo: ROUND(AVG(quantity * unit_price), 2) devuelve 569.00.
MIN y MAX también funcionan con fechas y texto:
SELECT MIN(order_date) AS first_order,
MAX(order_date) AS last_order,
MIN(customer) AS first_alphabetically
FROM orders;
first_order | last_order | first_alphabetically
-------------+------------+----------------------
2026-01-05 | 2026-03-12 | Daniel Brooks
Cuidado: AVG de Números Enteros en SQL Server
SELECT AVG(quantity) AS avg_qty FROM orders;
PostgreSQL, MySQL y SQLite devuelven 2.2. SQL Server devuelve 2, porque el promedio de una columna INT también es INT, así que se corta la parte decimal. Convierte el valor primero:
SELECT AVG(1.0 * quantity) AS avg_qty FROM orders; -- 2.200000 en SQL Server
Cómo Cambian los Resultados los Valores NULL
Las funciones de agregación omiten los NULL (excepto COUNT(*)). Normalmente es lo que quieres, pero no siempre:
SELECT AVG(discount) AS avg_ignoring_nulls,
AVG(COALESCE(discount, 0)) AS avg_nulls_as_zero
FROM orders;
avg_ignoring_nulls | avg_nulls_as_zero
------------------------+------------------------
0.09000000000000000000 | 0.04500000000000000000
AVG(discount)promedia solo los 5 pedidos con descuento: 9%.AVG(COALESCE(discount, 0))trata los descuentos faltantes como 0 y promedia los 10 pedidos: 4.5%.
Los dos son correctos; responden preguntas distintas. “¿Cuál es el descuento típico cuando damos uno?” es la primera. “¿Cuál es el descuento promedio de todos los pedidos?” es la segunda. Decide qué significa NULL en tus datos antes de promediar.
Sin Filas que Coincidan: SUM Devuelve NULL, No 0
SELECT COUNT(*) AS n, SUM(quantity) AS units, MAX(order_date) AS latest
FROM orders
WHERE region = 'Central';
n | units | latest
---+-------+--------
0 | |
COUNT devuelve 0, pero SUM, AVG, MIN y MAX devuelven NULL (se ve en blanco) cuando no hay filas. En los reportes, envuélvelas en COALESCE: COALESCE(SUM(quantity), 0) devuelve 0.
GROUP BY: Un Resultado por Grupo
Sin GROUP BY, una agregación devuelve una sola fila para toda la tabla. Con GROUP BY, obtienes una fila por grupo:
SELECT region,
COUNT(*) AS orders,
SUM(quantity * unit_price) AS revenue
FROM orders
GROUP BY region
ORDER BY revenue DESC;
region | orders | revenue
--------+--------+---------
West | 2 | 1980.00
North | 3 | 1615.00
South | 3 | 1525.00
East | 2 | 570.00
El oeste (West) tiene menos pedidos pero más ingresos, gracias a un pedido de dos laptops. Ese es el tipo de hallazgo que un total por sí solo no muestra.
Agrupa por varias columnas para obtener una fila por cada combinación:
SELECT region, product, SUM(quantity) AS units
FROM orders
GROUP BY region, product
ORDER BY region, product;
region | product | units
--------+----------+-------
East | Desk | 1
East | Monitor | 1
North | Desk | 2
North | Laptop | 1
North | Mouse | 3
South | Laptop | 1
South | Monitor | 2
South | Mouse | 5
West | Keyboard | 4
West | Laptop | 2
La Regla de GROUP BY
Cada columna del SELECT debe estar en el GROUP BY o dentro de una función de agregación. Esta consulta rompe la regla, porque una región tiene varios clientes y la base de datos no sabe cuál mostrar:
SELECT region, customer FROM orders GROUP BY region;
- PostgreSQL:
ERROR: column "orders.customer" must appear in the GROUP BY clause or be used in an aggregate function - SQL Server:
Column 'orders.customer' is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause. - MySQL 8:
ERROR 1055 ... incompatible with sql_mode=only_full_group_by - SQLite: se ejecuta sin error y devuelve un cliente de cada región, pero no está definido cuál. No dependas de eso.
WHERE vs. HAVING
Los dos filtran, pero en momentos distintos:
WHEREfiltra filas antes de agruparlas.HAVINGfiltra grupos después de calcular las agregaciones, así que puede usarSUM,COUNT, etc.
Clientes con más de 1,500 en ingresos:
SELECT customer, COUNT(*) AS orders, SUM(quantity * unit_price) AS revenue
FROM orders
GROUP BY customer
HAVING SUM(quantity * unit_price) > 1500
ORDER BY revenue DESC;
customer | orders | revenue
---------------+--------+---------
Daniel Brooks | 2 | 1980.00
Maria Lopez | 3 | 1615.00
James Carter | 3 | 1525.00
Usando los dos: clientes con al menos dos pedidos desde el 1 de febrero:
SELECT customer, SUM(quantity * unit_price) AS revenue
FROM orders
WHERE order_date >= '2026-02-01'
GROUP BY customer
HAVING COUNT(*) >= 2
ORDER BY revenue DESC;
customer | revenue
---------------+---------
Daniel Brooks | 1980.00
James Carter | 1025.00
WHERE quitó primero los pedidos de enero, y luego HAVING dejó solo a los clientes con dos o más pedidos restantes. Maria Lopez tuvo solo un pedido después del 1 de febrero, así que no aparece.
El Orden en que se Ejecuta SQL
SQL se escribe en un orden pero se evalúa en otro, lo que explica por qué WHERE no puede usar agregaciones y HAVING sí:
FROM(y los joins)WHEREGROUP BY- Funciones de agregación
HAVINGSELECTORDER BYLIMIT/TOP
Pon las condiciones sobre filas individuales en WHERE siempre que puedas; filtrar temprano es más rápido que filtrar grupos después.
Agregación Condicional: Varios Totales en una Consulta
Pon una expresión CASE dentro de una agregación para contar o sumar solo algunas filas. Así armas una pequeña tabla cruzada en una sola consulta:
SELECT region,
SUM(CASE WHEN product = 'Laptop' THEN quantity ELSE 0 END) AS laptops,
SUM(CASE WHEN product <> 'Laptop' THEN quantity ELSE 0 END) AS other_units,
COUNT(CASE WHEN discount IS NOT NULL THEN 1 END) AS discounted_orders
FROM orders
GROUP BY region
ORDER BY region;
region | laptops | other_units | discounted_orders
--------+---------+-------------+-------------------
East | 0 | 2 | 1
North | 1 | 5 | 2
South | 1 | 7 | 1
West | 2 | 4 | 1
COUNT(CASE WHEN ... THEN 1 END) funciona porque CASE devuelve NULL cuando la condición es falsa, y COUNT omite los NULL. Este patrón funciona en todas las bases de datos.
PostgreSQL y SQLite también admiten una cláusula FILTER más corta: COUNT(*) FILTER (WHERE discount IS NOT NULL). MySQL y SQL Server no, así que ahí usa CASE.
Porcentaje del Total
Para mostrar la participación de cada región en los ingresos, divide el total de cada grupo entre el total general:
SELECT region,
SUM(quantity * unit_price) AS revenue,
ROUND(100.0 * SUM(quantity * unit_price)
/ (SELECT SUM(quantity * unit_price) FROM orders), 1) AS pct
FROM orders
GROUP BY region
ORDER BY revenue DESC;
region | revenue | pct
--------+---------+------
West | 1980.00 | 34.8
North | 1615.00 | 28.4
South | 1525.00 | 26.8
East | 570.00 | 10.0
La subconsulta calcula el total general una vez. También puedes usar una función de ventana, SUM(SUM(quantity * unit_price)) OVER (), que devuelve el mismo resultado. Consulta Funciones de Ventana en SQL para ver en qué se diferencian: una agregación reduce las filas a una por grupo, mientras que una función de ventana conserva todas las filas. Multiplicar por 100.0 en lugar de 100 evita la división entera.
Subtotales y Totales Generales con ROLLUP
ROLLUP agrega una fila de total a los resultados agrupados:
SELECT COALESCE(region, 'Total') AS region, SUM(quantity * unit_price) AS revenue
FROM orders
GROUP BY ROLLUP (region)
ORDER BY GROUPING(region), region;
region | revenue
--------+---------
East | 570.00
North | 1615.00
South | 1525.00
West | 1980.00
Total | 5690.00
La fila de total tiene NULL en la columna agrupada, y COALESCE la convierte en “Total”. GROUPING(region) vale 1 en esa fila, así que ordenar por él deja el total al final. La sintaxis cambia:
| Base de datos | Sintaxis |
|---|---|
| PostgreSQL, SQL Server | GROUP BY ROLLUP (region) |
| MySQL | GROUP BY region WITH ROLLUP (GROUPING() también funciona) |
| SQLite | No lo admite; usa UNION ALL con una consulta aparte para el total |
Agrupar por Mes
Agrupa por una expresión de fecha para obtener totales mensuales. En PostgreSQL:
SELECT TO_CHAR(order_date, 'YYYY-MM') AS month,
COUNT(*) AS orders,
SUM(quantity * unit_price) AS revenue
FROM orders
GROUP BY TO_CHAR(order_date, 'YYYY-MM')
ORDER BY month;
month | orders | revenue
---------+--------+---------
2026-01 | 4 | 1795.00
2026-02 | 4 | 1970.00
2026-03 | 2 | 1925.00
En SQLite usa strftime('%Y-%m', order_date); MySQL y SQL Server tienen sus propias funciones. Funciones de Fecha en SQL cubre cómo agrupar por día, semana, mes y año en las cuatro bases de datos.
Otras Funciones de Agregación Útiles
| Necesidad | PostgreSQL | MySQL | SQL Server | SQLite |
|---|---|---|---|---|
| Unir texto de muchas filas | STRING_AGG | GROUP_CONCAT | STRING_AGG | GROUP_CONCAT |
| Mediana | PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY x) | (no incluida) | PERCENTILE_CONT como función de ventana | (no incluida) |
| Desviación estándar (muestral) | STDDEV_SAMP | STDDEV_SAMP | STDEV | (no incluida) |
La mediana del valor por pedido en los datos de ejemplo es 410, y el promedio es 569. Unos cuantos pedidos grandes de laptops suben el promedio, así que la mediana describe mejor un pedido “típico”. Funciones de Texto en SQL muestra STRING_AGG y GROUP_CONCAT en acción.
Cuidado con los nombres de la desviación estándar: en MySQL, STDDEV a secas es la desviación poblacional, mientras que en PostgreSQL es la muestral. Usar STDDEV_SAMP o STDDEV_POP deja clara tu intención.
Errores Comunes que Debes Evitar
- Usar
COUNT(columna)cuando queríasCOUNT(*), y omitir sin darte cuenta las filas con NULL. - Promediar con NULL sin decidir si un valor faltante significa “desconocido” o “cero”.
- Olvidar que
SUMsin filas es NULL, lo que deja espacios en blanco en los reportes y rompe los cálculos. UsaCOALESCE(SUM(x), 0). - Promedios enteros en SQL Server, que pierden la parte decimal.
- Seleccionar columnas que no están agrupadas ni agregadas, lo que da error en la mayoría de las bases de datos y devuelve valores impredecibles en SQLite.
- Filtrar agregaciones en
WHERE.WHERE SUM(x) > 100es un error; usaHAVING. - Contar duplicados después de un join. Unir los pedidos con sus artículos multiplica las filas, así que
COUNT(*)ySUMse inflan. Cuenta los ID conDISTINCTo agrega antes de unir. Consulta Los JOINs de SQL Explicados. - División entera en porcentajes.
100 * a / bcon números enteros puede redondear a 0; usa100.0.
Preguntas Frecuentes
¿Qué son las funciones de agregación en SQL?
Son funciones que toman muchas filas y devuelven un solo valor, como un conteo, un total, un promedio, un mínimo o un máximo. Las cinco estándar son COUNT, SUM, AVG, MIN y MAX.
¿Cuál es la diferencia entre COUNT(*) y COUNT(columna)?
COUNT(*) cuenta todas las filas. COUNT(columna) cuenta solo las filas donde esa columna no es NULL. COUNT(DISTINCT columna) cuenta cuántos valores distintos que no son NULL hay.
¿Las funciones de agregación ignoran los valores NULL?
Sí, todas excepto COUNT(*). Eso significa que AVG divide solo entre la cantidad de valores que no son NULL. Usa COALESCE(columna, 0) si los valores faltantes deben contar como cero.
¿Cuál es la diferencia entre WHERE y HAVING?
WHERE filtra filas individuales antes de agrupar y no puede usar funciones de agregación. HAVING filtra grupos después de agregar y sí puede, por ejemplo, HAVING COUNT(*) > 5.
¿Puedo usar una función de agregación sin GROUP BY?
Sí. Sin GROUP BY, la agregación trata toda la tabla (después del WHERE) como un solo grupo y devuelve una fila, como el ingreso total.
¿Cuál es la diferencia entre las funciones de agregación y las de ventana?
Las funciones de agregación con GROUP BY devuelven una fila por grupo. Las funciones de ventana, escritas con OVER(), calculan el mismo tipo de valores pero conservan todas las filas originales, lo que sirve para totales acumulados y rankings.
Conclusión
Las funciones de agregación son la base de los reportes en SQL. COUNT, SUM, AVG, MIN y MAX resumen los datos; GROUP BY divide el resumen por categoría; HAVING filtra los grupos; y la agregación condicional con CASE arma varios totales en una sola consulta.
La mayoría de los números equivocados vienen de unos cuantos detalles: los NULL que se omiten, SUM que devuelve NULL sin resultados, los promedios enteros en SQL Server y las filas duplicadas después de los joins. Revísalos, prueba tus consultas con un conjunto de datos pequeño cuyas respuestas conozcas, y tus reportes cuadrarán.
