Einführung in die Gruppierung und Summenbildung in SQL

Einer der leistungsstärksten Aspekte von SQL ist die Fähigkeit zur Datenaggregation. Zwei der leistungsstärksten Tools zur Aggregation von SQL-Daten sind die Gruppierung und Summen . In diesem Handbuch lernen Sie die SQL-Datenaggregation mithilfe von Gruppierung und Summierung kennen.

SQL-Aggregatfunktionen

In SQL ist die Aggregation der Prozess der Verarbeitung oder Berechnung einer Reihe von Werten. Die Absicht besteht darin, einen einzelnen Zusammenfassungswert zurückzugeben. SQL enthält mehrere sehr leistungsfähige Aggregatfunktionen wie AVG() , COUNT() , SUM() , MAX() , und MIN() . Diese Funktionen wiederum finden sich am häufigsten in SQL-Anweisungen, die ein GROUP BY implementieren Klausel. Diese Funktionen müssen jedoch nicht mit dieser Klausel verknüpft werden.

Hinweis Sofern nicht anders erwähnt, funktionieren alle Datenbankbefehle, die in diesem Handbuch gezeigt werden, sowohl auf MySQL als auch gut und PostgreSQL .

Dieser Leitfaden verwendet einen CourseTaken Tabelle zur Demonstration von Aggregatfunktionen. Erstellen Sie über die Befehlszeile den CourseTaken Tabelle.

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

Der CourseTaken Tabelle enthält die folgenden Spaltendaten:

Verwenden Sie eine SQL-Aggregatfunktion, um einen einzelnen Zusammenfassungswert zu berechnen

Die folgenden Abschnitte enthalten verschiedene Beispiele, die Aggregatfunktionen verwenden, um einen einzelnen Zusammenfassungswert zurückzugeben. Alle Beispiele verwenden den CourseTaken Tabelle, die im Abschnitt Aggregatfunktionen des Handbuchs erstellt wurde.

Beispiel 1:

In diesem Beispiel gibt die Aggregatfunktion eine numerische Durchschnittsnote für alle Studenten zurück, die den Kurs CSC101 belegen im Jahr 2022.

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

SQL gibt die folgende Durchschnittsnote zurück:

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

Beispiel 2:

Die folgende Aggregatfunktion gibt die Anzahl der Schüler zurück, die den Kurs CSC101 belegt haben vor dem Jahr 2022.

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

Die folgende Anzahl wird zurückgegeben:

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

Beispiel 3:

In diesem Beispiel wird eine Aggregatfunktion verwendet, um die maximale numerische Note zu erhalten, die in einem beliebigen Jahr von einem Schüler aufgezeichnet wurde, der CSC101 belegt .

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

Die zurückgegebene Höchstnote lautet wie folgt:

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

Aggregieren Sie Daten mithilfe von Gruppenfunktionen

Die folgenden Beispiele demonstrieren die Verwendung von GROUP BY -Klausel unter Verwendung der Daten aus CourseTaken Tabelle.

Beispiel 1:

Das folgende Beispiel ermittelt die Durchschnittsnote für jeden Studenten für alle Kurse, die er bisher besucht hat. Um dies auszuführen, verwenden Sie die SQL Group By Klausel zum Gruppieren nach Student (in diesem Fall die SSNumber Spalte).

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

Die Ausgabe gibt die Durchschnittsnote für jeden Schüler zurück.

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

Beispiel 2:

Die Aggregatfunktion unten findet die durchschnittliche Note, die für jede CourseId erhalten wurde im CourseTaken Tisch. Gruppieren Sie dazu nach CourseId innerhalb von YearTaken mit folgendem SQL-Code:

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

Sie sollten die folgende Ausgabe sehen:

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

Hinweis Das obige Beispiel ist etwas komplexer. Sie gruppieren nach zwei Spalten statt nach einer (CourseId innerhalb von Year ). Daher berechnen Sie die Durchschnittsnote und gruppieren nach CSC101 für das Jahr 2021 getrennt von der Durchschnittsnote für CSC101 für das Jahr 2022 . Der Kurs CSC101 für das Jahr 2022 ist eine Aggregation von zwei Zeilen, während alle anderen Group By-Zeilen eine Aggregation von einer Zeile sind. Zusätzlich aus dem Konzept der Bestellung (Order By -Klausel) können Sie die Ergebnisse (sortiert) nach Course anzeigen innerhalb eines bestimmten Jahres.

