SQL
GRUPP AV

Introduktion

Syntax

• GRUPP AV {
  kolonn-expression
  | ROLLUP (<grupp_by_uttryck> [, ... n])
  | CUBE (<grupp_by_uttryck> [, ... n])
  | GRUPPERINSTÄLLNINGAR ([, ... n])
  | () - beräknar totalbeloppet
  } [, ... n]

• <grupp_by_uttryck> :: =
  kolonn-expression
  | (kolumnuttryck [, ... n])

• <grupp_set> :: =
  () - beräknar totalbeloppet
  | <Grouping_set_item>
  | (<grupp_set_item> [, ... n])

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

ANVÄND GRUPP AV för att COUNT antalet rader för varje unik post i en given kolumn

Låt oss säga att du vill generera räkningar eller delsiffror för ett visst värde i en kolumn.

Med tanke på denna tabell, "Westerosians":

Utan GROUP BY kommer COUNT helt enkelt att returnera ett totalt antal rader:

SELECT Count(*) Number_of_Westerosians
FROM Westerosians

avkastning ...

Men genom att lägga till GROUP BY kan vi COUNT användarna för varje värde i en given kolumn för att returnera antalet personer i ett visst Great House, säga:

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

avkastning ...

Det är vanligt att kombinera GROUP BY med ORDER BY för att sortera resultat efter största eller minsta kategori:

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

avkastning ...

Filtrera GROUP BY-resultat med hjälp av en HAVING-klausul

En HAVING-klausul filtrerar resultaten av ett GROUP BY-uttryck. Obs: Följande exempel använder bibliotekets exempeldatabas.

Exempel:

Returnera alla författare som skrev mer än en bok ( levande exempel ).

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
;

Returnera alla böcker som har mer än tre författare ( levande exempel ).

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
;

Grundläggande GRUPP AV exempel

Det kan vara lättare om du tänker på GROUP BY som "för varje" för att förklara. Frågan nedan:

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

säger:

"Ge mig summan av månadssalarier för varje EmpID"

Så om ditt bord såg ut så här:

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

Resultat:

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

Summa verkar inte göra något eftersom summan av ett nummer är det numret. Å andra sidan om det såg ut så här:

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

Resultat:

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

Sedan skulle det bero på att det finns två EmpID 1: er att summera tillsammans.

ROLAP-aggregering (Data Mining)

Beskrivning

SQL-standarden ger ytterligare två aggregerade operatörer. Dessa använder det polymorfa värdet "ALL" för att beteckna uppsättningen av alla värden som ett attribut kan ta. De två operatörerna är:

• with data cube att den ger alla möjliga kombinationer än klausulens attribut för klausulen.
• with roll up att det ger de aggregerade erhållna genom att beakta attributen i ordning från vänster till höger jämfört med hur de är listade i klausulens argument.

SQL-standardversioner som stöder dessa funktioner: 1999,2003,2006,2008,2011.

exempel

Tänk på denna tabell:

Med kub

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

Med rulla upp

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