¿Cómo usar funciones de agregación como SUM, COUNT y AVG? | SQL y Bases de Datos: Curso Gratis desde Cero

Las funciones de agregación toman muchas filas de datos y las convierten en un solo número útil, como un total, un conteo o un promedio.

Cuando los datos crudos no dicen nada

Imagina que eres analista de datos en Liverpool. Tu jefe te pide el total de ventas del mes. Tienes una tabla con 50,000 filas de transacciones individuales. Abrir Excel y sumar todo a mano tomaría horas. Con SQL, lo resuelves en una sola línea. Eso es exactamente lo que hacen las funciones de agregación: trabajan por ti directamente en la base de datos.

El sistema de las cinco funciones esenciales

SQL tiene cinco funciones de agregación que debes conocer desde el principio. Puedes llamarlas el Sistema SCAMM (por sus iniciales):

SUM() — Suma todos los valores de una columna numérica.
COUNT() — Cuenta cuántas filas existen.
AVG() — Calcula el promedio de una columna numérica.
MAX() — Encuentra el valor más alto.
MIN() — Encuentra el valor más bajo.

Cada función recibe el nombre de una columna adentro de los paréntesis. Le dices a SQL: "toma esta columna y agrégala".

SUM(): el total que tu jefe siempre pide

SUP te permite sumar todos los valores de una columna. La sintaxis básica es:

SELECT SUM(nombre_columna)
FROM nombre_tabla;

Ejemplo real: tienes una tabla ventas en la base de datos de FEMSA con una columna monto. Quieres saber cuánto vendieron en total.

SELECT SUM(monto) AS total_ventas
FROM ventas;

Resultado:

total_ventas
------------
$4,850,000

Con AS total_ventas le das un nombre claro a la columna calculada. Sin alias, la columna aparece como SUM(monto), que es difícil de leer en un reporte.

COUNT(): saber cuántos registros tienes

COUNT() cuenta filas. Hay dos formas de usarlo y es importante entender la diferencia.

COUNT(*) cuenta todas las filas, incluyendo las que tienen valores nulos:

SELECT COUNT(*) AS total_pedidos
FROM pedidos;

COUNT(columna) cuenta solo las filas donde esa columna no es nula:

SELECT COUNT(fecha_entrega) AS pedidos_entregados
FROM pedidos;

Ejemplo práctico con Mercado Libre: imagina que tienes una tabla pedidos y quieres saber cuántos pedidos se realizaron en total versus cuántos ya tienen fecha de entrega registrada.

SELECT
  COUNT(*) AS total_pedidos,
  COUNT(fecha_entrega) AS pedidos_entregados
FROM pedidos;

Resultado:

total_pedidos  pedidos_entregados
-------------  ------------------
12,400         9,875

Eso significa que 2,525 pedidos aún no tienen fecha de entrega. Un dato valioso que tomó dos segundos obtener.

AVG(): el promedio que revela tendencias

AVG() divide la suma de todos los valores entre el número de filas. Es perfecto para analizar salarios, precios o calificaciones.

Ejemplo con Bimbo: tienes una tabla empleados con columnas nombre, departamento y salario. Quieres saber el salario promedio de toda la empresa.

SELECT AVG(salario) AS salario_promedio
FROM empleados;

Resultado:

salario_promedio
----------------
$18,500

Si el resultado tuviera decimales, SQL los mostraría. Puedes redondearlo con ROUND(AVG(salario), 0) para un número más limpio.

La combinación perfecta: funciones + GROUP BY

Las funciones de agregación son poderosas solas, pero se vuelven increíbles cuando las combinas con GROUP BY. GROUP BY divide tus datos en grupos y luego aplica la función a cada grupo por separado.

Piénsalo así: GROUP BY es como ordenar papeles en carpetas por categoría. Luego calculas el total de cada carpeta por separado.

Ejemplo con Liverpool: tienes una tabla ventas con columnas departamento, producto y monto. Quieres el total de ventas por departamento.

