Agregação e agrupamento em SQL

Uma função de agregação combina valores de várias linhas em um resultado. A Oracle também a chama de função de grupo. Sem GROUP BY, uma consulta de agregação trata todas as linhas que passam por WHERE como um único grupo e retorna uma linha de resumo.

Comece com dados que você pode conferir

Cada linha em orders é um pedido. As colunas numéricas abaixo contêm números inteiros; order_id é a chave primária. As datas usam texto ISO no SQLite e o tipo DATE no PostgreSQL.

Escolha a medida

SUM(amount) soma os valores. AVG(amount) fornece a média aritmética deles. MIN(amount) encontra o menor valor e MAX(amount) encontra o maior. Você pode solicitar as quatro funções em uma consulta:

SELECT SUM(amount) AS total, AVG(amount) AS avg_amount, MIN(amount) AS smallest, MAX(amount) AS largest FROM orders;

O resultado é uma linha: total 780, média 97,5, menor valor 30 e maior valor 200. Some os oito valores para obter 780 e depois divida por oito para obter 97,5. Cada função usa as mesmas oito linhas de entrada. Apelidos claros após AS tornam úteis os cabeçalhos do resultado; um cabeçalho gerado como sum diz pouco sobre o que foi somado.

Filtre antes de calcular

Para resumir os pedidos de East, escreva SELECT COUNT(*) AS orders, SUM(amount) AS total FROM orders WHERE region = 'East';. O filtro mantém os valores 120, 45 e 95. A consulta retorna três pedidos e um total de 260. WHERE escolhe as linhas de entrada antes da execução de qualquer função de agregação.

Uma função de agregação também pode receber uma expressão calculada. Em uma tabela com quantity e unit_price, SUM(quantity * unit_price) primeiro calcula a receita de cada linha e depois as soma. Duas linhas, dois itens a 5 e três itens a 10, contribuem com 10 e 30, para um total de 40. SUM(quantity) * SUM(unit_price) multiplica 5 por 15 e resulta em 75. Manter o cálculo dentro de SUM preserva o preço correspondente a cada quantidade.

Interprete corretamente os valores extremos

MIN(order_date) é 2026-01-05 e MAX(order_date) é 2026-03-21. Valores de data e textos de data ISO são ordenados cronologicamente. Textos como “03/21/2026” seguem a ordem dos caracteres, que não corresponde de forma confiável à ordem das datas. Os valores extremos de texto também seguem a colação do banco de dados, suas regras para comparar textos. Aqui, os clientes extremos são “Ana” e “Eli”; a mistura de maiúsculas e minúsculas pode alterar a ordenação do texto.

MAX(amount) retorna um valor, não o pedido inteiro que o contém. Para mostrar um cliente com um pedido de maior valor, use SELECT customer, amount FROM orders ORDER BY amount DESC LIMIT 1;. O PostgreSQL rejeita uma coluna customer simples ao lado de MAX(amount) sem um agrupamento adequado. O SQLite tem uma regra especial para um único MIN ou MAX que pode retornar uma coluna adjacente da linha com o valor extremo, mas valores extremos empatados ainda precisam de uma regra de desempate.

“Quantos?” pode ser uma pergunta sobre linhas, valores registrados ou valores diferentes. São contagens diferentes, mesmo quando por acaso resultam no mesmo número em uma tabela pequena.

Três formas de COUNT

Na tabela de pedidos, as regiões são East, West, East, North, West, East, North e NULL. SELECT COUNT(*) AS order_rows, COUNT(region) AS with_region, COUNT(DISTINCT region) AS regions FROM orders; retorna 8, 7 e 3. Os nomes de região repetidos são contados separadamente em COUNT(region), mas cada nome contribui apenas uma vez para a contagem de valores distintos.

Para “Quantos clientes diferentes fizeram pedidos?”, use COUNT(DISTINCT customer). Ana, Ben e Chen aparecem duas vezes cada, enquanto Dara e Eli aparecem uma vez, então a resposta é cinco clientes. COUNT(customer) retorna oito porque cada pedido identifica um cliente. Essa função conta linhas de pedido com cliente identificado, não pessoas.

Um zero registrado também é contado

Os descontos são 10, NULL, 5, NULL, 0, NULL, 15 e NULL. COUNT(discount) retorna quatro. O zero registra um valor conhecido e é contado assim como 10, 5 e 15. Uma cadeia de caracteres vazia também é um valor no SQLite e no PostgreSQL; o Oracle trata uma cadeia vazia como NULL.

Subtraia a contagem de valores não NULL da contagem de linhas para medir os registros ausentes: SELECT COUNT(*) - COUNT(region) AS missing_region FROM orders; retorna um. Isso funciona porque ambas as contagens usam exatamente as mesmas linhas de entrada.

Listas DISTINCT e contagens de valores distintos

SELECT DISTINCT region FROM orders; lista East, West, North e uma linha NULL. Sua função é retornar valores diferentes, e NULL permanece nessa lista. COUNT(DISTINCT region) retorna três porque a contagem ignora NULL. Não deduza uma contagem de valores distintos contando uma lista sem antes decidir se a linha NULL deve entrar na contagem.

