Allt du behöver veta om SQL GROUP BY -uttalandet

Allt du behöver veta om SQL GROUP BY -uttalandet

Mycket av relationsdatabasernas kraft kommer från att filtrera data och sammanföra tabeller. Det är därför vi representerar dessa relationer i första hand. Men moderna databassystem ger en annan värdefull teknik: gruppering.





Genom gruppering kan du extrahera sammanfattande information från en databas. Det låter dig kombinera resultat för att skapa användbar statistisk data. Gruppering sparar dig från att skriva kod för vanliga fall, till exempel genomsnittslistor med siffror. Och det kan göra för mer effektiva system.



Vad gör GROUP BY -klausulen?

GROUP BY, som namnet antyder, grupperas resultaten till en mindre uppsättning. Resultaten består av en rad för varje distinkt värde för den grupperade kolumnen. Vi kan visa dess användning genom att titta på några exempeldata med rader som delar några gemensamma värden.





vissa nycklar fungerar inte på bärbar dator hp

Följande är en mycket enkel databas med två tabeller som representerar skivalbum. Du kan skapa en sådan databas med skriva ett grundschema för ditt valda databassystem. De album tabellen har nio rader med en primärnyckel id kolumn och kolumner för namn, artist, utgivningsår och försäljning:

+----+---------------------------+-----------+--------------+-------+
| id | name | artist_id | release_year | sales |
+----+---------------------------+-----------+--------------+-------+
| 1 | Abbey Road | 1 | 1969 | 14 |
| 2 | The Dark Side of the Moon | 2 | 1973 | 24 |
| 3 | Rumours | 3 | 1977 | 28 |
| 4 | Nevermind | 4 | 1991 | 17 |
| 5 | Animals | 2 | 1977 | 6 |
| 6 | Goodbye Yellow Brick Road | 5 | 1973 | 8 |
| 7 | 21 | 6 | 2011 | 25 |
| 8 | 25 | 6 | 2015 | 22 |
| 9 | Bat Out of Hell | 7 | 1977 | 28 |
+----+---------------------------+-----------+--------------+-------+

De konstnärer bordet är ännu enklare. Den har sju rader med id- och namnkolumner:



+----+---------------+
| id | name |
+----+---------------+
| 1 | The Beatles |
| 2 | Pink Floyd |
| 3 | Fleetwood Mac |
| 4 | Nirvana |
| 5 | Elton John |
| 6 | Adele |
| 7 | Meat Loaf |
+----+---------------+

Du kan förstå olika aspekter av GROUP BY med bara en enkel datauppsättning som denna. Naturligtvis skulle en verklig datauppsättning ha många, många fler rader, men principerna förblir desamma.

Gruppering efter en enda kolumn

Låt oss säga att vi vill ta reda på hur många album vi har för varje artist. Börja med en typisk VÄLJ fråga för att hämta artist_id -kolumnen:



SELECT artist_id FROM albums

Detta returnerar alla nio rader, som förväntat:

+-----------+
| artist_id |
+-----------+
| 1 |
| 2 |
| 3 |
| 4 |
| 2 |
| 5 |
| 6 |
| 6 |
| 7 |
+-----------+

Lägg till frasen för att gruppera dessa resultat efter artisten GROUP BY artist_id :



SELECT artist_id FROM albums GROUP BY artist_id

Vilket ger följande resultat:

+-----------+
| artist_id |
+-----------+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
+-----------+

Det finns sju rader i resultatuppsättningen, minskade från de totalt nio i album tabell. Var och en unik artist_id har en enda rad. Slutligen, för att få de faktiska räkningarna, lägg till RÄKNA(*) till de valda kolumnerna:

SELECT artist_id, COUNT(*)
FROM albums
GROUP BY artist_id
+-----------+----------+
| artist_id | COUNT(*) |
+-----------+----------+
| 1 | 1 |
| 2 | 2 |
| 3 | 1 |
| 4 | 1 |
| 5 | 1 |
| 6 | 2 |
| 7 | 1 |
+-----------+----------+

Resultaten grupperar två par rader för artisterna med id: er 2 och 6 . Var och en har två album i vår databas.

Relaterad: Essential SQL Commands fuskblad för nybörjare

Så här får du tillgång till grupperade data med en aggregerad funktion

Du kanske har använt RÄKNA fungera tidigare, särskilt i RÄKNA(*) form enligt ovan. Det hämtar antalet resultat i en uppsättning. Du kan använda den för att få det totala antalet poster i en tabell:

SELECT COUNT(*) FROM albums
+----------+
| COUNT(*) |
+----------+
| 9 |
+----------+

COUNT är en aggregerad funktion. Denna term avser funktioner som översätter värden från flera rader till ett enda värde. De används ofta tillsammans med GROUP BY -uttalandet.

I stället för att bara räkna antalet rader kan vi tillämpa en aggregerad funktion på grupperade värden:

SELECT artist_id, SUM(sales)
FROM albums
GROUP BY artist_id
+-----------+------------+
| artist_id | SUM(sales) |
+-----------+------------+
| 1 | 14 |
| 2 | 30 |
| 3 | 28 |
| 4 | 17 |
| 5 | 8 |
| 6 | 47 |
| 7 | 28 |
+-----------+------------+

Den totala försäljningen som visas ovan för artisterna 2 och 6 är deras flera album försäljning tillsammans:

SELECT artist_id, sales
FROM albums
WHERE artist_id IN (2, 6)
+-----------+-------+
| artist_id | sales |
+-----------+-------+
| 2 | 24 |
| 2 | 6 |
| 6 | 25 |
| 6 | 22 |
+-----------+-------+