Beispiel 3:

Ausgehend von der SQL-Abfrage im vorherigen Beispiel können Sie die Anzahl der Zeilen einschränken, die Sie bearbeiten, indem Sie ein WHERE hinzufügen Klausel zur Abfrage. Zum Beispiel, um die Durchschnittsnote der Schüler nur für CourseId zu generieren CSC101 , nach CourseId gruppieren innerhalb von YearTaken . Der folgende SQL-Code kann dies erreichen:

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

Im obigen SQL-Code fügen Sie eine Bedingung hinzu (über die WHERE -Klausel), bevor die eigentliche Gruppenaggregation durchgeführt wird (über die GROUP BY Klausel).

Die folgende Ausgabe wird zurückgegeben:

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

Beispiel 4:

Von der SQL-Abfrage in Beispiel 2 aus können Sie eine Bedingung anwenden, bevor das Endergebnis zurückgegeben wird. Um dies zu erreichen, verwenden Sie den SQL Having Klausel. Sie können die Durchschnittsnote über jede CourseId ermitteln , wobei die aggregierte Durchschnittsnote größer als 90 ist . Sie können wieder nach CourseId gruppieren innerhalb von YearTaken . Der folgende SQL-Code kann dies erreichen:

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

Die Ausgabe ist die folgende:

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

Die Zeile für CourseId EEE101 wurde nicht zurückgegeben. Das liegt daran, dass das Having -Klausel hat es nach dem GROUP BY herausgefiltert Klausel ausgeführt wurde (CourseId EEE101 Die Durchschnittsnote von liegt unter 90).

Beispiel 5:

Aufbauend auf dem SQL-Code aus Beispiel 3 und Beispiel 4 können Sie Aggregationsabfragen erstellen, die sowohl Where verwenden und Having Klausel. Beispielsweise können Sie die Kurse ermitteln, die im 2021 absolviert wurden , wobei die Durchschnittsnote für die besuchten Kurse größer als 93 war . Hier das Where -Klausel filtert Ergebnisse vor Group By heraus Datenaggregation durchgeführt wird, und das Having -Klausel filtert Ergebnisse heraus, die nach Group By zurückgegeben werden Datenaggregation durchgeführt wird. Der folgende SQL-Code kann dies erreichen:

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

Die zurückgegebene Ausgabe ist die folgende:

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

Beispiel 6:

Sie können die Anzahl der Zeilen zählen, die jedem Group By zugeordnet sind Aggregation in einer Abfrage. Aufbauend auf dem vorherigen Beispiel-SQL-Code können Sie die von Students erhaltene Durchschnittsnote generieren nur für CourseId CSC101 , gruppiert nach CourseId innerhalb von YearTaken . Der Code sollte die Anzahl der Schüler (Anzahl) angeben, die jeder Gruppe zugeordnet sind. Der folgende SQL-Code kann dies erreichen:

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

Der Count(SSNumber) im SELECT -Klausel hätte als Count(*) angegeben werden können . Der Unterschied zwischen den beiden Syntaxen besteht darin, dass Count(*) enthält Zeilen mit NULL auch Werte darin. Gemäß CourseTaken Tabellendefinition oben, alle Spalten im CourseTaken Tabelle muss Nicht-Null-Werte enthalten (die NOT NULL Attribut stellt dies sicher). Der Count(SSNumber) und Count(*) wäre in diesem Beispiel funktional äquivalent.

Die folgende Ausgabe wird zurückgegeben:

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

Schlussfolgerung

Dieses Handbuch enthält die Bausteine ​​für die leistungsstarken Datenaggregationsvorgänge von SQL zum Gruppieren und Summieren. Wie bereits erwähnt, können Sie Werte einschränken, die Teil dieser Gruppen werden, indem Sie ein Where verwenden -Klausel in Abfragen, bevor die Aggregation durchgeführt wird. Sie können Zeilen gruppierter Ergebnisse herausfiltern (nachdem die Aggregation durchgeführt wurde), indem Sie Having verwenden -Klausel in den SQL-Abfragen.