Inleiding tot SQL-groepering en totalen

Een van de krachtigste aspecten van SQL is de mogelijkheid om gegevens samen te voegen. Twee van de krachtigste tools voor het samenvoegen van SQL-gegevens zijn groeperen en totaal . In deze handleiding leert u SQL-gegevensaggregatie met behulp van groeperen en optellen.

SQL-aggregaatfuncties

In SQL is aggregatie het proces van het uitvoeren of berekenen van een reeks waarden. Het is de bedoeling om één samenvattingswaarde te retourneren. SQL bevat verschillende zeer krachtige aggregatiefuncties zoals AVG() , COUNT() , SUM() , MAX() , en MIN() . Deze functies worden op hun beurt het vaakst aangetroffen in SQL-instructies die een GROUP BY . implementeren clausule. Deze functies hoeven echter niet aan die clausule te worden gekoppeld.

Opmerking Tenzij anders vermeld, werken alle databasecommando's die in deze handleiding worden gedemonstreerd goed op zowel MySQL en PostgreSQL .

Deze handleiding gebruikt een CourseTaken tabel om geaggregeerde functies te demonstreren. Maak vanaf de opdrachtregel de CourseTaken tafel.

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

De CourseTaken tabel bevat de volgende kolomgegevens:

Een SQL-aggregaatfunctie gebruiken om een ​​enkele samenvattingswaarde te berekenen

In de onderstaande secties worden verschillende voorbeelden gegeven die statistische functies gebruiken om één samenvattingswaarde te retourneren. Alle voorbeelden gebruiken de CourseTaken tabel die is gemaakt in het gedeelte Samengestelde functies van de handleiding.

Voorbeeld 1:

In dit voorbeeld retourneert de aggregatiefunctie een numeriek gemiddeld cijfer voor alle studenten die de cursus CSC101 volgen in het jaar 2022.

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

SQL geeft het volgende gemiddelde cijfer:

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

Voorbeeld 2:

De aggregatiefunctie hieronder retourneert een telling van het aantal studenten dat cursus CSC101 heeft gevolgd vóór het jaar 2022.

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

De volgende telling wordt geretourneerd:

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

Voorbeeld 3:

In dit voorbeeld wordt een aggregatiefunctie gebruikt om het maximale numerieke cijfer te verkrijgen dat in een jaar is geregistreerd door een student die CSC101 volgt. .

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

Het geretourneerde maximale cijfer is het volgende:

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

Gegevens samenvoegen met behulp van groepsfuncties

De volgende voorbeelden demonstreren het gebruik van de GROUP BY clausule met behulp van de gegevens van de CourseTaken tafel.

Voorbeeld 1:

Het onderstaande voorbeeld bepaalt het gemiddelde cijfer voor elke student voor alle cursussen die ze tot nu toe hebben gevolgd. Om dit uit te voeren, gebruikt u de SQL Group By clausule om te groeperen op student (in dit geval de SSNumber kolom).

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

De uitvoer levert het gemiddelde cijfer voor elke leerling op.

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

Voorbeeld 2:

De aggregatiefunctie hieronder vindt het gemiddelde cijfer dat is behaald voor elke CourseId in de CourseTaken tafel. Om dit te doen, groepeert u op CourseId binnen YearTaken met de volgende SQL-code:

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

U zou de volgende uitvoer moeten zien:

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

Opmerking Bovenstaand voorbeeld is iets ingewikkelder. U groepeert op twee kolommen in plaats van één (CourseId binnen Year ). Daarom bereken je het gemiddelde cijfer en de groep met CSC101 voor het jaar 2021 los van het gemiddelde cijfer voor CSC101 voor het jaar 2022 . De cursus CSC101 voor jaar 2022 is een aggregatie van twee rijen, terwijl alle andere Group By-rijen een aggregatie van één rij zijn. Bovendien, vanuit het concept van Bestellen (Order By clausule) kunt u geordende resultaten weergeven (gesorteerd) op Course binnen een bepaald jaar.

Voorbeeld 3:

Met de SQL-query in het vorige voorbeeld kunt u het aantal rijen dat u gebruikt beperken door een WHERE toe te voegen. clausule bij de vraag. Om bijvoorbeeld het gemiddelde cijfer te genereren dat studenten alleen ontvangen voor CourseId CSC101 , groeperen op CourseId binnen YearTaken . De volgende SQL-code kan dit bereiken:

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

In de bovenstaande SQL-code voegt u een voorwaarde toe (via de WHERE clausule) voordat de feitelijke groepsaggregatie wordt uitgevoerd (via de GROUP BY clausule).

De volgende uitvoer wordt geretourneerd:

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

Voorbeeld 4:

Vanuit de SQL-query in Voorbeeld 2 kunt u een voorwaarde toepassen voordat het uiteindelijke resultaat wordt geretourneerd. Gebruik hiervoor de SQL Having clausule. Je kunt het gemiddelde cijfer bepalen voor elke CourseId , waarbij het geaggregeerde gemiddelde cijfer groter is dan 90 . U kunt opnieuw groeperen op CourseId binnen YearTaken . De volgende SQL-code kan dit bereiken:

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

De output is de volgende:

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

De rij voor CourseId EEE101 werd niet teruggestuurd. Dit komt omdat de Having clausule filterde het uit na de GROUP BY clausule is uitgevoerd (CourseId EEE101 s gemiddelde cijfer is lager dan 90).

Voorbeeld 5:

Voortbouwend op de SQL-code uit Voorbeeld 3 en Voorbeeld 4 , kunt u aggregatiequery's maken die zowel de Where en Having clausule. U kunt bijvoorbeeld bepalen welke cursussen zijn gevolgd in 2021 , waarbij het gemiddelde cijfer voor de gevolgde cursussen hoger was dan 93 . Hier, de Where clausule filtert resultaten uit vóór de Group By gegevensaggregatie wordt uitgevoerd en de Having clausule filtert resultaten uit die worden geretourneerd na de Group By gegevensaggregatie wordt uitgevoerd. De volgende SQL-code kan dit bereiken:

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

De geretourneerde uitvoer is de volgende:

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

Voorbeeld 6:

U kunt het aantal rijen tellen dat is gekoppeld aan elke Group By aggregatie in een query. Voortbouwend op de vorige voorbeeld-SQL-code, kunt u het gemiddelde cijfer genereren dat door Students wordt ontvangen voor alleen CourseId CSC101 , gegroepeerd op CourseId binnen YearTaken . De code moet het aantal studenten (aantal) dat bij elke groep hoort, aangeven. De volgende SQL-code kan dit bereiken:

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

De Count(SSNumber) in de SELECT clausule had kunnen worden opgegeven als Count(*) . Het verschil tussen de twee syntaxis is dat Count(*) bevat rijen met NULL daarin ook waarden. Volgens de CourseTaken tabeldefinitie hierboven, alle kolommen in de CourseTaken tabel moet niet-null-waarden bevatten (de NOT NULL attribuut verzekert dit). De Count(SSNumber) en Count(*) zou in dit voorbeeld functioneel equivalent zijn.

De volgende uitvoer wordt geretourneerd:

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

Conclusie

Deze handleiding biedt de bouwstenen voor de krachtige gegevensaggregatiebewerkingen van SQL voor groeperen en optellen. Zoals opgemerkt, kunt u waarden die onderdeel worden van deze groepen beperken door een Where . te gebruiken clausule in query's voordat de aggregatie wordt uitgevoerd. U kunt rijen met gegroepeerde resultaten uitfilteren (nadat de aggregatie is uitgevoerd) met behulp van de Having clausule in de SQL-query's.