Funções GROUP BY e Aggregate: Uma visão geral completa

As funções GROUP BY e aggregate do SQL são essenciais na agregação de dados - e para analisar dados e criar relatórios. Vamos explorá-las juntos!

No SQL, as funções GROUP BY e de agregação são um dos recursos mais populares da linguagem. A agregação de dados é essencial para a análise de dados e a criação de relatórios; para dar sentido a todos os dados em um conjunto de dados, eles geralmente precisam ser agregados.

Mas o que é agregação de dados? Simplificando, é quando você agrupa dados com base em valores comuns e executa um cálculo para cada grupo de dados. Por exemplo, você pode agrupar uma lista de cães por sua raça e, em seguida, usar um cálculo para descobrir a altura média de cada raça. Essa tarefa é possível graças à cláusula GROUP BY e à função de agregação AVG().

Se você precisar atualizar seus conhecimentos sobre GROUP BY, nosso SQL para Iniciantes curso é ideal. Ele tem 129 exercícios interativos que você pode concluir em cerca de 10 horas. Ele aborda tópicos como filtragem de dados, uso de operadores lógicos, união e uso de operadores de conjunto.

A sintaxe básica do GROUP BY com agregados

GROUP BY GROUP BY é uma cláusula do SQL que organiza os dados com os mesmos valores em grupos. O agrupamento é feito por coluna(s), em que todas as linhas com o mesmo valor nessa coluna pertencem a um grupo. Em seguida, você pode executar cálculos de resumo - como contagem, soma ou média de valores - para cada grupo. Por exemplo, você pode usar GROUP BY para calcular o número de funcionários em um departamento, o salário total ou o salário médio por departamento etc.

A sintaxe de GROUP BY com uma função de agregação é a seguinte:

SELECT column1, 
        column2, 
        ..., 
        aggregate_function(column_name)
FROM table_name
WHERE filtering_condition
GROUP BY column1, column2, …
HAVING filtering_condition;

A função de agregação é escrita na instrução SELECT e o resultado da função será mostrado como uma coluna adicional.

A cláusula GROUP BY contém as colunas pelas quais você deseja que o resultado seja agrupado. Essa cláusula é frequentemente usada com as cláusulas WHERE e HAVING para filtragem. Na sintaxe, WHERE vem antes de GROUP BY, enquanto HAVING vem depois. (Explicarei mais sobre essas duas cláusulas posteriormente.) Além disso, seus dados às vezes conterão NULLs, portanto, você terá interesse em saber como o GROUP BY trata os NULLs.

Um exemplo de GROUP BY em ação é mostrado no GIF a seguir.

Esse exemplo básico agrupa os dados por diretor de cinema e mostra o número de filmes que cada um fez.

Funções agregadas do SQL

As funções agregadas do SQL são usadas quando você deseja fazer cálculos nos dados e retornar um único valor.

As funções agregadas mais comuns no SQL são:

• COUNT() - Conta as linhas na coluna indicada.
• SUM() - Retorna a soma de todos os valores.
• AVG() - Calcula a média de um grupo de valores.
• MIN() - Retorna o mínimo (o menor) dos valores fornecidos.
• MAX() - Retorna o máximo (o mais alto) dos valores fornecidos

Consulte nossos guias sobre como usar essas funções para calcular agregados para toda a tabela:

• Como contar o número de linhas em uma tabela no SQL
• Como contar valores distintos no SQL
• Como somar valores de uma coluna no SQL?
• Como encontrar a média de uma coluna numérica no SQL
• Como encontrar o valor máximo de uma coluna no SQL?
• Como encontrar o valor mínimo de uma coluna no SQL

É importante observar que a função COUNT() tem diversas variações de uso:

• COUNT(*) conta todas as linhas em um conjunto de resultados, incluindo valores NULL e duplicatas.
• COUNT(expression) conta os valores não NULL em um conjunto de resultados.
• COUNT(DISTINCT) conta os valores distintos e ignora as duplicatas.