DISTINCT também pode aparecer dentro de SUM ou AVG. As quantidades são 2, 1, 3, 4, 1, 2, 5 e 1. Sua soma comum é 19. SUM(DISTINCT quantity) mantém apenas 1, 2, 3, 4 e 5, resultando em 15. Quantidades repetidas geralmente representam vendas adicionais reais. Removê-las altera a medida; isso não corrige registros duplicados.

Conte combinações em duas etapas

Para pares diferentes de região e cliente, primeiro faça uma lista distinta:

SELECT COUNT(*) FROM (SELECT DISTINCT region, customer FROM orders) AS pairs;

A consulta interna retorna cinco pares: East/Ana, East/Dara, North/Chen, West/Ben e NULL/Eli. O COUNT(*) externo conta essas cinco linhas, incluindo NULL/Eli. Essa forma funciona no SQLite e no PostgreSQL. O MySQL também aceita COUNT(DISTINCT region, customer), mas essa forma exclui combinações que contêm NULL, então pode responder a uma pergunta diferente. No SQLite e no PostgreSQL, a forma com valores separados por vírgula é inválida.

Por fim, uma contagem nunca retorna NULL. SELECT COUNT(*) FROM orders WHERE region = 'South'; retorna uma linha de resumo contendo zero, pois não há pedidos correspondentes.

NULL significa que um valor está ausente ou é desconhecido. Isso altera os valores recebidos por uma função de agregação, então um total ou uma média pode ser SQL válido e ainda assim medir algo diferente do que você pretendia.

Determine o denominador

Suponha que scores contenha Ana 80, Ben NULL, Chen 70 e Dara 90. SUM(score) é 240, COUNT(score) é três e COUNT(*) é quatro. AVG(score) é 80: as três notas registradas somam 240 e são divididas por três.

As cinco funções de agregação padrão ignoram argumentos NULL. COUNT(*) conta todas as linhas porque não avalia um argumento de coluna. MIN(score) é 70 e MAX(score) é 90; NULL não se torna a menor nem a maior nota. Isso difere da ordenação, em que valores NULL ocupam uma extremidade do resultado: primeiro em uma ordenação crescente no SQLite, por último em uma ordenação crescente no PostgreSQL.

Uma média calculada manualmente precisa da contagem de valores não NULL: 1.0 * SUM(score) / NULLIF(COUNT(score), 0). O operando decimal preserva resultados fracionários, e NULLIF transforma um divisor zero em NULL. Dividir por COUNT(*) resultaria em 60 e trataria, na prática, a nota ausente como zero.

Decida o que um valor padrão significa

COALESCE retorna seu primeiro argumento não NULL. Se Ben ainda não foi avaliado, mantenha a nota ausente e calcule a média dos resultados conhecidos. Se uma prova perdida é registrada como NULL, mas deve contar como zero, AVG(COALESCE(score, 0)) calcula a média de 80, 0, 70 e 90, resultando em 60. O significado dos dados determina se essa substituição se justifica.

Compare o uso de COALESCE dentro e fora de uma função. AVG(COALESCE(score, 0)) altera os valores que entram na média. COALESCE(AVG(score), 0) altera apenas um resultado final NULL; ainda retorna 80 para essas notas. NVL(x, 0) do Oracle é outra forma com dois argumentos para substituir NULL.

Distinga ausência de linhas de ausência de valores registrados

Com WHERE region = 'South', não restam pedidos. Uma consulta de agregação sem GROUP BY ainda retorna uma linha: COUNT(*) é zero, enquanto SUM(amount), AVG(amount), MIN(amount) e MAX(amount) são NULL. Para exibir um total vazio como zero, use COALESCE(SUM(amount), 0). O SQLite também oferece TOTAL(amount), que retorna 0,0 para um conjunto de entrada vazio.

Agora mantenha os quatro pedidos cujo desconto é NULL. Há linhas, mas não há valores de desconto registrados: COUNT(*) é quatro, COUNT(discount) é zero e SUM(discount) é NULL. Zero valores registrados e quatro valores ausentes são observações diferentes.

Verifique as expressões antes de entrarem em SUM

Operações aritméticas com NULL produzem NULL. Em SUM(amount - discount), os quatro pedidos sem desconto registrado não contribuem com nenhum valor. Apenas as linhas com desconto conhecido contribuem: 110, 40, 60 e 135, totalizando 345.

Se um desconto ausente significa que não há desconto, escreva SUM(amount - COALESCE(discount, 0)). Todos os pedidos passam a contribuir; o valor total de 780 menos os descontos registrados de 30 resulta em 750. Envolver a soma inteira em COALESCE não recuperaria os pedidos omitidos, pois 345 já é um valor não NULL.

Para localizar valores ausentes, use IS NULL ou IS NOT NULL. WHERE discount IS NULL encontra quatro pedidos. discount = NULL nunca é verdadeira e, portanto, não pode selecioná-los.

GROUP BY reúne linhas que compartilham um valor de agrupamento. Cada função de agregação é executada separadamente dentro de cada grupo, e o resultado contém uma linha para cada grupo existente após a filtragem.

Decida o que uma linha do resultado significa

“Total de vendas por região” pede uma linha de resultado por região. Comece escrevendo essa frase e depois use region como coluna de agrupamento:

SELECT region, COUNT(*) AS orders, SUM(amount) AS total FROM orders GROUP BY region;

Os três valores de East, 120, 45 e 95, tornam-se um grupo. Sua contagem é três e seu total é 260. North tem dois pedidos que totalizam 350; West tem dois que totalizam 140. O pedido de Eli forma um grupo de região NULL com um pedido que totaliza 30. Há quatro linhas no resultado, não oito.

Leia a consulta como uma sequência: FROM fornece os pedidos, uma eventual cláusula WHERE remove linhas, GROUP BY reúne as linhas restantes por região e as funções de agregação resumem cada conjunto. SELECT exibe seu rótulo e suas medidas. O agrupamento não descarta os pedidos menores dentro de um grupo; todos contribuem, a menos que um filtro de linha os tenha removido.

Mantenha visíveis as categorias ausentes

Linhas com NULL na coluna de agrupamento pertencem a um único grupo NULL. Isso é útil: um relatório pode mostrar quanta atividade não tem região registrada. Ele não trata cada região ausente como uma categoria diferente.

Para mostrar um rótulo legível, selecione COALESCE(region, 'No region') AS region_label e mantenha GROUP BY region. O rótulo altera o valor exibido. Para excluir essas linhas dos cálculos, adicione WHERE region IS NOT NULL antes de GROUP BY. Os totais resultantes somam 750, pois o valor de 30 de Eli ficou de fora.

Uma consulta agrupada sobre um conjunto de entrada sem linhas não retorna grupos. Por exemplo, filtrar a tabela para South e depois agrupar por região não retorna nenhuma linha de resultado. Isso difere de uma agregação da tabela inteira sem GROUP BY, que produz uma linha de resumo mesmo com um conjunto de entrada vazio.

Ordene os grupos explicitamente

GROUP BY não garante a ordem do resultado. Para listar primeiro as regiões com maiores totais, adicione ORDER BY total DESC. O apelido total é permitido em ORDER BY; ORDER BY SUM(amount) DESC produz a mesma ordenação.

Um relatório de clientes pode selecionar os três maiores totais:

SELECT customer, SUM(amount) AS total FROM orders GROUP BY customer ORDER BY total DESC, customer LIMIT 3;

Ele retorna Chen 350, Ana 165 e Ben 140. A segunda chave de ordenação, customer, dá aos totais empatados uma ordem repetível. LIMIT 3 retorna apenas três linhas; não mantém todos os empates no limite. O SQL Server expressa esse limite com SELECT TOP 3, enquanto o Oracle oferece FETCH FIRST 3 ROWS ONLY.

Ao ordenar rótulos de categoria em ordem crescente, o SQLite normalmente coloca NULL primeiro e o PostgreSQL o coloca por último. Especifique a ordenação desejada quando a posição importar.

Verifique a coluna de agrupamento

SELECT DISTINCT region FROM orders e SELECT region FROM orders GROUP BY region retornam os mesmos rótulos distintos de região, incluindo NULL. Use agrupamento quando também precisar de uma medida para cada rótulo.

Agrupar pela chave única order_id resulta em oito grupos de uma linha cada. Toda contagem é um, e cada total de valor é igual ao valor original. Para um relatório regional, esse resultado indica que a coluna de agrupamento é detalhada demais.

Um relatório agrupado precisa reunir muitas linhas de entrada em uma linha de resultado. Portanto, cada valor exibido precisa ter um significado claro para o grupo inteiro. Por isso, a SQL restringe as colunas que você pode selecionar.

Siga a regra de agrupamento portável

Um item de um SELECT agrupado deve ser uma coluna de agrupamento, uma expressão construída a partir de colunas de agrupamento, uma função de agregação ou uma constante. Considere:

SELECT region, customer, COUNT(*) FROM orders GROUP BY region;

East contém Ana, Ana e Dara. O grupo tem uma região e uma contagem, mas dois nomes de clientes diferentes. A consulta não informa qual cliente deve ser exibido no único resultado de East. O PostgreSQL rejeita a coluna customer não agrupada.

O mesmo problema surge sem GROUP BY: SELECT customer, SUM(amount) FROM orders combina um total da tabela inteira com um nome individual. O total não tem um único cliente que o identifique.

Corrija a consulta de acordo com a pergunta

Há três correções úteis, cada uma com um significado diferente:

• Para uma linha por região, remova customer: SELECT region, COUNT(*) FROM orders GROUP BY region;.
• Para uma linha por região e cliente, agrupe por ambos: SELECT region, customer, COUNT(*) FROM orders GROUP BY region, customer;.
• Para a quantidade de clientes por região, agregue os nomes: SELECT region, COUNT(DISTINCT customer) AS customers FROM orders GROUP BY region;.

A última consulta apresenta dois clientes em East e um em cada um dos outros grupos de região. Simplesmente adicionar uma coluna a GROUP BY pode alterar o nível de detalhe do relatório, então escolha a correção com base na pergunta, não apenas na mensagem de erro.

Uma coluna de agrupamento pode ser omitida de SELECT. SELECT COUNT(*) FROM orders GROUP BY region; é válida e retorna quatro contagens: três, dois, dois e um, sem ordem garantida. É difícil usar esses números sem os rótulos de região.

Aplique a regra além de SELECT

Um ORDER BY customer em uma consulta agrupada apresenta o mesmo problema quando o agrupamento é feito apenas por região: qual cliente deve determinar a posição de East? Condições HAVING em consultas agrupadas também devem descrever um grupo inteiro. Use nelas colunas agrupadas ou expressões de agregação.

Reconheça o comportamento permissivo de bancos de dados

O SQLite aceita uma coluna não agrupada nem agregada, uma coluna selecionada que não está agrupada nem agregada. Ele obtém um valor de uma linha de entrada do grupo. Um resultado aparentemente válido como “Ana” ao lado de East não significa que Ana represente todos os pedidos dessa região.

Com exatamente uma função de agregação MIN ou MAX incorporada, o SQLite obtém os valores não agrupados nem agregados de uma linha que contém o valor extremo. Empates e várias funções de agregação de extremos tornam incerta a linha selecionada. Esse atalho é específico do banco de dados. Ordenar as linhas originais é mais claro quando você quer um pedido com valor extremo.

O modo padrão ONLY_FULL_GROUP_BY do MySQL rejeita valores não agrupados que não são determinados pelo grupo. ANY_VALUE(customer) permite explicitamente um valor arbitrário, mas não encontra o cliente associado a um total escolhido. SQL Server e Oracle também rejeitam colunas comuns não agrupadas.

PostgreSQL e MySQL reconhecem uma exceção para a chave primária: agrupar pela chave primária de uma tabela identifica uma única linha, então suas outras colunas são determinadas. SELECT order_id, customer, SUM(amount) FROM orders GROUP BY order_id funciona no PostgreSQL. Listar em GROUP BY todas as colunas simples exibidas continua sendo a abordagem portável.

Alguns relatórios precisam de uma combinação de categorias ou de uma categoria calculada a partir de cada linha. A SQL pode agrupar por várias colunas ou por uma expressão. A escolha importante continua sendo o que uma linha do resultado representa.

Agrupe por uma combinação

GROUP BY region, customer reúne linhas apenas quando ambos os valores correspondem. Na tabela de pedidos, execute:

SELECT region, customer, COUNT(*) AS orders, SUM(amount) AS total FROM orders GROUP BY region, customer ORDER BY region, customer;

Os resultados são East/Ana: dois pedidos, 165; East/Dara: um, 95; North/Chen: dois, 350; West/Ben: dois, 140; e NULL/Eli: um, 30. Os dois resultados de East somam o total regional de 260.

Agrupar por customer, region forma as mesmas combinações. A ordem das colunas em GROUP BY não ordena o resultado. O ORDER BY separado acima escolhe como exibi-lo, sujeito à posição padrão de NULL em cada banco de dados.

Apenas as combinações presentes na entrada aparecem. Não há uma linha West/Ana com contagem zero. O agrupamento resume linhas existentes; não gera todos os pares possíveis de rótulos de categoria.

Adicione detalhes apenas quando necessário

Adicionar uma coluna divide um grupo apenas se suas linhas contiverem valores diferentes nessa coluna. Agrupar apenas por cliente já resulta em cinco grupos neste exemplo. Adicionar a região ainda resulta em cinco, pois cada cliente tem apenas um valor de região. Adicionar order_date a um relatório regional cria grupos menores para as diferentes datas e altera a pergunta respondida.

Agrupe datas por ano e mês

No SQLite, use strftime('%Y-%m', order_date) para criar um rótulo como “2026-02”:

SELECT strftime('%Y-%m', order_date) AS month, COUNT(*) AS orders, SUM(amount) AS total FROM orders GROUP BY strftime('%Y-%m', order_date) ORDER BY month;

Janeiro tem dois pedidos que totalizam 200, fevereiro tem três que totalizam 305 e março tem três que totalizam 275. No PostgreSQL, substitua as duas ocorrências de strftime('%Y-%m', order_date) por to_char(order_date, 'YYYY-MM') para uma coluna DATE.

Agrupar apenas pelo número do mês combina o mesmo mês de anos diferentes. Janeiro de 2025 e janeiro de 2026 se tornariam um grupo. Manter o ano na expressão de agrupamento preserva os meses de calendário separados.

Repetir a expressão em GROUP BY torna o agrupamento explícito. SQLite, PostgreSQL e MySQL também aceitam o apelido do resultado, como em GROUP BY month; o SQL Server não aceita um apelido de SELECT do mesmo nível nesse ponto.

Crie categorias com CASE

Uma expressão CASE pode atribuir um rótulo a cada pedido antes do agrupamento:

SELECT CASE WHEN amount >= 100 THEN 'large' ELSE 'small' END AS size, COUNT(*) AS orders, SUM(amount) AS total FROM orders GROUP BY CASE WHEN amount >= 100 THEN 'large' ELSE 'small' END;

A categoria large contém 120, 200 e 150: três pedidos que totalizam 470. A categoria small contém cinco pedidos que totalizam 310. O limite é inclusivo, então um valor exatamente igual a 100 pertence a “large”. A mesma expressão CASE aparece na exibição e no agrupamento para que ambos usem a mesma definição de categoria.

