Úvod do SQL Grouping a Totaling

Jedním z nejvýkonnějších aspektů SQL je schopnost provádět agregaci dat. Dva z nejvýkonnějších nástrojů pro agregaci dat SQL jsou seskupování a celkem . V této příručce se naučíte agregaci dat SQL pomocí seskupování a sčítání.

Agregační funkce SQL

V SQL je agregace procesem provozu nebo výpočtu sady hodnot. Záměrem je vrátit jednu souhrnnou hodnotu. SQL obsahuje několik velmi výkonných agregačních funkcí, jako je AVG() , COUNT() , SUM() , MAX() a MIN() . Tyto funkce se zase nejčastěji nacházejí v příkazech SQL, které implementují GROUP BY doložka. Tyto funkce však nemusí být spojeny s touto klauzulí.

Poznámka Pokud není uvedeno jinak, všechny databázové příkazy uvedené v této příručce fungují dobře na obou MySQL a PostgreSQL .

Tato příručka používá CourseTaken tabulka pro demonstraci agregačních funkcí. Z příkazového řádku vytvořte CourseTaken tabulka.

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

CourseTaken tabulka obsahuje následující data sloupce:

Použití agregační funkce SQL k výpočtu jedné souhrnné hodnoty

Níže uvedené části poskytují různé příklady, které používají agregační funkce k vrácení jedné souhrnné hodnoty. Všechny příklady používají CourseTaken tabulka, která byla vytvořena v sekci Aggregate Functions v příručce.

Příklad 1:

V tomto příkladu vrací agregační funkce číselné průměrné hodnocení pro všechny studenty, kteří absolvovali kurz CSC101 v roce 2022.

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

SQL vrátí následující průměrnou známku:

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

Příklad 2:

Agregační funkce níže vrací počet studentů, kteří absolvovali kurz CSC101 před rokem 2022.

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

Vrátí se následující počet:

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

Příklad 3:

V tomto příkladu je agregační funkce použita k získání maximálního numerického hodnocení zaznamenaného v kterémkoli roce studentem s CSC101 .

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

Vrácená maximální známka je následující:

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

Agregovat data pomocí skupinových funkcí

Následující příklady demonstrují použití GROUP BY klauzule využívající data z CourseTaken tabulka.

Příklad 1:

Níže uvedený příklad určuje průměrnou známku každého studenta ze všech kurzů, které dosud absolvovali. Chcete-li to provést, použijte SQL Group By klauzule seskupit podle studenta (v tomto případě SSNumber sloupec).

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

Výstup vrátí průměrnou známku pro každého studenta.

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

Příklad 2:

Agregační funkce níže najde průměrnou známku získanou v rámci každého CourseId v CourseTaken stůl. Chcete-li to provést, seskupte podle CourseId v rámci YearTaken s následujícím kódem SQL:

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

Měli byste vidět následující výstup:

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

Poznámka Výše uvedený příklad je o něco složitější. Seskupujete podle dvou sloupců místo jednoho (CourseId do Year ). Průměrnou známku a skupinu tedy vypočítáte podle CSC101 pro rok 2021 odděleně od průměrné známky pro CSC101 pro rok 2022 . Kurz CSC101 pro rok 2022 je agregací dvou řádků, zatímco všechny ostatní řádky Seskupit podle jsou agregací jednoho řádku. Navíc z konceptu Objednávání (Order By klauzule) můžete zobrazit seřazené výsledky (seřazené) podle Course v daném roce.

Příklad 3:

Z dotazu SQL v předchozím příkladu můžete omezit počet řádků, se kterými budete pracovat, přidáním WHERE klauzule k dotazu. Chcete-li například vygenerovat průměrnou známku získanou studenty pouze pro CourseId CSC101 , seskupte podle CourseId v rámci YearTaken . Toho může dosáhnout následující kód SQL:

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

Ve výše uvedeném kódu SQL přidáváte podmínku (přes WHERE klauzule) před provedením skutečné agregace skupiny (prostřednictvím GROUP BY doložka).

Je vrácen následující výstup:

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

Příklad 4:

Z dotazu SQL v příkladu 2 můžete použít podmínku, než se vrátí konečný výsledek. K tomu použijte SQL Having doložka. Můžete určit průměrnou známku pro každé CourseId , kde agregované průměrné hodnocení je větší než 90 . Opět můžete seskupit podle CourseId v rámci YearTaken . Toho může dosáhnout následující kód SQL:

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

Výstup je následující:

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

Řádek pro CourseId EEE101 nebyl vrácen. Je to proto, že Having klauzule jej odfiltrovala za GROUP BY byla provedena klauzule (CourseId EEE101 průměrná známka uživatele je nižší než 90).

Příklad 5:

Na základě kódu SQL z Příkladu 3 a Příklad 4 , můžete vytvořit agregační dotazy, které využívají jak Where a Having doložka. Můžete například určit kurzy, které byly absolvovány v 2021 , kde průměrná známka za tyto absolvované kurzy byla vyšší než 93 . Zde je Where klauzule odfiltruje výsledky před Group By je provedena agregace dat a Having klauzule odfiltruje výsledky vrácené po Group By se provádí agregace dat. Toho může dosáhnout následující kód SQL:

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

Vrácený výstup je následující:

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

Příklad 6:

Můžete spočítat počet řádků spojených s každým Group By agregace v dotazu. Na základě předchozího příkladu kódu SQL můžete vygenerovat průměrnou známku získanou Students pouze pro CourseId CSC101 , seskupené podle CourseId v rámci YearTaken . Kód by měl uvádět počet studentů (počet) přidružených ke každé skupině. Toho může dosáhnout následující kód SQL:

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) v SELECT klauzule mohla být specifikována jako Count(*) . Rozdíl mezi těmito dvěma syntaxemi je v tom, že Count(*) zahrnuje řádky, které mají NULL hodnoty v nich také. Podle CourseTaken definice tabulky výše, všechny sloupce v CourseTaken tabulka musí obsahovat nenulové hodnoty (NOT NULL atribut to zajišťuje). Count(SSNumber) a Count(*) by byl v tomto příkladu funkčně ekvivalentní.

Je vrácen následující výstup:

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

Závěr

Tato příručka poskytuje stavební bloky pro výkonné operace agregace dat SQL pro seskupování a sčítání. Jak bylo uvedeno, můžete omezit hodnoty, které se stanou součástí těchto skupin, pomocí Where klauzule v dotazech před provedením agregace. Řádky seskupených výsledků (po provedení agregace) můžete odfiltrovat pomocí Having klauzule v dotazech SQL.