Há mais detalhes em nosso guia Qual é a diferença entre COUNT(*), COUNT(1), COUNT(column) e COUNT(DISTINCT)?

Uso de GROUP BY com funções agregadas do SQL

Usarei a tabela albums para mostrar como as funções de agregação e o site GROUP BY funcionam juntos. O script para criar a tabela está aqui.

Essa tabela contém dados sobre álbuns musicais. Aqui está um instantâneo:

id	artist	album	release_year	length	label
1	Grant Green	The Latin Bit	1963	0:38:56	Blue Note Records
2	AC/DC	High Voltage	1976	0:44:23	Atlantic Records
3	Brother Jack McDuff	To Seek a New Home	1970	0:33:12	Blue Note Records
4	Grant Green	Green Is Beautiful	1970	0:37:33	Blue Note Records
5	Wayne Shorter	Moto Grosso Feio	1974	0:42:22	Blue Note Records

Exemplo 1: COUNT() com GROUP BY

Aqui está um exemplo de código que conta o número de álbuns por rótulo:

SELECT label,
	 COUNT(*) AS number_of_albums
FROM albums
GROUP BY label; 

Eu seleciono o rótulo e uso COUNT(*) para encontrar o número de álbuns. O asterisco (*) é uma abreviação para contar todas as linhas. Quando eu agrupar o resultado por rótulo, o COUNT() mostrará o número de álbuns por rótulo.

Aqui está o resultado:

label	number_of_albums
Atlantic Records	13
Blue Note Records	12
Stax Records	14

Leitura adicional:

• Um guia detalhado da função SQL COUNT()
• A função SQL Count explicada com 7 exemplos
• Como contar o número de linhas em uma tabela no SQL.
• Qual é a diferença entre COUNT(*), COUNT(1), COUNT(column) e COUNT(DISTINCT)?
• Como contar valores distintos no SQL.

Exemplo 2: SUM() com GROUP BY

O código a seguir soma as durações dos álbuns para mostrar o total de músicas disponíveis por artista:

SELECT artist,
	 SUM(length) AS total_music_available
FROM albums
GROUP BY artist;

A função SUM() é aplicada à coluna length e o resultado é então agrupado pelo artista.

Este é o resultado do código:

artist	total_music_available
Isaac Hayes	6:30:02
Otis Redding	1:34:09
Brother Jack McDuff	1:58:11
Aretha Franklin	1:47:07
Grant Green	3:10:11
John Prine	1:21:57
Led Zeppelin	3:32:07
Wayne Shorter	2:38:02
Albert King	3:08:28
AC/DC	2:05:23

Leitura adicional:

• Função SQL SUM() explicada com 5 exemplos práticos
• Como somar valores de uma coluna no SQL

Exemplo 3: AVG() com GROUP BY

Esse código calcula a duração média do álbum de cada artista:

SELECT artist,
	 AVG(length) AS average_album_length
FROM albums
GROUP BY artist; 

Para obter o resultado desejado, você precisa usar AVG() na coluna length e agrupar o resultado por artist.

Aqui está a aparência do resultado:

artist	average_album_length
Isaac Hayes	1:05:00
Otis Redding	0:31:23
Brother Jack McDuff	0:39:24
Aretha Franklin	0:35:42
Grant Green	0:38:02
John Prine	0:40:59
Led Zeppelin	0:42:25
Wayne Shorter	0:39:31
Albert King	0:37:42
AC/DC	0:41:48

Leitura adicional:

• A função SQL AVG() explicada com exemplos
• Como encontrar a média de uma coluna numérica no SQL

Exemplo 4: MIN() e MAX() com GROUP BY

Vamos encontrar a menor e a maior duração do álbum para cada ano:

SELECT release_year,
	 MIN(length) AS minimum_album_length,
	 MAX(length) AS maximum_album_length
