Funções de Agregação

Intermediário • 70 minutos • Análise de dados

Aprenda a usar funções de agregação para calcular estatísticas, somas, médias e agrupar dados para análises poderosas.

Objetivos de Aprendizagem

Dominar as principais funções de agregação (COUNT, SUM, AVG, MIN, MAX)
Usar GROUP BY para agrupar dados
Aplicar HAVING para filtrar grupos
Combinar agregações com JOINs
Criar relatórios e análises de dados

O que são Funções de Agregação?

Funções de agregação processam múltiplas linhas de dados e retornam um único valor. São essenciais para análises, relatórios e estatísticas.

🎯 Para que servem?

• Contar: Quantos registros existem?
• Somar: Qual o total de vendas?
• Calcular médias: Qual o preço médio dos produtos?
• Encontrar extremos: Qual o maior/menor valor?
• Agrupar dados: Vendas por categoria, por mês, etc.

Principais Funções

COUNT()

Conta registros

SUM()

Soma valores

AVG()

Calcula média

MIN()

Menor valor

MAX()

Maior valor

GROUP BY

Agrupa dados

COUNT() - Contando Registros

A função COUNT() conta o número de registros que atendem a uma condição.

Variações do COUNT

COUNT(*) - Conta todas as linhas

-- Quantos produtos existem?
SELECT COUNT(*) as total_produtos
FROM produtos;

Conta todas as linhas, incluindo valores NULL

COUNT(coluna) - Conta valores não-nulos

-- Quantos produtos têm descrição?
SELECT COUNT(descricao) as produtos_com_descricao
FROM produtos;

Ignora valores NULL na coluna especificada

COUNT(DISTINCT) - Conta valores únicos

-- Quantas categorias diferentes existem?
SELECT COUNT(DISTINCT categoria_id) as total_categorias
FROM produtos;

Conta apenas valores únicos (sem repetições)

Dica:

Use COUNT(*) para contar linhas totais e COUNT(coluna) para verificar completude dos dados.

SUM() e AVG() - Soma e Média

SUM() - Soma valores

-- Total de vendas
SELECT SUM(valor_total) as vendas_totais
FROM vendas;

-- Estoque total por categoria
SELECT categoria_id, SUM(estoque) as estoque_total
FROM produtos
GROUP BY categoria_id;

Uso: Totais financeiros, quantidades, estoques

AVG() - Calcula média

-- Preço médio dos produtos
SELECT AVG(preco) as preco_medio
FROM produtos;

-- Ticket médio por categoria
SELECT categoria_id, AVG(preco) as ticket_medio
FROM produtos
GROUP BY categoria_id;

Uso: Médias de preços, notas, idades, tempos

Exemplo Prático: Análise de Vendas

-- Relatório completo de vendas
SELECT 
    COUNT(*) as total_vendas,
    SUM(valor_total) as faturamento_total,
    AVG(valor_total) as ticket_medio,
    SUM(quantidade) as itens_vendidos
FROM vendas
WHERE data_venda >= '2024-01-01';

Atenção:

SUM() e AVG() ignoram valores NULL. Se uma coluna tem muitos NULLs, o resultado pode não representar a realidade.

MIN() e MAX() - Valores Extremos

MIN() e MAX() encontram os menores e maiores valores em uma coluna.

MIN() - Menor valor

-- Produto mais barato
SELECT MIN(preco) as menor_preco
FROM produtos;

-- Data da primeira venda
SELECT MIN(data_venda) as primeira_venda
FROM vendas;

MAX() - Maior valor

-- Produto mais caro
SELECT MAX(preco) as maior_preco
FROM produtos;

-- Última venda registrada
SELECT MAX(data_venda) as ultima_venda
FROM vendas;

Encontrando Registros Completos

Para encontrar o registro completo (não apenas o valor), use subconsultas:

-- Produto mais caro (registro completo)
SELECT *
FROM produtos
WHERE preco = (SELECT MAX(preco) FROM produtos);

-- Venda com maior valor
SELECT *
FROM vendas
WHERE valor_total = (SELECT MAX(valor_total) FROM vendas);

Análise de Amplitude

-- Amplitude de preços por categoria
SELECT 
    categoria_id,
    MIN(preco) as preco_minimo,
    MAX(preco) as preco_maximo,
    MAX(preco) - MIN(preco) as amplitude
FROM produtos
GROUP BY categoria_id;

GROUP BY - Agrupando Dados

GROUP BY agrupa registros com valores iguais em uma ou mais colunas, permitindo aplicar funções de agregação a cada grupo.

Sintaxe Básica

SELECT coluna_agrupamento, FUNCAO_AGREGACAO(coluna)
FROM tabela
GROUP BY coluna_agrupamento;

Exemplos Práticos

1. Vendas por categoria

SELECT 
    categoria_id,
    COUNT(*) as total_produtos,
    AVG(preco) as preco_medio
FROM produtos
GROUP BY categoria_id;

Agrupa produtos por categoria e calcula estatísticas

2. Vendas por mês

SELECT 
    EXTRACT(YEAR FROM data_venda) as ano,
    EXTRACT(MONTH FROM data_venda) as mes,
    COUNT(*) as total_vendas,
    SUM(valor_total) as faturamento
