Introdução ao agrupamento e totalização SQL

Um dos aspectos mais poderosos do SQL é a capacidade de realizar agregação de dados. Duas das ferramentas de agregação de dados SQL mais poderosas são agrupamento e totalizando . Neste guia, você aprende a agregação de dados SQL usando agrupamento e totalização.

Funções de agregação SQL

No SQL, a agregação é o processo de operação ou cálculo de um conjunto de valores. A intenção é retornar um único valor de resumo. SQL inclui várias funções agregadas muito poderosas, como AVG() , COUNT() , SUM() , MAX() e MIN() . Essas funções, por sua vez, são mais frequentemente encontradas em instruções SQL que implementam um GROUP BY cláusula. No entanto, essas funções não precisam ser associadas a essa cláusula.

Observação A menos que mencionado de outra forma, todos os comandos de banco de dados demonstrados neste guia funcionam bem tanto em MySQL e PostgreSQL .

Este guia usa um CourseTaken tabela para demonstrar funções agregadas. Na linha de comando, crie o CourseTaken tabela.

CREATE TABLE CourseTaken (
    SSNumber CHAR(9) NOT NULL,
    CourseId CHAR(6) NOT NULL,
    NumericGrade INT NOT NULL,
    YearTaken INT NOT NULL
);

O CourseTaken tabela contém os seguintes dados de coluna:

SSNumber	CourseId	NumericGrade	Ano do ano
111111111	CSC101	98	2021
111111111	ENG101	95	2022
222222222	CSC101	100	2022
222222222	EEE101	75	2022
333333333	POL101	92	2021
333333333	CSC101	84	2022

Usar uma função de agregação SQL para calcular um valor de resumo único

As seções abaixo fornecem diferentes exemplos que usam funções agregadas para retornar um único valor de resumo. Todos os exemplos usam o CourseTaken tabela que foi criada na seção Funções Agregadas do guia.

Exemplo 1:

Neste exemplo, a função agregada retorna uma nota média numérica para todos os alunos do curso CSC101 no ano de 2022.

SELECT AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101
AND YearTaken = 2022;

O SQL retorna a seguinte nota média:

Avg Grade
---------
92

Exemplo 2:

A função agregada abaixo retorna uma contagem do número de alunos que fizeram o curso CSC101 antes do ano de 2022.

SELECT COUNT(SSNumber) AS 'Student Count'
FROM CourseTaken
WHERE CourseId = 'CSC101'
AND YearTaken < 2022;

A seguinte contagem é retornada:

Student Count
---------
1

Exemplo 3:

Neste exemplo, uma função agregada é usada para obter a nota numérica máxima registrada em qualquer ano por um Aluno que está cursando CSC101 .

SELECT MAX(NumericGrade) AS 'Max Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101'

A nota máxima retornada é a seguinte:

Max Grade
---------
100

Agregar dados usando funções de grupo

Os exemplos a seguir demonstram o uso do GROUP BY cláusula usando os dados do CourseTaken tabela.

Exemplo 1:

O exemplo abaixo determina a nota média de cada aluno para todos os cursos que eles fizeram até o momento. Para executar isso, use o SQL Group By cláusula para agrupar por Aluno (neste caso, o SSNumber coluna).

SELECT SSNumber, AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
GROUP BY SSNumber

A saída retorna a nota média de cada aluno.

+-----------+----------+
| SSNumber  | Avg Grade|
+-----------+----------+
| 111111111 | 96.5     |
| 222222222 | 87.5     |
| 333333333 | 88       |
+-----------+----------+

Exemplo 2:

A função agregada abaixo encontra a nota média recebida em cada CourseId no CourseTaken tabela. Para fazer isso, agrupe por CourseId dentro de YearTaken com o seguinte código SQL:

SELECT CourseId AS 'Course', YearTaken AS 'Year',
AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

Você deve ver a seguinte saída:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| POL101 | 2021 | 92        |
| CSC101 | 2022 | 92        |
| EEE101 | 2022 | 75        |
| ENG101 | 2022 | 95        |
+--------+------+-----------+

Observação O exemplo acima é um pouco mais complexo. Você agrupa por duas colunas em vez de uma (CourseId dentro de Year ). Assim, você calcula a nota média e agrupa por CSC101 para o ano 2021 separadamente da nota média para CSC101 para o ano 2022 . O curso CSC101 para o ano 2022 é uma agregação de duas linhas, enquanto todas as outras linhas Agrupar por são uma agregação de uma linha. Além disso, a partir do conceito de Pedido (Order By cláusula) você pode exibir resultados ordenados (classificados) por Course dentro de um determinado ano.