HAVING testa grupos depois que suas agregações foram calculadas. Use-o para uma solicitação como “regiões com vendas totais acima de 200”. A condição descreve cada total regional, não um pedido individual.

Calcule primeiro, mantenha os grupos depois

SELECT region, COUNT(*) AS orders, SUM(amount) AS total FROM orders GROUP BY region HAVING SUM(amount) > 200;

Antes de HAVING, os totais regionais são East 260, North 350, West 140 e NULL 30. A condição mantém East com três pedidos e North com dois. Ela remove os outros dois grupos do resultado; não remove pedidos selecionados de dentro de East ou North.

Na SQL escrita, coloque HAVING depois de GROUP BY e antes de ORDER BY. A ordenação se aplica então aos grupos que passaram pela condição.

Filtre por medidas que você não exibe

SELECT region FROM orders GROUP BY region HAVING COUNT(*) >= 2; retorna East, North e West. O banco de dados pode contar as linhas de um grupo para decidir se ele atende à condição sem exibir essa contagem. HAVING e SELECT não precisam ter listas idênticas de funções de agregação.

Você pode combinar condições de grupo. HAVING COUNT(*) >= 2 AND AVG(amount) > 80 mantém East e North. East tem três pedidos e média de aproximadamente 86,67; North tem dois e média de 175. West tem pedidos suficientes, mas sua média é apenas 70. Ambos os testes devem ser atendidos porque estão ligados por AND; OR permitiria que apenas um deles fosse atendido.

Encontre valores repetidos

Agrupar e contar também encontra duplicatas:

SELECT customer, COUNT(*) AS orders FROM orders GROUP BY customer HAVING COUNT(*) > 1;

Ana, Ben e Chen têm dois pedidos cada e atendem à condição. Dara e Eli têm um e não atendem. Para encontrar valores de e-mail repetidos em uma tabela de clientes, o mesmo padrão agrupa por email e mantém contagens maiores que um. A contagem é o número de registros que compartilham esse valor.

Use a expressão de que a condição precisa

Repita a função de agregação em HAVING: HAVING SUM(amount) > 200. O PostgreSQL e a SQL padrão não permitem o apelido de resultado total nessa condição do mesmo nível, embora SQLite e MySQL permitam. Um apelido pode ser usado com segurança em um ORDER BY total DESC posterior.

Um valor arredondado exibido e o valor testado podem ser diferentes. A média exata de East é 260 dividido por três. Se você selecionar ROUND(AVG(amount), 2), mas escrever HAVING AVG(amount) > 86.67, East será removida: sua média sem arredondamento é inferior a 86,67. North permanece. A condição usa exatamente a expressão escrita em HAVING. Apenas HAVING ROUND(AVG(amount), 2) ... testaria o valor arredondado.

Filtre o único grupo geral

HAVING também pode funcionar sem um GROUP BY explícito. SELECT COUNT(*) FROM orders HAVING COUNT(*) > 5; trata todos os oito pedidos como um grupo, passa no teste e retorna uma linha contendo oito. Substituir a condição por COUNT(*) > 10 não retorna nenhuma linha, não uma linha contendo zero.

O PostgreSQL oferece suporte a esse padrão, assim como o SQLite a partir da versão 3.39.0. Em uma instalação mais antiga do SQLite, uma consulta que usa HAVING precisa de um GROUP BY explícito.

Uma condição pertence ao ponto em que aquilo que ela descreve existe. Pedidos individuais existem antes do agrupamento. Um total regional só existe depois que os pedidos foram agrupados e somados.

Acompanhe a ordem lógica

A SQL é escrita como SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT. Para raciocinar sobre o resultado, siga esta ordem lógica:

1. FROM fornece as linhas.
2. WHERE mantém as linhas que atendem à condição.
3. GROUP BY forma grupos, e as funções de agregação calculam suas medidas.
4. HAVING mantém os grupos que atendem à condição.
5. SELECT produz os valores de saída; DISTINCT remove linhas duplicadas do resultado, se solicitado.
6. ORDER BY ordena o resultado, e LIMIT mantém a quantidade solicitada de linhas.

O banco de dados pode organizar sua execução interna de outra forma.

Coloque cada condição em seu nível

WHERE SUM(amount) > 200 falha porque o total ainda não existe na etapa de filtragem de linhas. Uma condição de linha como region = 'East' pode ser avaliada antes do agrupamento e pertence a WHERE.

Acompanhe os dois filtros

SELECT region, COUNT(*) AS orders, SUM(amount) AS total FROM orders WHERE amount >= 60 GROUP BY region HAVING SUM(amount) > 200;

Primeiro, remova os pedidos de 45 e 30. East agora contém 120 e 95, North contém 200 e 150, e West contém 80 e 60. Em seguida, calcule os totais de 215, 350 e 140. Por fim, mantenha os totais acima de 200. O resultado é East com dois pedidos e 215, e North com dois e 350. A região NULL não tem linhas restantes, então nunca forma um grupo.

Não mude a pergunta ao mover um filtro

