Introduktion till SQL-gruppering och sammanräkning

En av de mest kraftfulla aspekterna av SQL är förmågan att utföra dataaggregering. Två av de mest kraftfulla verktygen för SQL-dataaggregering är gruppering och totalt . I den här guiden lär du dig SQL-dataaggregering med hjälp av gruppering och summering.

SQL-aggregatfunktioner

I SQL är aggregering processen att driva eller beräkna en uppsättning värden. Avsikten är att returnera ett enda sammanfattande värde. SQL innehåller flera mycket kraftfulla aggregerade funktioner såsom AVG() , COUNT() , SUM() , MAX() och MIN() . Dessa funktioner i sin tur finns oftast i SQL-satser som implementerar en GROUP BY klausul. Dessa funktioner behöver dock inte vara associerade med den klausulen.

Obs Om inget annat nämns fungerar alla databaskommandon som visas i den här guiden bra på både MySQL och PostgreSQL .

Den här guiden använder en CourseTaken tabell för att visa aggregerade funktioner. Skapa CourseTaken från kommandoraden bord.

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

CourseTaken Tabellen innehåller följande kolumndata:

Använd en SQL-aggregatfunktion för att beräkna ett enda sammanfattningsvärde

Avsnitten nedan ger olika exempel som använder aggregerade funktioner för att returnera ett enda sammanfattningsvärde. Alla exempel använder CourseTaken tabell som skapades i avsnittet Aggregatfunktioner i guiden.

Exempel 1:

I det här exemplet returnerar aggregatfunktionen ett numeriskt medelbetyg för alla elever som går kursen CSC101 år 2022.

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

SQL returnerar följande medelbetyg:

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

Exempel 2:

Den aggregerade funktionen nedan returnerar en räkning av antalet studenter som tog kursen CSC101 före år 2022.

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

Följande räkning returneras:

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

Exempel 3:

I det här exemplet används en aggregatfunktion för att erhålla det maximala numeriska betyget som registrerats under ett år av en student som tar CSC101 .

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

Det returnerade högsta betyget är följande:

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

Aggregera data med hjälp av gruppfunktioner

Följande exempel visar användningen av GROUP BY sats med hjälp av data från CourseTaken bord.

Exempel 1:

Exemplet nedan bestämmer medelbetyget för varje elev för alla kurser som de har läst hittills. För att utföra detta, använd SQL Group By sats att gruppera efter Student (i detta fall SSNumber kolumn).

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

Resultatet returnerar medelbetyget för varje elev.

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

Exempel 2:

Den aggregerade funktionen nedan hittar det genomsnittliga betyget för varje CourseId i CourseTaken tabell. För att göra detta, gruppera efter CourseId inom YearTaken med följande SQL-kod:

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

Du bör se följande utdata:

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

Obs Exemplet ovan är något mer komplext. Du grupperar efter två kolumner istället för en (CourseId inom Year ). Därför beräknar du medelbetyget och gruppen med CSC101 för året 2021 separat från medelbetyget för CSC101 för året 2022 . Kursen CSC101 för år 2022 är en aggregering av två rader, medan alla andra Group By-rader är en aggregering av en rad. Dessutom från konceptet Beställning (Order By klausul) kan du visa ordnade resultat (sorterade) efter Course inom ett givet år.

Exempel 3:

Från SQL-frågan i föregående exempel kan du begränsa antalet rader som du använder genom att lägga till en WHERE klausul till frågan. Till exempel för att generera det genomsnittliga betyget som eleverna får endast för CourseId CSC101 , gruppera efter CourseId inom YearTaken . Följande SQL-kod kan åstadkomma detta:

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

I ovanstående SQL-kod lägger du till ett villkor (via WHERE klausul) innan den faktiska gruppaggregationen utförs (via GROUP BY klausul).

Följande utdata returneras:

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

Exempel 4:

Från SQL-frågan i exempel 2 kan du tillämpa ett villkor innan det slutliga resultatet returneras. För att åstadkomma detta använd SQL Having klausul. Du kan bestämma medelbetyget för varje CourseId , där det aggregerade medelbetyget är högre än 90 . Du kan återigen gruppera efter CourseId inom YearTaken . Följande SQL-kod kan åstadkomma detta:

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

Utdata är följande:

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

Raden för CourseId EEE101 returnerades inte. Detta beror på att Having klausulen filtrerade bort den efter GROUP BY klausul kördes (CourseId EEE101 medelbetyget är under 90).

Exempel 5:

Bygger på SQL-koden från Exempel 3 och Exempel 4 , kan du skapa aggregeringsfrågor som använder både Where och Having klausul. Du kan till exempel bestämma vilka kurser som togs i 2021 , där medelbetyget för de kurser som togs var högre än 93 . Här, Where klausulen filtrerar bort resultat före Group By dataaggregering utförs och Having klausulen filtrerar bort resultat som returneras efter Group By dataaggregation utförs. Följande SQL-kod kan åstadkomma detta:

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

Utdata som returneras är följande:

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

Exempel 6:

Du kan räkna antalet rader som är associerade med varje Group By aggregering i en fråga. Med utgångspunkt i föregående exempel på SQL-koden kan du generera medelbetyget som Students fått endast för CourseId CSC101 , grupperad efter CourseId inom YearTaken . Koden ska ange antalet elever (antal) som är associerade med varje grupp. Följande SQL-kod kan åstadkomma detta:

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

Count(SSNumber) i SELECT klausul kunde ha specificerats som Count(*) . Skillnaden mellan de två syntaxerna är att Count(*) inkluderar rader som har NULL värden i dem också. Enligt CourseTaken tabelldefinitionen ovan, alla kolumner i CourseTaken Tabellen måste innehålla icke-nullvärden (NOT NULL attribut garanterar detta). Count(SSNumber) och Count(*) skulle vara funktionellt likvärdig i detta exempel.

Följande utdata returneras:

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

Slutsats

Den här guiden tillhandahåller byggstenarna för SQLs kraftfulla dataaggregering för gruppering och summering. Som nämnts kan du begränsa värden som blir en del av dessa grupper genom att använda en Where klausul i frågor innan aggregeringen utförs. Du kan filtrera bort rader med grupperade resultat (efter att aggregeringen har utförts) genom att använda Having sats i SQL-frågorna.