Errores típicos al trabajar con agregados

Ahora toca profundizar en los errores típicos que aparecen cuando usamos estas funciones. Incluso los cracks de SQL a veces pisan el mismo rastrillo, y nuestra misión es aprender a ver esos rastrillos y esquivarlos con estilo.

¿Alguna vez has escrito una consulta y te ha saltado un error raro tipo "column must appear in the GROUP BY clause or be used in an aggregate function"? ¿O el resultado de tu consulta era rarísimo y no tenías ni idea de por qué? Eso es solo la punta del iceberg de los errores típicos con funciones agregadas. Esta lección es tu guía de supervivencia en el mar de errores y malentendidos.

Error 1: Usar una columna no agregada fuera de GROUP BY

Problema

Has escrito una consulta que devuelve datos agregados, pero por el camino has añadido una columna que no está en el grupo ni envuelta en una función agregada. Por ejemplo:

SELECT departamento, salario, SUM(salario)
FROM empleados
GROUP BY departamento;

PostgreSQL te va a decir:

ERROR: column "empleados.salario" must appear in the GROUP BY clause or be used in an aggregate function

¿Por qué pasa esto?

Cuando usas GROUP BY, PostgreSQL agrupa las filas por las columnas que indiques. Pero si añades otra columna (en este caso salario), PostgreSQL no sabe qué hacer con ella. No sabe si quieres solo un salario, el promedio o qué.

¿Cómo arreglarlo? Hay dos caminos:

1. Asegúrate de que todas las columnas no agregadas estén en el GROUP BY:

SELECT departamento, salario
FROM empleados
GROUP BY departamento, salario;

2. O envuelve la columna en una función agregada, si tiene sentido:

SELECT departamento, AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento;

Consejo: si PostgreSQL se queja del GROUP BY, pregúntate: "¿De verdad necesito esta columna en la consulta? Si sí, ¿qué papel juega exactamente?"

Error 2: Mal uso de COUNT() y NULL

Problema: quieres contar cuántos empleados han puesto su bono, y escribes:

SELECT COUNT(bono) AS cantidad_bonos
FROM empleados;

Pero de repente ves que el resultado es menor de lo que esperabas. ¿Por qué? Porque COUNT(columna) ignora las filas donde columna es NULL.

Solución: si quieres contar todas las filas, usa COUNT(*):

SELECT COUNT(*) AS total_filas
FROM empleados;

O aclara que solo quieres las filas donde el bono no es NULL:

SELECT COUNT(bono) AS cantidad_bonos
FROM empleados
WHERE bono IS NOT NULL;

Pista: si quieres tener en cuenta la diferencia entre registros con NULL y la ausencia total de registros en la tabla, elige bien entre COUNT(*) y COUNT(columna).

Error 3: Olvidar filtrar con HAVING en vez de WHERE

Problema: quieres encontrar los departamentos donde el salario promedio es mayor que 5000. Un desarrollador novato puede escribir algo así:

SELECT departamento, AVG(salario) AS salario_promedio
FROM empleados
WHERE AVG(salario) > 5000
GROUP BY departamento;

PostgreSQL te va a lanzar un error:

ERROR: aggregate functions are not allowed in WHERE clause

Esto pasa porque el filtro WHERE se ejecuta antes del agrupamiento, y las funciones agregadas se aplican después del GROUP BY. Así que el salario promedio AVG(salario) aún no existe cuando se ejecuta el WHERE.

Para arreglarlo, usa HAVING para filtrar los datos agregados:

SELECT departamento, AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento
HAVING AVG(salario) > 5000;

Error 4: Filtrar con WHERE y liarse con el orden de ejecución

Problema: quieres saber cuántos empleados hay en los departamentos donde la edad de los empleados es mayor de 30 años. La consulta puede ser así:

SELECT departamento, COUNT(*)
FROM empleados
GROUP BY departamento
WHERE edad > 30;

PostgreSQL otra vez te va a fastidiar:

ERROR: syntax error at or near "WHERE"

¿Por qué pasa esto? El operador WHERE siempre se procesa antes que el GROUP BY. En este caso, simplemente has puesto el WHERE en el sitio equivocado.

Para evitar esto, cambia el orden: primero filtra las filas, luego haz el agrupamiento.

SELECT departamento, COUNT(*)
FROM empleados
WHERE edad > 30
GROUP BY departamento;

Error 5: Usar NULL con SUM(), AVG() y otras funciones

Problema: quieres saber el bono total dado a los empleados, y escribes:

SELECT SUM(bono) AS bono_total
FROM empleados;

Pero el resultado te parece sospechosamente bajo. Y es porque la mitad de los empleados no tienen bono, y esos NULL simplemente se ignoran.

Solución: trata los NULL antes. Por ejemplo, puedes cambiar los NULL por 0:

SELECT SUM(COALESCE(bono, 0)) AS bono_total
FROM empleados;

Ahora todos los NULL serán 0 y la suma será correcta.

Vamos a ver la función COALESCE en detalle en un par de lecciones.

Error 6: Usar varias funciones agregadas sin entender su relación

Problema: quieres contar el total de empleados y el total de salarios. Pero escribes algo que da resultados raros:

SELECT COUNT(salario) AS cantidad_salarios, SUM(salario) AS salario_total
FROM empleados;

¿Por qué puede salir mal? Si alguien tiene salario NULL, COUNT(salario) y SUM(salario) van a dar resultados diferentes, y eso puede liar mucho.

Recuerda siempre que las funciones agregadas trabajan de forma independiente. Si hay NULL, eso lleva a resultados distintos. Usa COALESCE o COUNT(*) para asegurarte de que todo cuadra:

SELECT COUNT(*) AS total_empleados, SUM(COALESCE(salario, 0)) AS salario_total
FROM empleados;

Error 7: Consultas no optimizadas con muchos agrupamientos

Problema: lanzas una consulta con un montón de agrupamientos y tarda cinco horas en vez de cinco minutos:

SELECT departamento, puesto_trabajo, ubicacion, COUNT(*)
FROM empleados
GROUP BY departamento, puesto_trabajo, ubicacion;

Antes de agrupar, piensa si de verdad necesitas todas esas columnas en el GROUP BY. Cuantos más valores únicos haya en el grupo, más tarda la consulta. Si puedes, reduce el agrupamiento:

SELECT departamento, COUNT(*)
FROM empleados
GROUP BY departamento;

Estos errores son muy comunes, y hasta los desarrolladores de SQL más experimentados se los encuentran. Espero que ahora te sea más fácil esquivar estas piedras en el camino y escribir consultas que vayan rápido, sean correctas y queden chulas.