Funções de agregação: COUNT, SUM, AVG, MIN, MAX

1. Introdução às Funções de Agregação

As funções de agregação em SQL são operações especializadas que processam um conjunto de linhas e retornam um único valor resumido. Elas são fundamentais para análise de dados, permitindo extrair insights como totais, médias, contagens e extremos de forma eficiente diretamente no banco de dados.

Diferentemente das funções de linha única (como UPPER(), LENGTH() ou ROUND()), que operam linha a linha e retornam um resultado por registro, as funções de agregação operam sobre grupos de linhas. Enquanto uma função de linha única transforma cada valor individualmente, uma função de agregação condensa múltiplos valores em um único resultado.

O contexto mais comum de uso é em consultas SELECT combinadas com a cláusula GROUP BY, que divide os dados em categorias para que as agregações sejam aplicadas separadamente a cada grupo. No entanto, também podem ser usadas sem GROUP BY, caso em que a agregação ocorre sobre todas as linhas da tabela.

2. COUNT: Contando Registros

A função COUNT é a mais básica das funções de agregação. Sua sintaxe apresenta três variações importantes:

  • COUNT(*) – conta todas as linhas da tabela, independentemente de valores nulos.
  • COUNT(coluna) – conta apenas linhas onde a coluna especificada não é NULL.
  • COUNT(DISTINCT coluna) – conta o número de valores únicos não nulos em uma coluna.

O comportamento com NULL é crucial: COUNT(*) inclui linhas com todos os campos nulos, enquanto COUNT(coluna) ignora linhas onde aquela coluna específica é nula.

Exemplo prático:

-- Contagem total de funcionários
SELECT COUNT(*) AS total_funcionarios
FROM funcionarios;

-- Funcionários com salário registrado (não nulo)
SELECT COUNT(salario) AS funcionarios_com_salario
FROM funcionarios;

-- Número de departamentos distintos
SELECT COUNT(DISTINCT departamento) AS departamentos_unicos
FROM funcionarios;

3. SUM: Somando Valores Numéricos

A função SUM calcula a soma total de valores numéricos em uma coluna. Funciona com tipos inteiros (INT), decimais (DECIMAL, FLOAT, NUMERIC) e tipos similares. Valores NULL são simplesmente ignorados no cálculo – a soma considera apenas os valores não nulos.

Exemplos práticos:

-- Total de vendas realizadas
SELECT SUM(valor_venda) AS total_vendas
FROM vendas;

-- Soma de salários apenas do departamento de TI
SELECT SUM(salario) AS folha_ti
FROM funcionarios
WHERE departamento = 'TI';

-- Soma de horas extras, considerando que alguns funcionários não têm horas extras (NULL)
SELECT SUM(horas_extras) AS total_horas_extras
FROM funcionarios;

4. AVG: Calculando Médias

A função AVG retorna a média aritmética dos valores de uma coluna. É importante entender que AVG(coluna) é semanticamente diferente de SUM(coluna)/COUNT(*). Enquanto AVG(coluna) divide pela contagem de valores não nulos, SUM(coluna)/COUNT(*) divide pelo total de linhas (incluindo nulos), o que resultaria em um valor incorreto.

Valores NULL são ignorados pela AVG, assim como em SUM. Para obter médias com casas decimais controladas, combina-se AVG com ROUND.

Exemplos práticos:

-- Média de notas dos alunos
SELECT AVG(nota) AS media_geral
FROM alunos;

-- Média de preços dos produtos, arredondada para 2 casas decimais
SELECT ROUND(AVG(preco), 2) AS preco_medio
FROM produtos;

-- Comparação correta vs incorreta:
-- Correto: AVG calcula sobre valores não nulos
SELECT AVG(salario) AS media_salarial FROM funcionarios;
-- Incorreto: SUM/COUNT(*) incluiria nulos como zero no denominador
SELECT SUM(salario)/COUNT(*) AS media_incorreta FROM funcionarios;

5. MIN e MAX: Encontrando Extremos

As funções MIN e MAX retornam, respectivamente, o menor e o maior valor de uma coluna. Funcionam com dados numéricos, datas e strings. Para strings, a ordenação segue a collation do banco (geralmente ordem alfabética). Valores NULL são ignorados – se todos os valores forem nulos, o resultado será NULL.

Exemplos práticos:

-- Menor e maior salário da empresa
SELECT MIN(salario) AS menor_salario, MAX(salario) AS maior_salario
FROM funcionarios;

-- Data mais antiga e mais recente de contratação
SELECT MIN(data_contratacao) AS primeira_contratacao,
       MAX(data_contratacao) AS ultima_contratacao
FROM funcionarios;

-- Primeiro e último nome em ordem alfabética
SELECT MIN(nome) AS primeiro_nome, MAX(nome) AS ultimo_nome
FROM funcionarios;

6. Uso Combinado com GROUP BY

O verdadeiro poder das funções de agregação é revelado quando combinadas com GROUP BY. Essa cláusula particiona os dados em grupos com base em uma ou mais colunas, permitindo que as agregações sejam calculadas separadamente para cada grupo.

Exemplo completo:

-- Total de vendas, média, valor mínimo e máximo por departamento
SELECT 
    departamento,
    COUNT(*) AS total_vendas,
    SUM(valor) AS receita_total,
    ROUND(AVG(valor), 2) AS ticket_medio,
    MIN(valor) AS menor_venda,
    MAX(valor) AS maior_venda
FROM vendas
GROUP BY departamento
ORDER BY receita_total DESC;

É possível usar múltiplas funções de agregação em um mesmo SELECT, como demonstrado acima, desde que todas as colunas não agregadas estejam na cláusula GROUP BY.

7. Cuidados e Boas Práticas

Performance: Funções de agregação em tabelas com milhões de registros podem ser lentas. Índices apropriados nas colunas usadas em WHERE e GROUP BY ajudam significativamente. Para análises muito grandes, considere tabelas resumo ou materialized views.

Erros comuns: O erro mais frequente é esquecer o GROUP BY ao misturar colunas agregadas e não agregadas no SELECT. Isso gera erro na maioria dos bancos relacionais (exceto MySQL com configurações permissivas). Exemplo incorreto:

-- ERRADO: departamento não está no GROUP BY nem é agregado
SELECT departamento, AVG(salario)
FROM funcionarios;

Outro erro comum é usar COUNT(coluna) esperando contar linhas, quando na verdade a intenção era contar registros independentemente de nulos – nesse caso, use COUNT(*).

Armadilhas com DISTINCT e NULL: COUNT(DISTINCT coluna) ignora nulos, mas COUNT(DISTINCT *) não é válido. Além disso, MIN e MAX ignoram nulos, mas cuidado com strings vazias ('') que são consideradas válidas e podem aparecer como mínimo.

8. Conclusão e Próximos Passos

As cinco funções de agregação fundamentais – COUNT, SUM, AVG, MIN e MAX – formam a espinha dorsal da análise de dados em SQL. Dominá-las permite responder perguntas de negócio como "quantos?", "quanto?", "qual a média?", "qual o menor/maior?" de forma direta e eficiente.

Para avançar, estude a cláusula HAVING, que filtra grupos após a agregação (diferente de WHERE, que filtra antes). Explore também JOINs para agregar dados de múltiplas tabelas, como calcular totais por cliente usando dados de pedidos e clientes. Pratique com datasets públicos como os disponíveis no Kaggle ou nos exemplos da documentação oficial.

Lembre-se: a melhor forma de aprender SQL é praticando com problemas reais. Comece com consultas simples e gradualmente adicione complexidade com agrupamentos, filtros e múltiplas funções de agregação combinadas.

Referências