FROM vendas
GROUP BY EXTRACT(YEAR FROM data_venda), EXTRACT(MONTH FROM data_venda)
ORDER BY ano, mes;

Agrupa vendas por ano e mês

3. Múltiplas colunas de agrupamento

SELECT 
    categoria_id,
    fornecedor_id,
    COUNT(*) as total_produtos,
    AVG(preco) as preco_medio
FROM produtos
GROUP BY categoria_id, fornecedor_id;

Agrupa por categoria E fornecedor

Regra Importante:

Toda coluna no SELECT que não é uma função de agregação DEVE estar no GROUP BY.

HAVING - Filtrando Grupos

HAVING é como WHERE, mas para grupos. Permite filtrar resultados após o agrupamento.

WHERE vs HAVING

WHERE

• Filtra registros ANTES do agrupamento
• Não pode usar funções de agregação
• Mais eficiente

HAVING

• Filtra grupos APÓS o agrupamento
• Pode usar funções de agregação
• Usado com GROUP BY

Exemplos Práticos

1. Categorias com mais de 5 produtos

SELECT 
    categoria_id,
    COUNT(*) as total_produtos
FROM produtos
GROUP BY categoria_id
HAVING COUNT(*) > 5;

Mostra apenas categorias com mais de 5 produtos

2. Clientes com compras acima de R$ 1000

SELECT 
    cliente_id,
    COUNT(*) as total_compras,
    SUM(valor_total) as total_gasto
FROM vendas
GROUP BY cliente_id
HAVING SUM(valor_total) > 1000;

Identifica clientes VIP

3. Combinando WHERE e HAVING

SELECT 
    categoria_id,
    AVG(preco) as preco_medio
FROM produtos
WHERE estoque > 0  -- Filtra antes do agrupamento
GROUP BY categoria_id
HAVING AVG(preco) > 100;  -- Filtra depois do agrupamento

Produtos em estoque, agrupados por categoria, com preço médio > R$ 100

Ordem de Execução

1 FROM: Seleciona a tabela
2 WHERE: Filtra registros individuais
3 GROUP BY: Agrupa os dados
4 HAVING: Filtra grupos
5 SELECT: Seleciona colunas
6 ORDER BY: Ordena resultados

Exemplos Avançados

1. Relatório de Vendas Completo

SELECT 
    c.nome as categoria,
    COUNT(v.id) as total_vendas,
    SUM(v.valor_total) as faturamento,
    AVG(v.valor_total) as ticket_medio,
    MIN(v.valor_total) as menor_venda,
    MAX(v.valor_total) as maior_venda
FROM vendas v
JOIN produtos p ON v.produto_id = p.id
JOIN categorias c ON p.categoria_id = c.id
WHERE v.data_venda >= '2024-01-01'
GROUP BY c.id, c.nome
HAVING COUNT(v.id) >= 10
ORDER BY faturamento DESC;

2. Análise de Performance por Fornecedor

SELECT 
    f.nome as fornecedor,
    COUNT(p.id) as produtos_cadastrados,
    AVG(p.preco) as preco_medio,
    SUM(p.estoque) as estoque_total,
    COUNT(CASE WHEN p.estoque = 0 THEN 1 END) as produtos_sem_estoque,
    ROUND(
        COUNT(CASE WHEN p.estoque = 0 THEN 1 END) * 100.0 / COUNT(p.id), 
        2
    ) as percentual_sem_estoque
FROM fornecedores f
LEFT JOIN produtos p ON f.id = p.fornecedor_id
GROUP BY f.id, f.nome
HAVING COUNT(p.id) > 0
ORDER BY percentual_sem_estoque ASC;

3. Top 5 Clientes por Período

SELECT 
    cliente_id,
    COUNT(*) as total_compras,
    SUM(valor_total) as total_gasto,
    AVG(valor_total) as ticket_medio,
    MAX(data_venda) as ultima_compra
FROM vendas
WHERE data_venda BETWEEN '2024-01-01' AND '2024-12-31'
GROUP BY cliente_id
HAVING COUNT(*) >= 3
ORDER BY total_gasto DESC
LIMIT 5;

Exercício Prático

Vamos praticar funções de agregação!

Complete as consultas SQL abaixo:

1. Complete a consulta para contar produtos por categoria:

SELECT categoria_id, ______(*)  as total
FROM produtos
______ __ categoria_id;

Função de agregação:

Cláusula de agrupamento:

2. Qual função calcula a média de preços?

SUM(preco) AVG(preco) COUNT(preco)

3. Complete para mostrar apenas categorias com mais de 3 produtos:

SELECT categoria_id, COUNT(*) as total
FROM produtos
GROUP BY categoria_id
______ COUNT(*) _ 3;

Cláusula:

Operador:

4. Qual a diferença entre WHERE e HAVING?

Não há diferença WHERE filtra antes do GROUP BY, HAVING filtra depois HAVING é mais rápido que WHERE

Resumo da Aula

COUNT(), SUM(), AVG(), MIN(), MAX() são as principais funções de agregação
GROUP BY agrupa dados para aplicar funções de agregação
HAVING filtra grupos após o agrupamento
WHERE filtra registros antes do agrupamento
Funções de agregação são essenciais para relatórios e análises

Aula Anterior: Atualizando e Excluindo Dados Próxima Aula: Subconsultas