FROM albums
GROUP BY release_year
ORDER BY release_year; 

Como nos exemplos anteriores, as funções de agregação são usadas na coluna length; MIN() para o álbum mais curto e MAX() para o mais longo.

O resultado é agrupado por ano de lançamento.

Também adicionei a cláusula ORDER BY para classificar o resultado do ano mais antigo para o mais recente, para que ficasse mais legível.

Aqui está o resultado do código:

release_year	minimum_album_length	maximum_album_length
1962	0:34:49	0:34:49
1963	0:38:56	0:38:56
1964	0:30:17	0:30:17
1965	0:32:22	0:42:45
1967	0:32:51	0:41:08
1968	0:29:30	0:29:30
1969	0:31:30	0:46:00
1970	0:33:12	0:43:04
1971	0:42:37	1:33:38
1972	0:37:50	0:44:46
1973	0:40:57	1:43:10
1974	0:42:22	0:46:00
1976	0:39:59	0:44:23
1977	0:41:01	0:41:01

Leitura adicional:

• Funções SQL MIN e MAX explicadas em 6 exemplos
• Como encontrar o valor máximo de uma coluna numérica no SQL
• Como encontrar o valor mínimo de uma coluna no SQL

Técnicas avançadas de GROUP BY

A seção anterior abordou os conceitos básicos do uso de funções agregadas do SQL e GROUP BY. Com essas bases estabelecidas, podemos agora explorar algumas técnicas avançadas do GROUP BY.

Filtragem de resultados agregados com HAVING

Para filtrar resultados agregados, você precisa usar a cláusula HAVING. Sua sintaxe é mostrada aqui:

SELECT column1, 
       column2, 
       ..., 
       aggregate_function(column_name)
FROM table_name
GROUP BY column1, column2, …
HAVING filtering_condition;

HAVING compara os valores agregados com a condição de filtragem e retorna somente os valores que satisfazem essa condição. Você pode saber mais em nosso artigo sobre a cláusula HAVING.

Vou lhe mostrar um exemplo. O código a seguir calcula a duração média do álbum por artista, mas mostra somente aqueles cuja duração média do álbum é inferior a 40 minutos.

SELECT artist,
	 AVG(length) AS average_album_length
FROM albums
GROUP BY artist
HAVING AVG(length) < '00:40:00';

Usei a função AVG() da mesma forma que fiz anteriormente. A cláusula HAVING é nova. Para filtrar os dados da maneira necessária, escrevi em HAVING o mesmo cálculo de média que aparece em SELECT. Em seguida, usei o operador de comparação 'less than' (<) para comparar cada resultado agrupado com um valor (nesse caso, 40 minutos). Esse valor é colocado entre aspas simples (''). O valor entre aspas deve ser escrito no formato HH:MM:SS (horas:minutos:segundos) porque os valores na coluna length são do tipo de dados INTERVAL.

Aqui está o resultado:

artist	average_album_length
Otis Redding	0:31:23
Brother Jack McDuff	0:39:24
Aretha Franklin	0:35:42
Grant Green	0:38:02
Wayne Shorter	0:39:31
Albert King	0:37:42

O princípio é o mesmo, independentemente da função de agregação que você usar, mas aqui estão os livros de receitas para ajudá-lo com algumas outras funções:

• Como filtrar registros com a função de agregação COUNT
• Como filtrar registros com a função agregada SUM
• Como filtrar registros com a função de agregação AVG

Agrupamento por várias colunas

Até agora, agrupei dados por uma coluna. Entretanto, também é possível agrupar por duas ou mais colunas.

Não é complicado: Você só precisa listar todas as colunas de agrupamento em GROUP BY e separá-las com vírgulas.

