Erros comuns ao trabalhar com agregações

Agora chegou a hora de mergulhar nos erros típicos que aparecem quando a gente usa essas funções. Até os SQL-nerds mais experientes tropeçam nessas armadilhas de vez em quando, e nossa missão é aprender a enxergar esses problemas e desviar deles de boa.

Já rolou de você escrever uma query e ela reclamar de algo misterioso tipo "column must appear in the GROUP BY clause or be used in an aggregate function"? Ou talvez o resultado da sua query ficou estranho e você nem fazia ideia do porquê? Isso é só a pontinha do iceberg dos erros clássicos com funções agregadas. Essa aula é tipo um guia de sobrevivência nesse mar de erros e confusões.

Erro 1: Usar coluna não agregada fora do GROUP BY

Problema

Você escreveu uma query que retorna dados agregados, mas no meio do caminho colocou uma coluna que não faz parte do agrupamento e nem está dentro de uma função agregada. Tipo assim:

SELECT department, salary, SUM(salary)
FROM employees
GROUP BY department;

O PostgreSQL já vai te dar um puxão de orelha:

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

Por que isso acontece?

Quando você usa GROUP BY, o PostgreSQL junta as linhas pelos campos que você indicou. Mas se você coloca outra coluna (nesse caso salary), o PostgreSQL não faz ideia do que você quer fazer com ela. Ele não sabe se você quer só um salário, a média, ou qualquer outra coisa.

Como resolver? Tem dois jeitos:

1. Confirma que todas as colunas não agregadas estão no GROUP BY:

SELECT department, salary
FROM employees
GROUP BY department, salary;

2. Ou coloca a coluna dentro de uma função agregada, se fizer sentido:

SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department;

Dica: se o PostgreSQL reclamar do GROUP BY, se pergunta: "Essa coluna realmente precisa estar na query? Se sim, qual o papel dela aqui?"

Erro 2: Trabalhar errado com COUNT() e NULL

Problema: você quer contar quantos funcionários informaram seus bônus e escreve:

SELECT COUNT(bonus) AS bonus_count
FROM employees;

Mas aí percebe que o resultado é menor do que esperava. Por quê? Porque COUNT(column) ignora as linhas onde column é NULL.

Como resolver: se você quer contar todas as linhas, usa COUNT(*):

SELECT COUNT(*) AS total_count
FROM employees;

Ou deixa claro que você só quer as linhas onde bônus não é NULL:

SELECT COUNT(bonus) AS bonus_count
FROM employees
WHERE bonus IS NOT NULL;

Dica: se você quer considerar a diferença entre registros com NULL e a ausência total de registros na tabela, escolhe com cuidado entre COUNT(*) e COUNT(column).

Erro 3: Esquecer de filtrar com HAVING em vez de WHERE

Problema: você quer achar os departamentos onde o salário médio passa de 5000. Um dev novato pode escrever algo assim:

SELECT department, AVG(salary) AS avg_salary
FROM employees
WHERE AVG(salary) > 5000
GROUP BY department;

O PostgreSQL vai jogar um erro:

ERROR: aggregate functions are not allowed in WHERE clause

Isso acontece porque o filtro do WHERE rola antes do agrupamento, e as funções agregadas só são aplicadas depois do GROUP BY. Ou seja, o AVG(salary) ainda nem existe na hora do WHERE.

Pra resolver, usa HAVING pra filtrar os dados agregados:

SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 5000;

Erro 4: Filtrar com WHERE e se perder na ordem de execução

Problema: você quer saber quantos funcionários tem em departamentos onde a galera tem mais de 30 anos. A query pode ficar assim:

SELECT department, COUNT(*)
FROM employees
GROUP BY department
WHERE age > 30;

O PostgreSQL vai te dar outro erro:

ERROR: syntax error at or near "WHERE"

Por que isso? O operador WHERE sempre é processado antes do GROUP BY. Nesse caso, você só colocou o WHERE no lugar errado.

Pra não cair nessa, troca a ordem: primeiro filtra as linhas, depois agrupa.

SELECT department, COUNT(*)
FROM employees
WHERE age > 30
GROUP BY department;

Erro 5: Usar NULL com SUM(), AVG() e outras funções

Problema: você quer saber o total de bônus pagos pros funcionários e escreve:

SELECT SUM(bonus) AS total_bonus
FROM employees;

Mas o resultado parece baixo demais. Isso porque metade da galera não tem bônus informado, e esses NULL são simplesmente ignorados.

Como resolver: trata o NULL antes. Por exemplo, você pode trocar NULL por 0:

SELECT SUM(COALESCE(bonus, 0)) AS total_bonus
FROM employees;

Agora todos os NULL viram 0 e a soma fica certinha.

A gente vai ver a função COALESCE com mais detalhes em umas próximas aulas.

Erro 6: Usar várias funções agregadas sem entender a relação entre elas

Problema: você quer contar o total de funcionários e o total de salários. Mas escreve algo que retorna uns resultados esquisitos:

SELECT COUNT(salary) AS count_salary, SUM(salary) AS total_salary
FROM employees;

Por que pode dar ruim aqui? Se alguém tem salário NULL, COUNT(salary) e SUM(salary) vão dar resultados diferentes, o que pode confundir.

Lembra sempre que funções agregadas trabalham de forma independente. Se tem NULL, isso vai dar resultados diferentes. Usa COALESCE ou COUNT(*) pra garantir que tudo fique alinhado:

SELECT COUNT(*) AS total_employees, SUM(COALESCE(salary, 0)) AS total_salary
FROM employees;

Erro 7: Queries não otimizadas com muitos agrupamentos

Problema: você roda uma query com um monte de agrupamento e ela demora cinco horas em vez de cinco minutos:

SELECT department, job_title, location, COUNT(*)
FROM employees
GROUP BY department, job_title, location;

Antes de fazer o GROUP BY, pensa se você realmente precisa de todas essas colunas. Quanto mais valores únicos no grupo, mais lenta fica a query. Se der, simplifica o agrupamento:

SELECT department, COUNT(*)
FROM employees
GROUP BY department;

Esses erros são super comuns, e até os devs SQL mais experientes passam por eles. Espero que agora fique mais fácil pra você evitar essas armadilhas e escrever queries que rodem rápido, certo e bonito.