Introduction au regroupement et au total SQL

L'un des aspects les plus puissants de SQL est la possibilité d'effectuer une agrégation de données. Deux des outils d'agrégation de données SQL les plus puissants sont le regroupement et totalisant . Dans ce guide, vous apprendrez l'agrégation de données SQL à l'aide du regroupement et de la totalisation.

Fonctions d'agrégation SQL

En SQL, l'agrégation est le processus d'exploitation ou de calcul d'un ensemble de valeurs. L'intention est de renvoyer une seule valeur récapitulative. SQL inclut plusieurs fonctions d'agrégation très puissantes telles que AVG() , COUNT() , SUM() , MAX() , et MIN() . Ces fonctions, à leur tour, se trouvent le plus souvent dans des instructions SQL qui implémentent un GROUP BY clause. Cependant, ces fonctions n'ont pas besoin d'être associées à cette clause.

Remarque Sauf mention contraire, toutes les commandes de base de données présentées dans ce guide fonctionnent bien sur MySQL et PostgreSQL .

Ce guide utilise un CourseTaken tableau pour illustrer les fonctions d'agrégation. Depuis la ligne de commande, créez le CourseTaken tableau.

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

Le CourseTaken table contient les données de colonne suivantes :

Utiliser une fonction d'agrégation SQL pour calculer une valeur récapitulative unique

Les sections ci-dessous fournissent différents exemples qui utilisent des fonctions d'agrégation pour renvoyer une seule valeur récapitulative. Tous les exemples utilisent le CourseTaken tableau qui a été créé dans la section Fonctions d'agrégation du guide.

Exemple 1 :

Dans cet exemple, la fonction d'agrégation renvoie une note moyenne numérique pour tous les étudiants qui suivent le cours CSC101 en 2022.

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

SQL renvoie la note moyenne suivante :

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

Exemple 2 :

La fonction d'agrégation ci-dessous renvoie le nombre d'étudiants qui ont suivi le cours CSC101 avant l'année 2022.

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

Le décompte suivant est renvoyé :

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

Exemple 3 :

Dans cet exemple, une fonction d'agrégation est utilisée pour obtenir la note numérique maximale enregistrée au cours d'une année par un étudiant suivant CSC101 .

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

La note maximale renvoyée est la suivante :

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

Agréger des données à l'aide de fonctions de groupe

Les exemples suivants illustrent l'utilisation du GROUP BY clause utilisant les données du CourseTaken tableau.

Exemple 1 :

L'exemple ci-dessous détermine la note moyenne de chaque étudiant pour tous les cours qu'il a suivis à ce jour. Pour l'exécuter, utilisez le SQL Group By clause pour regrouper par Étudiant (dans ce cas, le SSNumber colonne).

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

La sortie renvoie la note moyenne de chaque étudiant.

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

Exemple 2 :

La fonction d'agrégation ci-dessous trouve la note moyenne reçue pour chaque CourseId dans le CourseTaken table. Pour ce faire, regroupez par CourseId dans YearTaken avec le code SQL suivant :

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

Vous devriez voir le résultat suivant :

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

Remarque L'exemple ci-dessus est légèrement plus complexe. Vous groupez par deux colonnes au lieu d'une (CourseId dans Year ). Par conséquent, vous calculez la note moyenne et le groupe par CSC101 pour l'année 2021 séparément de la note moyenne pour CSC101 pour l'année 2022 . Le cours CSC101 pour l'année 2022 est une agrégation de deux lignes, tandis que toutes les autres lignes Grouper par sont une agrégation d'une ligne. De plus, à partir du concept de commande (Order By clause) vous pouvez afficher les résultats classés (triés) par Course dans une année donnée.

Exemple 3 :

A partir de la requête SQL de l'exemple précédent, vous pouvez restreindre le nombre de lignes que vous exploitez en ajoutant un WHERE clause à la requête. Par exemple, pour générer la note moyenne reçue par les étudiants uniquement pour CourseId CSC101 , grouper par CourseId dans YearTaken . Le code SQL suivant peut accomplir cela :

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

Dans le code SQL ci-dessus, vous ajoutez une condition (via le WHERE clause) avant que l'agrégation de groupe réelle ne soit effectuée (via la clause GROUP BY clause).

La sortie suivante est renvoyée :

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

Exemple 4 :

À partir de la requête SQL de l'exemple 2, vous pouvez appliquer une condition avant que le résultat final ne soit renvoyé. Pour ce faire, utilisez le SQL Having clause. Vous pouvez déterminer la note moyenne sur chaque CourseId , où la note moyenne agrégée est supérieure à 90 . Vous pouvez à nouveau grouper par CourseId dans YearTaken . Le code SQL suivant peut accomplir cela :

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

Le résultat est le suivant :

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

La ligne pour CourseId EEE101 n'a pas été retourné. C'est parce que le Having la clause l'a filtré après le GROUP BY clause a été exécutée (CourseId EEE101 la note moyenne de est inférieure à 90).

Exemple 5 :

S'appuyant sur le code SQL de l'exemple 3 et Exemple 4 , vous pouvez créer des requêtes d'agrégation qui utilisent à la fois Where et Having clause. Par exemple, vous pouvez déterminer les cours qui ont été suivis en 2021 , où la note moyenne des cours suivis était supérieure à 93 . Ici, le Where la clause filtre les résultats avant le Group By l'agrégation des données est effectuée, et le Having la clause filtre les résultats renvoyés après le Group By l'agrégation des données est effectuée. Le code SQL suivant peut accomplir cela :

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

Le résultat renvoyé est le suivant :

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

Exemple 6 :

Vous pouvez compter le nombre de lignes associées à chaque Group By agrégation dans une requête. En vous basant sur l'exemple de code SQL précédent, vous pouvez générer la note moyenne reçue par les Students pour CourseId uniquement CSC101 , regroupés par CourseId dans YearTaken . Le code doit indiquer le nombre d'élèves (nombre) associés à chaque groupe. Le code SQL suivant peut accomplir cela :

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

Le Count(SSNumber) dans le SELECT la clause aurait pu être spécifiée sous la forme Count(*) . La différence entre les deux syntaxes est que Count(*) inclut les lignes qui ont NULL valeurs en eux aussi. Selon le CourseTaken définition de table ci-dessus, toutes les colonnes dans le CourseTaken table doit contenir des valeurs non nulles (le NOT NULL attribut le garantit). Le Count(SSNumber) et Count(*) serait fonctionnellement équivalent dans cet exemple.

La sortie suivante est renvoyée :

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

Conclusion

Ce guide fournit les éléments de base des puissantes opérations d'agrégation de données de SQL pour le regroupement et le total. Comme indiqué, vous pouvez restreindre les valeurs qui font partie de ces groupes en utilisant un Where clause dans les requêtes avant que l'agrégation ne soit effectuée. Vous pouvez filtrer les lignes de résultats groupés (après l'agrégation) en utilisant le Having clause dans les requêtes SQL.