Ao fazer isso, você agrupa pelos valores da coluna, mas também pela combinação de valores em todas as colunas de agrupamento. Se você tiver o valor A na coluna_1 e o valor B na coluna_2, esse é um grupo. Se houver, por exemplo, valores A na coluna_1 com valor C na coluna_2, isso formará outro grupo, apesar de os valores na coluna_1 serem os mesmos do exemplo anterior.

Exemplo

O código abaixo mostra o número de álbuns do artista e o ano de lançamento:

SELECT artist,
	 release_year,
	 COUNT(*) AS number_of_albums
FROM albums
GROUP BY artist, release_year
ORDER BY artist, release_year;

Estou usando COUNT(*) para encontrar o número de álbuns. O resultado é agrupado por artista e ano de lançamento. Como você pode ver, essas são exatamente as colunas em GROUP BY e estão separadas por vírgula.

Para tornar o resultado mais legível, classifiquei os dados por artista em ordem alfabética e do ano de lançamento mais antigo para o mais recente.

Este é o instantâneo do resultado:

artist	release_year	number_of_albums
AC/DC	1976	2
AC/DC	1977	1
Albert King	1962	1
Albert King	1967	1
Albert King	1969	1
Albert King	1972	1
Albert King	1974	1
Aretha Franklin	1967	1
Aretha Franklin	1968	1
Aretha Franklin	1972	1
Brother Jack McDuff	1969	2
Brother Jack McDuff	1970	1

Duas funções agregadas em uma consulta

Também é possível escrever uma consulta que tenha duas funções agregadas. Não, não é o que você está pensando: você não escreve uma função agregada dentro de outra. Isso não é possível no SQL.

Duas funções de agregação em uma consulta podem significar duas coisas:

1. Abordagem simples: Usar duas funções de agregação em duas colunas do mesmo SELECT.
2. Abordagem avançada: Usar o resultado de uma função agregada em outra função agregada.

Uma consulta, duas funções agregadas: A abordagem simples

Portanto, a abordagem simples é quando você tem duas funções de agregação em duas colunas de agregação diferentes em um SELECT. Elas podem ser a mesma função aplicada em colunas diferentes, funções diferentes usadas na mesma coluna ou funções diferentes usadas em colunas diferentes. Isso realmente não importa; o ponto é que você tem duas agregações em uma consulta. Essas agregações não se "comunicam", ou seja, não dependem uma da outra de forma alguma.

Exemplo

No exemplo, usarei a tabela package_deliveries com o script vinculado aqui.

A tabela mostra informações sobre o número de pacotes entregues diariamente em várias cidades.

Aqui estão as seis primeiras linhas da tabela:

id	date_of_delivery	number_of_packages	city_of_delivery	country_of_delivery
1	2024-03-01	49	Krakow	Poland
2	2024-03-01	528	Warsaw	Poland
3	2024-03-01	158	Gdansk	Poland
4	2024-03-01	28	Rijeka	Croatia
5	2024-03-01	97	Split	Croatia
6	2024-03-01	64	Zagreb	Croatia

O código abaixo calcula o total e o número médio de pacotes por cidade.

SELECT city_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
GROUP BY city_of_delivery;

Você pode ver que a consulta tem dois agregados: um com SUM() e outro com AVG(). Realmente não importa quantas funções de agregação você escreve na consulta. A única coisa importante é que cada agregação seja tratada como uma linha de código ou coluna de saída separada.

Aqui está o resultado:

city_of_delivery	total_number_of_packages	average_number_of_packages
Split	531	177.00
Izmir	5,936	1,978.67
Ankara	9,139	3,046.33
Gdansk	712	237.33
Rijeka	627	209.00
Zagreb	930	310.00
Istanbul	13,857	4,619.00
Krakow	673	224.33
Warsaw	2,358	786.00

Uma consulta, duas funções agregadas: A abordagem avançada

A versão avançada é quando as agregações se "comunicam", o que significa que você precisa primeiro encontrar um valor agregado e, em seguida, usá-lo para calcular outro valor agregado. Normalmente, isso é feito por meio de subconsultas ou expressões de tabela comuns (CTEs).