“Para cada região, calcule a média apenas dos pedidos de 60 ou mais” usa WHERE amount >= 60. A média de East passa a ser 107,5 a partir de 120 e 95.

HAVING MIN(amount) >= 60 pede regiões em que todo valor não NULL atende ao limite. East é removida porque seu mínimo é 45; North e West permanecem com seus pedidos originais. Mover o teste mudou o significado: de selecionar pedidos individuais para aceitar ou rejeitar regiões inteiras.

Para esse relatório regional, region <> 'West' produz o mesmo resultado em WHERE ou HAVING: East e North permanecem, e o grupo NULL também não passa na comparação. WHERE expressa a restrição de linha diretamente e a aplica antes do agrupamento. Para manter também as regiões ausentes, a condição precisa de um OR region IS NULL explícito.

Apelidos de SELECT não estão disponíveis nas cláusulas anteriores WHERE e HAVING no PostgreSQL. O SQLite permite mais usos de apelidos, mas escrever a coluna ou expressão de entrada por extenso deixa clara a etapa pretendida.

Dividir dois valores inteiros pode descartar a parte fracionária antes mesmo de você exibir a resposta. Isso importa quando você calcula uma média ou um percentual a partir de totais e contagens.

Tenha um operando decimal antes da divisão

No SQLite e no PostgreSQL, 7 / 2 retorna 3. Com valores inteiros de entrada, SUM(quantity) / COUNT(*) na tabela de pedidos retorna 2: 19 itens divididos por oito pedidos perdem a parte fracionária. No PostgreSQL, SUM de uma coluna INTEGER retorna BIGINT, que ainda usa divisão inteira nesse caso.

Escreva 1.0 * SUM(quantity) / COUNT(*) para obter 2,375 nos dois mecanismos. Multiplicar por 1,0 cria um operando decimal antes da divisão. SUM(quantity) / COUNT(*) * 1.0 resulta em 2,0 porque a divisão já descartou a parte fracionária. Operações de mesma precedência são avaliadas da esquerda para a direita.

Para essa tabela, AVG(quantity) fornece diretamente 2,375 no SQLite e no PostgreSQL. A fórmula manual é importante quando você precisa de outro denominador ou de um percentual.

Calcule um percentual

Três dos oito pedidos têm valores de pelo menos 100. A contagem desses pedidos dividida pela contagem de todos os pedidos mede sua proporção. Multiplique por 100,0:

SELECT 100.0 * COUNT(CASE WHEN amount >= 100 THEN 1 END) / COUNT(*) AS pct_large FROM orders;

O resultado é 37,5. Usar o inteiro 100 produz 37 no SQLite e na divisão de contagens inteiras no PostgreSQL. Arredondar depois apenas alteraria a exibição de 37.

Uma consulta sobre a tabela inteira pode não ter linhas correspondentes. NULLIF(COUNT(*), 0) retorna NULL quando a contagem é zero, então 100.0 * COUNT(discount) / NULLIF(COUNT(*), 0) retorna NULL para um conjunto de entrada vazio. Um denominador zero sem tratamento gera erro no PostgreSQL; o SQLite retorna NULL. Uma proporção NULL pode representar claramente “nenhum pedido a medir”.

Verifique o banco de dados e o tipo de entrada

No SQL Server, use AVG(quantity * 1.0) ou converta as entradas para DECIMAL antes de calcular a média. No PostgreSQL, SUM de uma coluna BIGINT retorna NUMERIC, então sua divisão não precisa se comportar como SUM de uma coluna INTEGER. O MySQL retorna DECIMAL para somas de entradas inteiras.

Uma conversão também pode criar o operando decimal necessário: use CAST(SUM(quantity) AS REAL) no SQLite ou CAST(SUM(quantity) AS NUMERIC) no PostgreSQL. A conversão para NUMERIC no SQLite pode manter um inteiro, então essa conversão, por si só, não garante divisão decimal.

Distinga decimais exatos de aproximações

Tipos de ponto flutuante armazenam aproximações binárias. NUMERIC e DECIMAL no PostgreSQL oferecem suporte a valores decimais exatos; somas em ponto flutuante podem exibir pequenas imprecisões, como 0,30000000000000004. A afinidade NUMERIC do SQLite não oferece armazenamento decimal exato. Para totais monetários exatos nesse sistema, armazene centavos como inteiros, some-os e divida por 100,0 para exibição.

O arredondamento determina quantos dígitos um resultado mostra. Mantenha o cálculo completo até a etapa final para que escolhas de exibição não alterem a medida calculada.

Arredonde o resultado de uma agregação

ROUND(x, n) arredonda para n casas após a vírgula decimal. ROUND(x) arredonda para um número inteiro. Por exemplo, ROUND(3.14159, 2) é 3,14.

SELECT region, ROUND(AVG(amount), 2) AS avg_amount FROM orders GROUP BY region; resulta em East 86,67, North 175, West 70 e região NULL 30. O SQLite pode mostrar 175,0, enquanto o resultado NUMERIC do PostgreSQL mostra 175,00. Eles representam o mesmo número. Arredondar um número e formatar um rótulo de texto com largura fixa são tarefas diferentes.

Arredonde depois de somar ou calcular a média

