Introduzione al raggruppamento e alla totalizzazione SQL

Uno degli aspetti più potenti di SQL è la capacità di eseguire l'aggregazione dei dati. Due dei più potenti strumenti di aggregazione dei dati SQL sono il raggruppamento e totale . In questa guida imparerai l'aggregazione dei dati SQL utilizzando il raggruppamento e il totale.

Funzioni di aggregazione SQL

In SQL, l'aggregazione è il processo di funzionamento o calcolo di un insieme di valori. L'intento è restituire un unico valore di riepilogo. SQL include diverse funzioni di aggregazione molto potenti come AVG() , COUNT() , SUM() , MAX() e MIN() . Queste funzioni, a loro volta, si trovano più spesso nelle istruzioni SQL che implementano un GROUP BY clausola. Tuttavia, queste funzioni non devono essere associate a tale clausola.

Nota Salvo diversa indicazione, tutti i comandi del database illustrati in questa guida funzionano bene su entrambi MySQL e PostgreSQL .

Questa guida utilizza un CourseTaken tabella per dimostrare le funzioni aggregate. Dalla riga di comando, crea il CourseTaken tabella.

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

Il CourseTaken la tabella contiene i seguenti dati di colonna:

Utilizzare una funzione di aggregazione SQL per calcolare un singolo valore di riepilogo

Le sezioni seguenti forniscono diversi esempi che utilizzano funzioni di aggregazione per restituire un unico valore di riepilogo. Tutti gli esempi utilizzano il CourseTaken tabella creata nella sezione Funzioni di aggregazione della guida.

Esempio 1:

In questo esempio, la funzione di aggregazione restituisce un voto medio numerico per tutti gli studenti che seguono il corso CSC101 nell'anno 2022.

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

SQL restituisce il seguente voto medio:

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

Esempio 2:

La funzione di aggregazione seguente restituisce un conteggio del numero di studenti che hanno frequentato il corso CSC101 prima dell'anno 2022.

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

Viene restituito il seguente conteggio:

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

Esempio 3:

In questo esempio, viene utilizzata una funzione aggregata per ottenere il voto numerico massimo registrato in un qualsiasi anno da uno Studente che prende CSC101 .

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

Il voto massimo restituito è il seguente:

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

Aggrega i dati utilizzando le funzioni di gruppo

Gli esempi seguenti dimostrano l'uso di GROUP BY clausola che utilizza i dati del CourseTaken tabella.

Esempio 1:

L'esempio seguente determina il voto medio di ogni studente per tutti i corsi che ha seguito fino ad oggi. Per eseguire questa operazione, utilizzare l'SQL Group By clausola da raggruppare per Studente (in questo caso, il SSNumber colonna).

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

L'output restituisce il voto medio di ogni studente.

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

Esempio 2:

La funzione aggregata di seguito trova il voto medio ricevuto su ogni CourseId nel CourseTaken tavolo. Per fare ciò, raggruppa per CourseId entro YearTaken con il seguente codice SQL:

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

Dovresti vedere il seguente output:

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

Nota L'esempio sopra è leggermente più complesso. Raggruppi per due colonne invece di una (CourseId entro Year ). Quindi, calcoli il voto medio e raggruppi per CSC101 per l'anno 2021 separatamente dal voto medio per CSC101 per l'anno 2022 . Il corso CSC101 per l'anno 2022 è un'aggregazione di due righe, mentre tutte le altre righe Raggruppa per sono un'aggregazione di una riga. Inoltre, dal concetto di Ordine (Order By clausola) puoi visualizzare i risultati ordinati (ordinati) per Course entro un determinato anno.

Esempio 3:

Dalla query SQL nell'esempio precedente, puoi limitare il numero di righe che operi aggiungendo un WHERE clausola alla query. Ad esempio, per generare il voto medio ricevuto dagli studenti solo per CourseId CSC101 , raggruppa per CourseId entro YearTaken . Il seguente codice SQL può eseguire questa operazione:

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

Nel codice SQL sopra, stai aggiungendo una condizione (tramite il WHERE clausola) prima che venga eseguita l'effettiva aggregazione del gruppo (tramite il GROUP BY clausola).

Viene restituito il seguente output:

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

Esempio 4:

Dalla query SQL nell'esempio 2, puoi applicare una condizione prima che venga restituito il risultato finale. Per fare ciò, usa l'SQL Having clausola. Puoi determinare il voto medio per ogni CourseId , dove il voto medio aggregato è maggiore di 90 . Puoi nuovamente raggruppare per CourseId entro YearTaken . Il seguente codice SQL può eseguire questa operazione:

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

L'output è il seguente:

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

La riga per CourseId EEE101 non è stato restituito. Questo perché Having la clausola l'ha filtrata dopo il GROUP BY la clausola è stata eseguita (CourseId EEE101 il voto medio di è inferiore a 90).

Esempio 5:

Basandosi sul codice SQL dell'Esempio 3 e Esempio 4 , puoi creare query di aggregazione che utilizzano sia il Where e Having clausola. Ad esempio, puoi determinare i corsi che sono stati seguiti nel 2021 , dove il voto medio per quei corsi seguiti era superiore a 93 . Qui, il Where La clausola filtra i risultati prima del Group By viene eseguita l'aggregazione dei dati e Having La clausola filtra i risultati restituiti dopo il Group By viene eseguita l'aggregazione dei dati. Il seguente codice SQL può eseguire questa operazione:

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

L'output restituito è il seguente:

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

Esempio 6:

Puoi contare il numero di righe associate a ciascun Group By aggregazione in una query. Basandosi sul codice SQL di esempio precedente, puoi generare il voto medio ricevuto da Students solo per CourseId CSC101 , raggruppati per CourseId entro YearTaken . Il codice dovrebbe fornire il numero di studenti (conteggio) associati a ciascun gruppo. Il seguente codice SQL può eseguire questa operazione:

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

Il Count(SSNumber) nel SELECT la clausola avrebbe potuto essere specificata come Count(*) . La differenza tra le due sintassi è che Count(*) include le righe che hanno NULL valori anche in loro. Come per il CourseTaken definizione della tabella sopra, tutte le colonne nel CourseTaken la tabella deve contenere valori non null (il NOT NULL l'attributo lo assicura). Il Count(SSNumber) e Count(*) sarebbe funzionalmente equivalente in questo esempio.

Viene restituito il seguente output:

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

Conclusione

Questa guida fornisce gli elementi costitutivi per le potenti operazioni di aggregazione dei dati di SQL per il raggruppamento e il totale. Come notato, puoi limitare i valori che diventano parte di questi gruppi utilizzando un Where clausola nelle query prima che venga eseguita l'aggregazione. Puoi filtrare le righe di risultati raggruppati (dopo aver eseguito l'aggregazione) utilizzando Having clausola nelle query SQL.