Mostrarei a você o uso de subconsultas no exemplo abaixo. Nosso guia sobre a combinação de duas funções de agregação em GROUP BY abrange ambas as abordagens.

Exemplo

O código a seguir retorna o número médio diário de pacotes entregues em cada país:

SELECT country_of_delivery,
	 AVG(pd.daily_number_of_packages) AS average_daily_number_of_packages
FROM (SELECT date_of_delivery, 
	       country_of_delivery,
	 	 SUM(number_of_packages) AS daily_number_of_packages
	FROM package_deliveries
	GROUP BY date_of_delivery, country_of_delivery) AS pd
GROUP BY country_of_delivery;

Primeiro, preciso encontrar o número de pacotes entregues diariamente em cada país, que é a primeira agregação. A segunda agregação usa esse resultado e calcula a média diária por país.

A primeira agregação está escrita na subconsulta. Ela usa a função SUM() e lista as colunas date_of_delivery e country_of_delivery em SELECT. O resultado é agrupado pelas mesmas colunas.

Agora, posso escrever a consulta principal, referenciando em AVG() a coluna daily_number_of_packages da subconsulta. Agrupo o resultado por país e obtenho o número médio diário de pacotes entregues para cada país.

country_of_delivery	average_daily_number_of_packages
Turkey	9,644.00
Croatia	696.00
Poland	1,247.67

GROUP BY com agregados condicionais

A instrução CASE ou CASE WHEN rotula os dados com base em seus valores. Essa instrução também pode ser usada com GROUP BY.

Agrupar dados por agregados condicionais significa usar CASE WHEN com GROUP BY. Entretanto - e isso é importante - o CASE WHEN que você escreve em SELECT também precisa aparecer em GROUP BY.

Exemplo

Usando a tabela do exemplo anterior, posso escrever um código que categoriza os países em países da UE e países fora da UE e mostra o número total de pacotes entregues para cada categoria:

SELECT
  CASE 
   WHEN country_of_delivery = 'Turkey' THEN 'Non-EU'
   ELSE 'EU'
  END,
  SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY CASE 
   WHEN country_of_delivery = 'Turkey' THEN 'Non-EU'
   ELSE 'EU'
  END;

A declaração CASE diz que a Turquia deve ser categorizada como um país fora da UE. Essa condição é declarada em WHEN. A categoria para todos os outros países é UE, que está escrita em ELSE.

A declaração CASE começa com CASE (daí o nome) e termina com a palavra-chave END.

Uso a função SUM() para calcular o número total de pacotes. Para mostrar esse valor por categoria, apenas copiei toda a instrução CASE WHEN em GROUP BY.

Aqui está o resultado:

case	total_number_of_packages
Non-EU	28,932
EU	5,831

Se você precisar de mais exemplos para entender isso completamente, leia um de nossos guias:

• Como usar CASE WHEN com SUM() no SQL
• Como usar CASE WHEN em GROUP BY

Extensões de GROUP BY: ROLLUP, CUBO, CONJUNTOS DE AGRUPAMENTO

As três extensões do SQL GROUP BY são:

• ROLLUP - Cria uma linha de resumo para os grupos listados em GROUP BY.
• CUBE - Cria subtotais para todas as combinações dos grupos em GROUP BY.
• GROUPING SETS - Agrega a saída em vários níveis.

No exemplo, mostrarei como GROUPING SETS funciona. Você pode saber como as outras duas extensões funcionam em nosso guia de extensões GROUP BY.

Exemplo

O código a seguir retorna o número de pacotes entregues por país e por data:

SELECT country_of_delivery,
	 date_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY GROUPING SETS(country_of_delivery, date_of_delivery)
ORDER BY country_of_delivery, date_of_delivery;

Começo usando SUM() para calcular o número de pacotes.

Em GROUP BY, escrevo GROUPING SETS com todos os níveis de agregação dentro dos parênteses.

O resultado mostra o número de pacotes entregues por país e por data de entrega:

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

Pode ser útil pensar em conjuntos de agrupamento como duas consultas separadas. A primeira consulta agrupa por país ...

SELECT country_of_delivery,
       NULL AS date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery
ORDER BY country_of_delivery;

... e retorna as três primeiras linhas do resultado anterior:

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932

A segunda consulta agrupa por data de entrega ...

SELECT NULL AS country_of_delivery,
       date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY date_of_delivery
ORDER BY date_of_delivery;

... e retorna as outras três linhas do resultado original:

country_of_delivery	date_of_delivery	total_number_of_packages
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

Em outras palavras, se você mesclar essas duas consultas de agrupamento separadas usando UNION...

SELECT country_of_delivery,
       NULL AS date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery

UNION 

SELECT NULL AS country_of_delivery,
       date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY date_of_delivery
ORDER BY country_of_delivery, date_of_delivery;

... você obterá exatamente o mesmo resultado que com GROUPING SETS.

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

Erros comuns ao usar GROUP BY

Confundir ORDER BY e GROUP BY

Isso geralmente é uma questão de não saber o que GROUP BY faz.

Vou demonstrar com um exemplo.

Digamos que você queira encontrar o número total de pacotes por país de entrega.

Se você não estiver familiarizado com GROUP BY, poderá escrever uma solução ingênua usando ORDER BY.

SELECT date_of_delivery,
	 city_of_delivery,
	 country_of_delivery
FROM package_deliveries
ORDER BY country_of_delivery;

Agora que você tem os dados classificados por país, conforme mostrado no instantâneo abaixo, você decide somar manualmente os valores para obter o resultado por país.

date_of_delivery	city_of_delivery	country_of_delivery
2024-03-01	Rijeka	Croatia
2024-03-01	Split	Croatia
2024-03-01	Zagreb	Croatia
2024-03-02	Rijeka	Croatia
2024-03-02	Split	Croatia
2024-03-02	Zagreb	Croatia
2024-03-03	Zagreb	Croatia
2024-03-03	Split	Croatia
2024-03-03	Rijeka	Croatia
2024-03-01	Krakow	Poland
2024-03-01	Warsaw	Poland

Mas por que você faria manualmente algo que o GROUP BY faz automaticamente? Em vez de ordenar os dados por país, você deve agrupar por ele e usar SUM() para somar os dados:

SELECT country_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery
ORDER BY country_of_delivery;

Você obtém imediatamente o resultado de que precisa:

country_of_delivery	total_number_of_packages
Croatia	2,088
Poland	3,743
Turkey	28,932

Leia mais sobre as diferenças entre GROUP BY e ORDER BY e como usar GROUP BY e ORDER BY juntos.

Confusão entre WHERE e HAVING

Outro erro comum é tentar filtrar valores agregados usando WHERE. Isso não é possível - WHERE é usado para filtrar linhas individuais antes da agregação. Por outro lado, HAVING serve para filtrar grupos de linhas após a agregação.

Exemplo

Se você quiser obter o número médio de pacotes entregues diariamente por cidade e mostrar somente aquelas com mais de 500 pacotes, você pode decidir escrever esta consulta:

SELECT city_of_delivery,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
WHERE AVG(number_of_packages) > 500
GROUP BY city_of_delivery;

Ela retornará um erro porque WHERE não aceita uma função de agregação como argumento. (Isso não significa que você nunca poderá usar WHERE com GROUP BY; você pode, mas não para filtrar grupos).

Nesse caso, você deve usar HAVING:

SELECT city_of_delivery,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
GROUP BY city_of_delivery
HAVING AVG(number_of_packages) > 500;

É a mesma consulta com AVG() e GROUP BY. A única diferença é HAVING, em que você compara o cálculo de AVG() com 500.