Gruppera efter flera kolumner

Du kan gruppera med mer än en kolumn. Inkludera bara flera kolumner eller uttryck, åtskilda med kommatecken. Resultaten grupperas enligt kombinationen av dessa kolumner.

SELECT release_year, sales, count(*)
FROM albums
GROUP BY release_year, sales

Detta ger vanligtvis fler resultat än att gruppera efter en enda kolumn:

+--------------+-------+----------+
| release_year | sales | count(*) |
+--------------+-------+----------+
| 1969 | 14 | 1 |
| 1973 | 24 | 1 |
| 1977 | 28 | 2 |
| 1991 | 17 | 1 |
| 1977 | 6 | 1 |
| 1973 | 8 | 1 |
| 2011 | 25 | 1 |
| 2015 | 22 | 1 |
+--------------+-------+----------+

Observera att i vårt lilla exempel har bara två album samma utgivningsår och försäljningsantal (28 1977).

Användbara aggregerade funktioner

Förutom COUNT fungerar flera funktioner bra med GROUP. Varje funktion returnerar ett värde baserat på de poster som tillhör varje resultatgrupp.

  • COUNT () returnerar det totala antalet matchande poster.
  • SUM () returnerar summan av alla värden i den angivna kolumnen.
  • MIN () returnerar det minsta värdet i en given kolumn.
  • MAX () returnerar det största värdet i en given kolumn.
  • AVG () returnerar medelvärdet. Det motsvarar SUM () / COUNT ().

Du kan också använda dessa funktioner utan en GROUP -klausul:

hur man tvingar att stänga en app på windows
SELECT AVG(sales) FROM albums
+------------+
| AVG(sales) |
+------------+
| 19.1111 |
+------------+

Använda GROUP BY med en WHERE -klausul

Precis som med en vanlig SELECT kan du fortfarande använda WHERE för att filtrera resultatuppsättningen:

SELECT artist_id, COUNT(*)
FROM albums
WHERE release_year > 1990
GROUP BY artist_id +-----------+----------+
| artist_id | COUNT(*) |
+-----------+----------+
| 4 | 1 |
| 6 | 2 |
+-----------+----------+

Nu har du bara de album som släpptes efter 1990, grupperade efter artist. Du kan också använda en join med WHERE -satsen, oberoende av GROUP BY:

SELECT r.name, COUNT(*) AS albums
FROM albums l, artists r
WHERE artist_id=r.id
AND release_year > 1990
GROUP BY artist_id +---------+--------+
| name | albums |
+---------+--------+
| Nirvana | 1 |
| Adele | 2 |
+---------+--------+

Observera dock att om du försöker filtrera baserat på en aggregerad kolumn:

SELECT r.name, COUNT(*) AS albums
FROM albums l, artists r
WHERE artist_id=r.id
AND albums > 2
GROUP BY artist_id;

Du får ett fel:

ERROR 1054 (42S22): Unknown column 'albums' in 'where clause'

Kolumner baserade på aggregerad data är inte tillgängliga för WHERE -klausulen.

Använda HAVING -klausulen

Så hur filtrerar du resultatuppsättningen efter att en gruppering har ägt rum? De HAR klausul behandlar detta behov:

SELECT r.name, COUNT(*) AS albums
FROM albums l, artists r
WHERE artist_id=r.id
GROUP BY artist_id
HAVING albums > 1;

Observera att HAVING -klausulen kommer efter GROUP BY. Annars är det i princip en enkel ersättning av WHERE med HAVING. Resultaten är:

+------------+--------+
| name | albums |
+------------+--------+
| Pink Floyd | 2 |
| Adele | 2 |
+------------+--------+

Du kan fortfarande använda ett WHERE -villkor för att filtrera resultaten före grupperingen. Det fungerar tillsammans med en HAVING -klausul för filtrering efter grupperingen:

SELECT r.name, COUNT(*) AS albums
FROM albums l, artists r
WHERE artist_id=r.id
AND release_year > 1990
GROUP BY artist_id
HAVING albums > 1;

Endast en artist i vår databas släppte mer än ett album efter 1990:

+-------+--------+
| name | albums |
+-------+--------+
| Adele | 2 |
+-------+--------+

Kombinera resultat med GROUP BY

GROUP BY -uttalandet är en oerhört användbar del av SQL -språket. Den kan tillhandahålla sammanfattande information om data, till exempel för en innehållssida. Det är ett utmärkt alternativ för att hämta stora mängder data. Databasen hanterar denna extra arbetsbelastning bra eftersom dess design gör den optimal för jobbet.

När du förstår gruppering och hur du går med i flera tabeller kommer du att kunna använda det mesta av kraften i en relationsdatabas.

Dela med sig Dela med sig Tweet E-post Hur man frågar flera databastabeller samtidigt med SQL -kopplingar

Lär dig hur du använder SQL -kopplingar för att effektivisera frågor, spara tid och få dig att känna dig som en SQL -användare.

när kom den första ps4 ut
Läs Nästa Relaterade ämnen
  • Programmering
  • SQL
Om författaren Bobby Jack(58 artiklar publicerade)

Bobby är en teknikentusiast som arbetade som mjukvaruutvecklare i de flesta av två decennier. Han brinner för spel, jobbar som Recensions Editor på Switch Player Magazine och är fördjupad i alla aspekter av online -publicering och webbutveckling.

Mer från Bobby Jack

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera