Introducción a la agrupación y el total de SQL

Uno de los aspectos más poderosos de SQL es la capacidad de realizar la agregación de datos. Dos de las herramientas de agregación de datos SQL más poderosas son agrupación y totalizando . En esta guía, aprenderá la agregación de datos SQL mediante la agrupación y el total.

Funciones agregadas de SQL

En SQL, la agregación es el proceso de operar o calcular un conjunto de valores. La intención es devolver un único valor de resumen. SQL incluye varias funciones agregadas muy potentes, como AVG() , COUNT() , SUM() , MAX() y MIN() . Estas funciones, a su vez, se encuentran con mayor frecuencia en sentencias SQL que implementan un GROUP BY cláusula. Sin embargo, estas funciones no necesitan estar asociadas con esa cláusula.

Nota A menos que se indique lo contrario, todos los comandos de base de datos que se muestran en esta guía funcionan bien tanto en MySQL y PostgreSQL .

Esta guía utiliza un CourseTaken tabla para demostrar funciones agregadas. Desde la línea de comando, cree el CourseTaken mesa.

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

El CourseTaken la tabla contiene los siguientes datos de columna:

Usar una función agregada de SQL para calcular un valor de resumen único

Las secciones a continuación proporcionan diferentes ejemplos que usan funciones agregadas para devolver un único valor de resumen. Todos los ejemplos usan el CourseTaken tabla que se creó en la sección Funciones agregadas de la guía.

Ejemplo 1:

En este ejemplo, la función agregada devuelve una calificación promedio numérica para todos los estudiantes que toman el curso CSC101 en el año 2022.

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

SQL devuelve la siguiente calificación promedio:

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

Ejemplo 2:

La siguiente función agregada devuelve un recuento de la cantidad de estudiantes que tomaron el curso CSC101 antes del año 2022.

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

Se devuelve el siguiente recuento:

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

Ejemplo 3:

En este ejemplo, se usa una función agregada para obtener la calificación numérica máxima registrada en cualquier año por un estudiante que toma CSC101 .

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

La calificación máxima devuelta es la siguiente:

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

Agregar datos usando funciones de grupo

Los siguientes ejemplos demuestran el uso de GROUP BY cláusula usando los datos del CourseTaken mesa.

Ejemplo 1:

El siguiente ejemplo determina la calificación promedio de cada estudiante para todos los cursos que ha tomado hasta la fecha. Para ejecutar esto, use SQL Group By cláusula para agrupar por Estudiante (en este caso, el SSNumber columna).

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

La salida devuelve la calificación promedio de cada estudiante.

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

Ejemplo 2:

La siguiente función agregada encuentra la calificación promedio recibida en cada CourseId en el CourseTaken mesa. Para hacer esto, agrupe por CourseId dentro de YearTaken con el siguiente 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

Debería ver el siguiente resultado:

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

Nota El ejemplo anterior es un poco más complejo. Agrupa por dos columnas en lugar de una (CourseId dentro del Year ). Por lo tanto, calcula la calificación promedio y agrupa por CSC101 para el año 2021 por separado de la calificación promedio para CSC101 para el año 2022 . El curso CSC101 para el año 2022 es una agregación de dos filas, mientras que todas las demás filas Agrupar por son una agregación de una fila. Además, desde el concepto de Pedido (Order By cláusula) puede mostrar resultados ordenados (ordenados) por Course dentro de un año dado.

Ejemplo 3:

A partir de la consulta SQL del ejemplo anterior, puede restringir la cantidad de filas que opera agregando un WHERE cláusula a la consulta. Por ejemplo, para generar la calificación promedio recibida por los estudiantes solo para CourseId CSC101 , agrupar por CourseId dentro de YearTaken . El siguiente código SQL puede lograr esto:

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

En el código SQL anterior, está agregando una condición (a través de WHERE cláusula) antes de que se realice la agregación del grupo real (a través de GROUP BY cláusula).

Se devuelve el siguiente resultado:

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

Ejemplo 4:

A partir de la consulta SQL del Ejemplo 2, puede aplicar una condición antes de que se devuelva el resultado final. Para lograr esto, use SQL Having cláusula. Puede determinar la calificación promedio en cada CourseId , donde la calificación promedio agregada es superior a 90 . Puede volver a agrupar por CourseId dentro de YearTaken . El siguiente código SQL puede lograr esto:

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

La salida es la siguiente:

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

La fila para CourseId EEE101 no fue devuelto. Esto se debe a que Having la cláusula lo filtró después de GROUP BY se ejecutó la cláusula (CourseId EEE101 la calificación promedio de está por debajo de 90).

Ejemplo 5:

Basándose en el código SQL del Ejemplo 3 y Ejemplo 4 , puede crear consultas de agregación que utilicen tanto el Where y Having cláusula. Por ejemplo, puede determinar los cursos que se tomaron en 2021 , donde la calificación promedio de los cursos tomados fue superior a 93 . Aquí, el Where La cláusula filtra los resultados antes de Group By se realiza la agregación de datos, y el Having La cláusula filtra los resultados devueltos después de Group By se realiza la agregación de datos. El siguiente código SQL puede lograr esto:

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

El resultado devuelto es el siguiente:

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

Ejemplo 6:

Puede contar el número de filas asociadas con cada Group By agregación en una consulta. Sobre la base del código SQL de ejemplo anterior, puede generar la calificación promedio recibida por Students solo para CourseId CSC101 , agrupados por CourseId dentro de YearTaken . El código debe proporcionar el número de estudiantes (recuento) asociados con cada grupo. El siguiente código SQL puede lograr esto:

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

El Count(SSNumber) en el SELECT la cláusula podría haberse especificado como Count(*) . La diferencia entre las dos sintaxis es que Count(*) incluye filas que tienen NULL valores en ellos también. Según el CourseTaken definición de la tabla anterior, todas las columnas en el CourseTaken la tabla debe contener valores no nulos (el NOT NULL atributo lo asegura). El Count(SSNumber) y Count(*) sería funcionalmente equivalente en este ejemplo.

Se devuelve el siguiente resultado:

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

Conclusión

Esta guía proporciona los componentes básicos para las potentes operaciones de agregación de datos de SQL para agrupar y totalizar. Como se indicó, puede restringir los valores que pasan a formar parte de estos grupos utilizando un Where cláusula en las consultas antes de que se realice la agregación. Puede filtrar filas de resultados agrupados (después de realizar la agregación) usando el Having cláusula en las consultas SQL.