Para três tarifas de 0,44, some primeiro para obter 1,32 e depois arredonde para uma casa decimal para obter 1,3. ROUND(SUM(fee), 1) segue essa sequência. SUM(ROUND(fee, 1)) arredonda cada tarifa para 0,4 e depois as soma, resultando em 1,2. O arredondamento antecipado alterou o total.

Da mesma forma, ROUND(100 * 1 / 3, 1) resulta em 33,0 no SQLite e no PostgreSQL porque a divisão inteira já produziu 33. ROUND(100.0 * 1 / 3, 1) preserva a parte fracionária e resulta em 33,3. Escolha o tipo do cálculo antes de arredondar.

Partes arredondadas podem não somar 100%. Três partes iguais podem ser exibidas como 33,3% cada, totalizando 99,9%. As proporções originais ainda cobrem o todo. Recalcular uma parte arbitrária para forçar o total exibido altera o significado desse número.

Use um tipo de entrada compatível

O PostgreSQL oferece suporte a ROUND(value, n) com dois argumentos para NUMERIC. Se temp for DOUBLE PRECISION, escreva ROUND(CAST(AVG(temp) AS NUMERIC), 2). A média de 20,5, 21,25 e 19,0 é 20,25, e a conversão permite usar o arredondamento com dois argumentos. Com amount inteiro, a média do PostgreSQL já é NUMERIC, então nenhuma conversão é necessária.

Para valores NUMERIC exatos no PostgreSQL, os valores intermediários são arredondados para longe de zero: 2,5 torna-se 3 e -2,5 torna-se -3. O SQLite também retorna 3,0 e -3,0 nesses exemplos. O arredondamento de ponto flutuante no PostgreSQL depende da plataforma; o arredondamento para o par mais próximo é comum. Uma aproximação binária também pode colocar um decimal ligeiramente abaixo do ponto intermediário pretendido. Não use um caso específico de empate em ponto flutuante como regra geral para a aritmética decimal exata.

Observe outras duas diferenças entre dialetos

PostgreSQL, MySQL, SQL Server e Oracle usam uma quantidade negativa de casas decimais para arredondar à esquerda da vírgula. ROUND(1234.5, -2) resulta em 1200. O SQLite trata um segundo argumento negativo como zero e retorna 1235,0. Para arredondar para centenas no SQLite, use ROUND(x / 100.0) * 100.

A conversão para inteiro também depende do banco de dados: o SQLite descarta a parte fracionária, então 2,9 torna-se 2; o PostgreSQL arredonda para 3. Use ROUND quando a finalidade for arredondar. TRUNC(x, n) do PostgreSQL descarta dígitos: TRUNC(2.97, 1) é 2,9, enquanto arredondá-lo para uma casa decimal resulta em 3,0.

A agregação condicional permite que diferentes medidas usem diferentes contribuições, mantendo o mesmo conjunto geral de linhas. Uma expressão CASE determina com o que cada linha contribui para uma contagem ou soma.

Conte as linhas correspondentes

COUNT(CASE WHEN amount >= 100 THEN 1 END) conta pedidos de pelo menos 100. A expressão retorna 1 para uma correspondência e NULL para as outras linhas porque não tem ELSE. COUNT ignora esses valores NULL, restando três correspondências na tabela de pedidos.

SUM(CASE WHEN amount >= 100 THEN 1 ELSE 0 END) conta as correspondências somando uns e zeros. Quando há linhas de entrada, produz a mesma contagem. COUNT(CASE WHEN amount >= 100 THEN 1 ELSE 0 END) não produz: tanto 1 quanto 0 são valores não NULL, então conta todos os oito pedidos.

Some os valores correspondentes

Para um total condicional, retorne o próprio valor:

SELECT region, COUNT(*) AS orders, COUNT(CASE WHEN amount >= 100 THEN 1 END) AS large_orders, SUM(CASE WHEN amount >= 100 THEN amount ELSE 0 END) AS large_total FROM orders GROUP BY region;

East tem três pedidos, um pedido de valor alto e um total de 120 em pedidos de valor alto. North tem dois pedidos, ambos de valor alto, totalizando 350. West tem dois pedidos, nenhum de valor alto e um total de zero em pedidos de valor alto. O grupo de região NULL tem um pedido e zeros para as duas medidas de pedidos de valor alto.

O resultado mantém West porque suas linhas de entrada ainda existem. Adicionar WHERE amount >= 100 removeria as linhas de West antes do agrupamento, então West desapareceria. Esse filtro também faria COUNT(*) contar apenas pedidos de valor alto, perdendo a comparação com todos os pedidos.

Use o denominador correto

Dentro de cada região, calcule o percentual de pedidos de valor alto com ROUND(100.0 * COUNT(CASE WHEN amount >= 100 THEN 1 END) / COUNT(*), 1) AS pct_large. East resulta em 33,3, North em 100,0, West em 0,0 e o grupo NULL em 0,0. Cada denominador é a contagem de pedidos desse grupo, não a contagem de oito da tabela inteira.

Para um relatório sem agrupamento que pode não ter linhas, proteja o denominador com NULLIF(COUNT(*), 0). Uma contagem em um conjunto de entrada vazio é zero, mas um percentual de uma população vazia não tem denominador.

