SQL
GROEPEN OP

Invoering

Syntaxis

• GROEP OP {
  kolom-expressie
  | ROLLUP (<group_by_expression> [, ... n])
  | CUBE (<group_by_expression> [, ... n])
  | GROEPINGSSETS ([, ... n])
  | () - berekent het eindtotaal
  } [, ... n]

• <group_by_expression> :: =
  kolom-expressie
  | (kolomuitdrukking [, ... n])

• <grouping_set> :: =
  () - berekent het eindtotaal
  | <Grouping_set_item>
  | (<grouping_set_item> [, ... n])

• <grouping_set_item> :: =
  <Group_by_expression>
  | ROLLUP (<group_by_expression> [, ... n])
  | CUBE (<group_by_expression> [, ... n])

GEBRUIK GROEP DOOR tot het aantal rijen voor elk uniek item in een bepaalde kolom

Stel dat u tellingen of subtotalen voor een bepaalde waarde in een kolom wilt genereren.

Gegeven deze tabel, "Westerosians":

Zonder GROUP BY zal COUNT gewoon een totaal aantal rijen retourneren:

SELECT Count(*) Number_of_Westerosians
FROM Westerosians

geeft terug...

Maar door GROUP BY toe te voegen, kunnen we de gebruikers TELLEN voor elke waarde in een bepaalde kolom, om het aantal mensen in een bepaald Great House te retourneren, bijvoorbeeld:

SELECT GreatHouseAllegience House, Count(*) Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience

geeft terug...

Het is gebruikelijk om GROUP BY te combineren met ORDER BY om resultaten te sorteren op grootste of kleinste categorie:

SELECT GreatHouseAllegience House, Count(*) Number_of_Westerosians
FROM Westerosians
GROUP BY GreatHouseAllegience
ORDER BY Number_of_Westerosians Desc

geeft terug...

Filter GROUP BY-resultaten met een HAVING-clausule

Een HAVING-clausule filtert de resultaten van een GROUP BY-expressie. Opmerking: de volgende voorbeelden gebruiken de voorbeelddatabase van Bibliotheek .

Voorbeelden:

Retourneer alle auteurs die meer dan één boek hebben geschreven ( live voorbeeld ).

SELECT
  a.Id,
  a.Name,
  COUNT(*) BooksWritten
FROM BooksAuthors ba
  INNER JOIN Authors a ON a.id = ba.authorid
GROUP BY
  a.Id,
  a.Name
HAVING COUNT(*) > 1    -- equals to HAVING BooksWritten > 1
;

Retourneer alle boeken met meer dan drie auteurs ( live voorbeeld ).

SELECT
  b.Id,
  b.Title,
  COUNT(*) NumberOfAuthors
FROM BooksAuthors ba
  INNER JOIN Books b ON b.id = ba.bookid
GROUP BY
  b.Id,
  b.Title
HAVING COUNT(*) > 3    -- equals to HAVING NumberOfAuthors > 3
;

Basic GROUP BY-voorbeeld

Het kan gemakkelijker zijn als u GROUP BY als "voor elk" beschouwt ter verduidelijking. De onderstaande vraag:

SELECT EmpID, SUM (MonthlySalary) 
FROM Employee
GROUP BY EmpID

zegt:

"Geef me de som van maandelijks salaris voor elke EmpID"

Dus als je tafel er zo uitzag:

+-----+-------------+
|EmpID|MonthlySalary|
+-----+-------------+
|1    |200          |
+-----+-------------+
|2    |300          |
+-----+-------------+

Resultaat:

+-+---+
|1|200|
+-+---+
|2|300|
+-+---+

Som lijkt niets te doen omdat de som van één getal dat getal is. Aan de andere kant als het er zo uitzag:

+-----+-------------+
|EmpID|MonthlySalary|
+-----+-------------+
|1    |200          |
+-----+-------------+
|1    |300          |
+-----+-------------+
|2    |300          |
+-----+-------------+

Resultaat:

+-+---+
|1|500|
+-+---+
|2|300|
+-+---+

Dan zou het omdat er twee EmpID 1's zijn om samen te tellen.

ROLAP-aggregatie (datamining)

Beschrijving

De SQL-standaard biedt twee extra aggregatie-operators. Deze gebruiken de polymorfe waarde "ALL" om de verzameling van alle waarden aan te geven die een attribuut kan aannemen. De twee operatoren zijn:

• with data cube dat het alle mogelijke combinaties biedt dan de argumentattributen van de clausule.
• with roll up samengevat dat het de verkregen aggregaten levert door de attributen in volgorde van links naar rechts te beschouwen vergeleken met hoe ze worden vermeld in het argument van de clausule.

SQL-standaardversies die deze functies ondersteunen: 1999,2003,2006,2008,2011.

Voorbeelden

Beschouw deze tabel:

Met kubus

select Food,Brand,Total_amount
from Table
group by Food,Brand,Total_amount with cube

Met oprollen

select Food,Brand,Total_amount
from Table
group by Food,Brand,Total_amount with roll up