Exemplo 3:

Na consulta SQL no exemplo anterior, você pode restringir o número de linhas que você opera adicionando um WHERE cláusula para a consulta. Por exemplo, para gerar a nota média recebida pelos alunos apenas para CourseId CSC101 , agrupar por CourseId dentro de YearTaken . O seguinte código SQL pode fazer isso:

SELECT CourseId AS 'Course', YearTaken AS 'Year',
AVG(NumericGrade) AS 'Avg Grade'
FROM CourseTaken
WHERE CourseId = 'CSC101'
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

No código SQL acima, você está adicionando uma condição (via WHERE cláusula) antes que a agregação do grupo real seja executada (através do GROUP BY cláusula).

A seguinte saída é retornada:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| CSC101 | 2022 | 92        |
+--------+------+-----------+

Exemplo 4:

Na consulta SQL no Exemplo 2, você pode aplicar uma condição antes que o resultado final seja retornado. Para fazer isso, use o SQL Having cláusula. Você pode determinar a nota média em cada CourseId , em que a nota média agregada é maior que 90 . Você pode agrupar novamente por CourseId dentro de YearTaken . O seguinte código SQL pode fazer isso:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’
FROM CourseTaken
GROUP BY CourseId, YearTaken
HAVING AVG(NumericGrade) > 90
ORDER BY CourseId, YearTaken

A saída é a seguinte:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
| POL101 | 2021 | 92        |
| CSC101 | 2022 | 92        |
| ENG101 | 2022 | 95        |
+--------+------+-----------+

A linha para CourseId EEE101 não foi devolvido. Isso ocorre porque o Having cláusula o filtrou após o GROUP BY cláusula foi executada (CourseId EEE101 a nota média de 90 é inferior a 90).

Exemplo 5:

Com base no código SQL do Exemplo 3 e Exemplo 4 , você pode criar consultas de agregação que utilizam o Where e Having cláusula. Por exemplo, você pode determinar os cursos que foram feitos em 2021 , em que a nota média dos cursos realizados foi maior que 93 . Aqui, o Where cláusula filtra os resultados antes do Group By agregação de dados é executada, e o Having cláusula filtra os resultados retornados após o Group By agregação de dados é executada. O seguinte código SQL pode fazer isso:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’
FROM CourseTaken
WHERE YearTaken = 2021
GROUP BY CourseId, YearTaken
HAVING AVG(NumericGrade) > 93
ORDER BY CourseId

A saída retornada é a seguinte:

+--------+------+-----------+
| Course | Year | Avg Grade |
+--------+------+-----------+
| CSC101 | 2021 | 98        |
+--------+------+-----------+

Exemplo 6:

Você pode contar o número de linhas associadas a cada Group By agregação em uma consulta. Com base no código SQL de exemplo anterior, você pode gerar a nota média recebida por Students apenas para CourseId CSC101 , agrupado por CourseId dentro de YearTaken . O código deve fornecer o número de alunos (contagem) associados a cada grupo. O seguinte código SQL pode fazer isso:

SELECT CourseId AS ‘Course’, YearTaken AS ‘Year’,
AVG(NumericGrade) AS ‘Avg Grade’,
Count(SSNumber) AS ‘Count’
FROM CourseTaken
WHERE CourseId = ‘CSC101’
GROUP BY CourseId, YearTaken
ORDER BY CourseId, YearTaken

O Count(SSNumber) no SELECT cláusula poderia ter sido especificada como Count(*) . A diferença entre as duas sintaxes é que Count(*) inclui linhas que têm NULL valores neles também. De acordo com o CourseTaken definição da tabela acima, todas as colunas no CourseTaken A tabela deve conter valores não nulos (o NOT NULL atributo garante isso). O Count(SSNumber) e Count(*) seria funcionalmente equivalente neste exemplo.

A seguinte saída é retornada:

+--------+------+-----------+-------+
| Course | Year | Avg Grade | Count |
+--------+------+-----------+-------+
| CSC101 | 2021 | 98        | 1     |
| CSC101 | 2022 | 92        | 2     |
+--------+------+-----------+-------+

Conclusão

Este guia fornece os blocos de construção para as poderosas operações de agregação de dados do SQL para agrupamento e totalização. Conforme observado, você pode restringir valores que se tornam parte desses grupos usando um Where cláusula em consultas antes que a agregação seja executada. Você pode filtrar linhas de resultados agrupados (após a agregação) usando o Having cláusula nas consultas SQL.