Crie várias colunas de categoria

Um único resultado pode mostrar uma contagem por região:

SELECT COUNT(CASE WHEN region = 'East' THEN 1 END) AS east, COUNT(CASE WHEN region = 'West' THEN 1 END) AS west, COUNT(CASE WHEN region = 'North' THEN 1 END) AS north FROM orders;

As contagens são três, dois e dois. O pedido de Eli não pertence a nenhum desses testes de regiões nomeadas. Adicione COUNT(CASE WHEN region IS NULL THEN 1 END) para contar o único pedido sem região. Comparar uma região NULL com um nome não produz uma condição verdadeira.

Reconheça sintaxes alternativas

O PostgreSQL e o SQLite a partir da versão 3.30.0 oferecem suporte a COUNT(*) FILTER (WHERE amount >= 100). O filtro se aplica a essa função de agregação, então um COUNT(*) adjacente sem filtro ainda conta todos os pedidos. MySQL e SQL Server não oferecem suporte a essa sintaxe FILTER de agregação; a forma com CASE funciona em ambos.

SQLite e MySQL também permitem SUM(amount >= 100) porque as comparações produzem valores lógicos numéricos. O PostgreSQL rejeita SUM de valores booleanos. Use a forma com CASE quando uma consulta precisar funcionar nesses mecanismos.

Uma consulta de resumo começa com uma pergunta sobre uma população em um determinado nível de detalhe. Transforme essas escolhas antes de escrever a SQL e depois verifique se o resultado ainda responde à pergunta original.

Construa o relatório em ordem

Pergunte: “Para cada mês de 2026 com pelo menos três pedidos, quantos pedidos foram feitos e qual foi o valor médio, com duas casas decimais?”

1. As medidas são COUNT(*) e AVG(amount).
2. A granularidade, ou o significado de uma linha do resultado, é um mês do calendário.
3. A condição de linha mantém datas em 2026.
4. A condição de grupo exige pelo menos três pedidos.
5. O resultado deve ser ordenado por mês, com a média arredondada para exibição.

No SQLite:

SELECT strftime('%Y-%m', order_date) AS month, COUNT(*) AS orders, ROUND(AVG(amount), 2) AS avg_amount FROM orders WHERE order_date >= '2026-01-01' AND order_date < '2027-01-01' GROUP BY strftime('%Y-%m', order_date) HAVING COUNT(*) >= 3 ORDER BY month;

Para valores de data no PostgreSQL, substitua a expressão de mês nos dois pontos por to_char(order_date, 'YYYY-MM'). O intervalo de datas inclui o início de 2026 e exclui o início de 2027.

Janeiro tem dois pedidos e não atende à condição de grupo. Fevereiro tem três pedidos que totalizam 305, com média de 101,67. Março tem três que totalizam 275, com média de 91,67. Os grupos mantidos correspondem a seis pedidos, não oito, porque HAVING removeu janeiro.

Verifique antes de filtrar os grupos

Execute primeiro o relatório sem HAVING. As contagens de todos os grupos devem somar a quantidade de linhas sob o mesmo filtro WHERE, e os totais devem somar o total sem agrupamento. Aqui, essas verificações resultam em oito e 780. Não compare os totais dos grupos mantidos com toda a entrada depois que alguns grupos forem excluídos.

Procure um grupo NULL, examine a ordem dos resultados e recalcule um grupo filtrando a tabela original. Para East, WHERE region = 'East' deve resultar em três pedidos que totalizam 260. Uma diferença pode revelar uma coluna de agrupamento extra, um filtro de linha mal posicionado ou uma expressão que se tornou NULL.

Distinga a média por pedido da média por cliente

AVG(amount) é 97,5 por pedido. O gasto médio por cliente pede uma unidade diferente: os cinco totais por cliente são 165, 140, 350, 95 e 30. Sua média é 156.

Calcule isso em duas etapas:

SELECT AVG(total) AS avg_customer_total FROM (SELECT customer, SUM(amount) AS total FROM orders GROUP BY customer) AS per_customer;

A consulta interna cria uma linha por cliente. A consulta externa calcula a média dessas linhas, dando a cada cliente uma contribuição. Com todos os clientes identificados, 1.0 * SUM(amount) / COUNT(DISTINCT customer) produz os mesmos 156. Quantidades diferentes de pedidos fazem da média dos valores por pedido um cálculo diferente.

Resuma os próprios grupos

Para contar clientes com mais de um pedido, primeiro liste-os e depois conte suas linhas:

SELECT COUNT(*) FROM (SELECT customer FROM orders GROUP BY customer HAVING COUNT(*) > 1) AS repeat_customers;

A resposta é três. Aninhar funções de agregação diretamente, como em MAX(AVG(amount)) em um único nível de consulta, falha no SQLite e no PostgreSQL. Para encontrar a região com a maior média, ordene as médias agrupadas: ORDER BY AVG(amount) DESC LIMIT 1 retorna North com 175. O Oracle também oferece suporte a funções de grupo aninhadas, mas um nível de consulta separado torna explícitos os dois cálculos. Verifique os empates quando um relatório pedir o maior resultado.