O resultado mostra apenas as cidades cuja média diária é superior a 500.

city_of_delivery	average_number_of_packages
Izmir	1,978.67
Ankara	3,046.33
Istanbul	4,619.00
Warsaw	786.00

Saiba mais sobre isso no artigo sobre HAVING vs. WHERE.

Como listar colunas não agregadas em SELECT, mas não em WHERE

A regra simples que você deve lembrar é que qualquer coluna não agregada que você escrever em SELECT também deve ser incluída em GROUP BY. Se você não fizer isso, o banco de dados não saberá qual valor mostrar se houver vários valores diferentes no mesmo grupo.

Exemplo

Por exemplo, você escreve a consulta que deve calcular o número total de pacotes por país e por cidade.

SELECT country_of_delivery,
       city_of_delivery,
	 SUM(number_of_packages) total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery;

Claro, você tem o país e a cidade em SELECT, mas esqueceu de colocar a cidade em GROUP BY. Essa consulta não será executada. Ela retornará um erro. Embora as mensagens sejam redigidas de forma diferente no PostgreSQL, Oracle e outros bancos de dados, a mensagem é a mesma: a coluna city_of_delivery deve aparecer em GROUP BY.

Mesmo que fosse executado, o banco de dados ficaria confuso. Ele pensaria algo assim: "Você quer mostrar as cidades, mas não quer agrupar por cidade? Como vou saber qual cidade mostrar na saída quando cada país tem três? Por favor, coloque as cidades em GROUP BY para que eu possa mostrar cada cidade como um grupo separado."

Então, você o ajuda incluindo a cidade de entrega em GROUP BY:

SELECT country_of_delivery,
       city_of_delivery,
	 SUM(number_of_packages) total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery, city_of_delivery;

Sim, é um agrupamento por duas colunas e você já aprendeu a fazer isso. Aqui está o resultado da consulta:

country_of_delivery	city_of_delivery	total_number_of_packages
Croatia	Zagreb	930
Croatia	Rijeka	627
Croatia	Split	531
Turkey	Istanbul	13,857
Poland	Warsaw	2,358
Poland	Krakow	673
Turkey	Ankara	9,139
Poland	Gdansk	712
Turkey	Izmir	5,936

Outros erros

Há também alguns outros erros, como esquecer GROUP BY com funções agregadas ou não agrupar por uma chave exclusiva. Esses e vários outros erros são abordados neste artigo sobre erros comuns de GROUP BY.

Outros recursos do SQL GROUP BY

Depois de ler esta visão geral da cláusula SQL GROUP BY, você deve ter uma ideia de seus usos e desafios. Mas, se quiser dominar a GROUP BY, precisará entrar em mais detalhes.

A melhor maneira de fazer isso é dar uma olhada em alguns de nossos cursos e livros de receitas. Aqui estão algumas de minhas sugestões para aprender mais:

• Como Criar Relatórios Básicos em SQL - Esse curso de nível intermediário concentra-se nas nuances do uso do GROUP BY - agrupamento por várias colunas, uso de HAVING, combinação de GROUP BY com CASE WHEN, a diferença entre COUNT(*) e COUNT(id), etc.

• Comandos GROUP BY em SQL - Este curso abrange CUBE, ROLLUP e GROUPING SETS.

• Trilha de Práticas em SQL - Os cursos dessa faixa têm seções dedicadas a diferentes tópicos de SQL, incluindo muita prática de GROUP BY.

E não se esqueça de nossos artigos com exemplos de GROUP BY. Dois dos meus favoritos são Trilha de Práticas em SQL: Prática de SQL: 10 exercícios práticos de GROUP BY com soluções detalhadas e Top 9 SQL GROUP BY Interview Questions.

Além disso, há uma folha de dicas de SQL para análise de dados, que tem uma seção dedicada a GROUP BY.

Bom aprendizado!