SELECT
  departamento,
  SUM(monto) AS total_ventas,
  COUNT(*) AS num_transacciones,
  AVG(monto) AS venta_promedio
FROM ventas
GROUP BY departamento;

Resultado:

departamento      total_ventas   num_transacciones  venta_promedio
----------------  ------------   -----------------  --------------
Electrónica       $1,250,000     3,400              $368
Ropa              $890,000       5,200              $171
Hogar             $620,000       2,800              $221
Juguetes          $430,000       1,900              $226

En una sola consulta obtuviste tres métricas diferentes para cuatro departamentos. Eso es un reporte completo.

MAX() y MIN(): los extremos que importan

MAX() y MIN() encuentran el valor más alto y más bajo en una columna. Son útiles para detectar el producto más caro, el pedido más grande o el empleado con el salario mínimo.

Ejemplo con FEMSA: quieres saber el precio más alto y más bajo de sus productos por categoría.

SELECT
  categoria,
  MAX(precio) AS precio_maximo,
  MIN(precio) AS precio_minimo
FROM productos
GROUP BY categoria;

Resultado:

categoria       precio_maximo  precio_minimo
--------------  -------------  -------------
Refrescos       $32            $8
Agua            $18            $6
Bebidas energéticas  $45       $22

Ahora sabes el rango de precios de cada categoría de un vistazo.

Cómo ordenar tus resultados agregados

Puedes combinar todo lo aprendido: funciones de agregación, GROUP BY y ORDER BY en una sola consulta. El orden de las cláusulas siempre es:

SELECT → FROM → WHERE → GROUP BY → ORDER BY

Ejemplo: quieres los departamentos de Liverpool ordenados de mayor a menor venta.

SELECT
  departamento,
  SUM(monto) AS total_ventas
FROM ventas
GROUP BY departamento
ORDER BY total_ventas DESC;

Resultado:

departamento      total_ventas
----------------  ------------
Electrónica       $1,250,000
Ropa              $890,000
Hogar             $620,000
Juguetes          $430,000

Ahora el reporte está ordenado y listo para presentar.

Errores comunes al usar funciones de agregación

Hay tres errores que casi todos cometen al inicio. Conocerlos ahora te ahorra frustración.

Error 1: mezclar columnas sin GROUP BY

Este código es incorrecto:

SELECT departamento, SUM(monto)
FROM ventas;

SQL no sabe si quieres el total por departamento o el total general. Necesitas agregar GROUP BY departamento o eliminar departamento del SELECT.

Error 2: usar WHERE con funciones de agregación

Si quieres filtrar por el resultado de una función (por ejemplo, solo departamentos con ventas mayores a $500,000), no puedes usar WHERE. Para eso existe HAVING:

SELECT departamento, SUM(monto) AS total_ventas
FROM ventas
GROUP BY departamento
HAVING SUM(monto) > 500000;

HAVING filtra grupos después de que GROUP BY los crea. WHERE filtra filas individuales antes de agrupar. Son dos herramientas distintas.

Error 3: olvidar el alias

Sin alias, tu reporte muestra columnas con nombres como SUM(monto) o COUNT(*). Siempre agrega AS nombre_descriptivo para que tus resultados sean profesionales y legibles.

Cómo aplicar esto hoy mismo

Si tienes acceso a cualquier base de datos, sigue estos tres pasos:

Identifica una tabla con columnas numéricas (ventas, salarios, precios, cantidades).
Escribe una consulta con SUM() o COUNT(*) sin GROUP BY para ver el total general.
Agrega GROUP BY con una columna categórica (departamento, región, producto) para desglozar el total.

Empezar con lo general y luego desglozar es el flujo natural de cualquier análisis de datos.

Las funciones de agregación son el puente entre datos crudos y decisiones de negocio: sin ellas, tienes filas; con ellas, tienes respuestas.