SELECT – GROUP BY-sats (Transact-SQL)

Gäller för:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsSQL-analysendpoint i Microsoft FabricLager i Microsoft FabricSQL-databas i Microsoft Fabric

En SELECT instruktionssats som delar upp frågeresultatet i grupper med rader, vanligtvis genom att utföra en eller flera aggregeringar i varje grupp. Instruktionen SELECT returnerar en rad för varje grupp.

Den här artikeln innehåller olika syntax, argument, kommentarer, behörigheter och exempel baserat på den valda produktversionen. Välj önskad produktversion i listrutan version.

Syntax

Transact-SQL syntaxkonventioner

ISO-kompatibel syntax för SQL Server, Azure SQL Database, Azure SQL Managed Instance och SQL database in Fabric:

GROUP BY {
      column-expression
    | ROLLUP ( <group_by_expression> [ , ...n ] )
    | CUBE ( <group_by_expression> [ , ...n ] )
    | GROUPING SETS ( <grouping_set> [ , ...n ]  )
    | () --calculates the grand total
} [ , ...n ]

<group_by_expression> ::=
      column-expression
    | ( column-expression [ , ...n ] )

<grouping_set> ::=
      () --calculates the grand total
    | <grouping_set_item>
    | ( <grouping_set_item> [ , ...n ] )

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

Syntax som inte är ISO-kompatibel endast för bakåtkompatibilitet:

GROUP BY {
       ALL column-expression [ , ...n ]
    | column-expression [ , ...n ]  WITH { CUBE | ROLLUP }
       }

Arguments

Kolumnuttryck

Anger en kolumn eller en icke-aggregeringsberäkning för en kolumn. Den här kolumnen kan tillhöra en tabell, härledd tabell eller vy. Kolumnen måste visas i FROM instruktionens SELECT sats, men behöver inte visas i SELECT listan.

Giltiga uttryck finns i uttrycket.

Kolumnen måste visas i FROM instruktionens SELECT sats, men krävs inte för att visas i SELECT listan. Du måste dock inkludera varje tabell eller vykolumn i GROUP BY listan om du använder den i ett icke-aggregeringsuttryck i <select> listan.

ALTERNATIV FÖR GRUPPERA EFTER

Följande alternativ utökar den grundläggande GROUP BY satsen för att stödja hierarkisk aggregering, flerdimensionell sammanfattning, anpassade grupperingskombinationer och plattformsspecifika körningsbeteenden. Frågor kan använda dessa alternativ för att producera delsummor och totalsummor i en enda logisk åtgärd.

• ROLLUP ( <group_by_expression> [ , ... n ] )

  Genererar hierarkiska delsummor för de listade kolumnerna och en slutlig totalsumma (till exempel (a,b,c), (a,b), (a), ()). Använd den för att öka detaljnivån, till exempelkvartalsmånad>för år>.

• CUBE ( <group_by_expression> [ , ... n ] )

  Genererar alla kombinationer av de angivna kolumnerna (hela 2^n-lattice) plus totalsumman. Använd den för flerdimensionell analys i varje sektor.

• GRUPPERINGSUPPSÄTTNINGAR ( <grouping_set> [ , ... n ] )

  Definierar de exakta grupperingar som ska beräknas (inklusive () för totalsumma) i ett enda pass. Det här alternativet liknar funktionellt flera UNION ALLGROUP BY frågor men optimeras tillsammans.

• () (tom grupperingsuppsättning)

  Förkortning för att endast beräkna totalsumman för alla rader. Använd den ensam som GROUP BY () eller inuti GROUPING SETS.

• ALLA kolumnuttryck [ , ... n ](icke-ISO; bakåtkompatibilitet)

  Kort stavning för att gruppera efter alla objekt som inte är aggregerade. Behålls för kompatibilitet; tillgänglighet och semantik varierar.

• column-expression [ , ... n ] MED { KUB | 'SAMMANSLAGNING }(äldre formulär)

  Äldre, icke-ISO-syntax som motsvarar GROUP BY CUBE(...) eller GROUP BY ROLLUP(...). Stöds endast för bakåtkompatibilitet. Använd ISO-underklienterna när det är möjligt.

• MED (DISTRIBUTED_AGG)

  Tips distribuerad körning för sammansättningar vid gruppering efter en enda kolumn. Endast Azure Synapse Analytics dedikerade SQL-pools stöder detta alternativ.

GROUP BY column-expression [ ,... n ]

Grupperar -instruktionens SELECT resultat enligt värdena i en lista med ett eller flera kolumnuttryck.

Den här frågan skapar till exempel en Sales tabell med kolumner för Region, Territoryoch Sales. Den infogar fyra rader och två av raderna har matchande värden för Region och Territory.

CREATE TABLE Sales
(
    Region VARCHAR (50),
    Territory VARCHAR (50),
    Sales INT
);
GO

INSERT INTO Sales VALUES (N'Canada', N'Alberta', 100);
INSERT INTO Sales VALUES (N'Canada', N'British Columbia', 200);
INSERT INTO Sales VALUES (N'Canada', N'British Columbia', 300);
INSERT INTO Sales VALUES (N'United States', N'Montana', 100);

Tabellen Sales innehåller följande rader:

Region	Område	Sales
Canada	Alberta	100
Canada	British Columbia	200
Canada	British Columbia	300
United States	Montana	100

Nästa fråga grupperar Region och Territory returnerar den aggregerade summan för varje kombination av värden.

SELECT Region,
       Territory,
       SUM(sales) AS TotalSales
FROM Sales
GROUP BY Region, Territory;

Frågeresultatet har tre rader eftersom det finns tre kombinationer av värden för Region och Territory. TotalSales För Kanada och British Columbia är summan av två rader.

Region	Område	TotalSales
Canada	Alberta	100
Canada	British Columbia	500
United States	Montana	100

Kolumnuttrycket i GROUP BY kan inte innehålla följande element:

• Ett GROUP BY kolumnuttryck kan inte innehålla ett kolumnalias som du definierar i listan SELECT . Den kan använda ett kolumnalias för en härledd tabell som definieras i FROM -satsen.
• Ett GROUP BY kolumnuttryck kan inte innehålla en kolumn med typtext, ntext eller bild. Du kan dock använda en kolumn med text, ntext eller bild som ett argument till en funktion som returnerar ett värde av en giltig datatyp. Uttrycket kan till exempel använda SUBSTRING() och CAST(). Den här regeln gäller även för uttryck i HAVING -satsen.
• Ett GROUP BY kolumnuttryck kan inte innehålla en xml-datatypmetod . Den kan inkludera en användardefinierad funktion eller en beräknad kolumn som använder xml-datatypmetoder .
• Ett GROUP BY kolumnuttryck kan inte innehålla en delfråga; frågan ger fel 144.
• Ett GROUP BY kolumnuttryck kan inte innehålla en kolumn från en indexerad vy.

Följande instruktioner är tillåtna:

SELECT ColumnA,
       ColumnB
FROM T
GROUP BY ColumnA, ColumnB;

SELECT ColumnA + ColumnB
FROM T
GROUP BY ColumnA, ColumnB;

SELECT ColumnA + ColumnB
FROM T
GROUP BY ColumnA + ColumnB;

SELECT ColumnA + ColumnB + constant
FROM T
GROUP BY ColumnA, ColumnB;

Följande instruktioner är inte tillåtna:

SELECT ColumnA,
       ColumnB
FROM T
GROUP BY ColumnA + ColumnB;

SELECT ColumnA + constant + ColumnB
FROM T
GROUP BY ColumnA + ColumnB;

GRUPPERA EFTER SAMMANSLAGNING ()

Skapar en grupp för varje kombination av kolumnuttryck. Dessutom summeras resultatet i delsummor och totalsummor. När grupperna skapas flyttas de från höger till vänster, vilket minskar antalet kolumnuttryck för gruppering och sammansättningar.

Kolumnordningen ROLLUP påverkar utdata och kan påverka antalet rader i resultatuppsättningen.

Skapar till exempel GROUP BY ROLLUP (col1, col2, col3, col4) grupper för varje kombination av kolumnuttryck i följande listor:

• kol1, kol2, kol 3, kol 4
• kol1, kol2, kol3, NULL
• kol1, kol2, NULL, NULL
• kol1, NULL, NULL, NULL
• NULL, NULL, NULL, NULL (Gruppen med NULL värdena är totalsumman)

Med hjälp av tabellen från föregående exempel kör den här koden en GROUP BY ROLLUP åtgärd i stället för en grundläggande GROUP BY.

SELECT Region,
       Territory,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY ROLLUP(Region, Territory);

Frågeresultatet har samma sammansättningar som grundläggande GROUP BY utan ROLLUP. Dessutom skapas delsummor för varje värde i Region. Slutligen ger den en totalsumma för alla rader. Resultatet ser ut så här:

Region	Område	TotalSales
Canada	Alberta	100
Canada	British Columbia	500
Canada	NULL	600
United States	Montana	100
United States	NULL	100
NULL	NULL	700

GRUPPERA EFTER KUB ()

GROUP BY CUBE skapar grupper för alla möjliga kombinationer av kolumner. För GROUP BY CUBE (a, b)har resultaten grupper för unika värden för (a, b), (NULL, b), (a, NULL)och (NULL, NULL).

Med hjälp av tabellen från föregående exempel kör den här koden en GROUP BY CUBE åtgärd i Region och Område.

SELECT Region,
       Territory,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY CUBE(Region, Territory);

Frågeresultatet har grupper för unika värden för (Region, Territory), (NULL, Territory), (Region, NULL)och (NULL, NULL). Resultatet ser ut så här:

Region	Område	TotalSales
Canada	Alberta	100
NULL	Alberta	100
Canada	British Columbia	500
NULL	British Columbia	500
United States	Montana	100
NULL	Montana	100
NULL	NULL	700
Canada	NULL	600
United States	NULL	100

GRUPPERA EFTER GRUPPERINGSUPPSÄTTNINGAR ()

Alternativet GROUPING SETS kombinerar flera GROUP BY satser i en GROUP BY sats. Resultatet är detsamma som för UNION ALL de angivna grupperna.

Till exempel GROUP BY ROLLUP (Region, Territory) och GROUP BY GROUPING SETS ( ROLLUP (Region, Territory)) returnera samma resultat.

När GROUPING SETS har två eller flera element är resultatet en union av elementen. Det här exemplet returnerar union av ROLLUP resultaten och CUBE för Region och Område.

SELECT Region,
       Territory,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY GROUPING SETS(ROLLUP(Region, Territory), CUBE(Region, Territory));

Resultatet är samma som den här frågan som returnerar en union av de två GROUP BY uttrycken.

SELECT Region,
       Territory,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY ROLLUP(Region, Territory)
UNION ALL
SELECT Region,
       Territory,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY CUBE(Region, Territory);

SQL konsoliderar inte duplicerade grupper som genererats för en GROUPING SETS lista. I returnerar till exempel GROUP BY ((), CUBE (Region, Territory))båda elementen en rad för totalsumman och båda raderna visas i resultatet.

Stöd för ISO- och ANSI SQL-2006 GROUP BY-funktioner

GROUP BY Satsen stöder alla GROUP BY funktioner som ingår i SQL-2006-standarden med följande syntaxfel:

• Grupperingsuppsättningar tillåts inte i satsen om de inte ingår i GROUP BY en explicit GROUPING SETS lista. Till exempel tillåts i standarden men GROUP BY Column1, (Column2, ...ColumnN) inte i Transact-SQL. Transact-SQL stöder GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)) och GROUP BY Column1, Column2, ... ColumnN, som är semantiskt likvärdiga. Dessa satser är semantiskt likvärdiga med föregående GROUP BY exempel. Den här begränsningen undviker möjligheten att GROUP BY Column1, (Column2, ...ColumnN) feltolkas som GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), som inte är semantiskt likvärdiga.

• Grupperingsuppsättningar tillåts inte i grupperingsuppsättningar. Till exempel tillåts i SQL-2006-standarden men GROUP BY GROUPING SETS (A1, A2,...An, GROUPING SETS (C1, C2, ...Cn)) inte i Transact-SQL. Transact-SQL tillåter GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn) eller GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn)), som är semantiskt likvärdiga med det första GROUP BY exemplet och har tydligare syntax.

GRUPPERA EFTER ()

Anger den tomma gruppen, som genererar totalsumman. Den här gruppen är användbar som ett av elementen i en GROUPING SET. Den här instruktionen ger till exempel den totala försäljningen för varje region och ger sedan totalsumman för alla regioner.

SELECT Region,
       SUM(Sales) AS TotalSales
FROM Sales
GROUP BY GROUPING SETS(Region, ());

GRUPPERA EFTER ALLA kolumnuttryck [ ,... n ]

Gäller för: SQL Server, Azure SQL Database, Azure SQL Managed Instance och SQL database in Fabric

Note

Använd endast den här syntaxen för bakåtkompatibilitet. Undvik att använda den här syntaxen i det nya utvecklingsarbetet och planera att ändra program som för närvarande använder den här syntaxen.

GROUP BY ALL T-SQL-syntaxen är annorlunda i Fabric Data Warehouse. För den Fabric Data Warehouse versionen av denna artikel, se VÄLJ - GRUPPERA EFTER för Fabric Data Warehouse.

Anger om alla grupper ska inkluderas i resultaten, oavsett om de uppfyller sökvillkoren i WHERE -satsen. Grupper som inte uppfyller sökvillkoren har NULL för aggregeringen.

• GROUP BY ALL {columns} stöds inte i frågor som får tillgång till fjärrtabeller om det också finns en WHERE klausul i frågan.
• GROUP BY ALL {columns} misslyckas på kolumner som har attributet FILESTREAM.

Stöd för ISO- och ANSI SQL-2006 GROUP BY-funktioner

GROUP BY Satsen stöder alla GROUP BY funktioner som ingår i SQL-2006-standarden med följande syntaxfel:

• Du kan bara använda GROUP BY ALL och GROUP BY DISTINCT i en grundläggande GROUP BY sats som innehåller kolumnuttryck. Du kan inte använda dem med konstruktionerna GROUPING SETS, ROLLUP, CUBE, WITH CUBEeller WITH ROLLUP . ALL är standardvärdet och är implicit. Du kan bara använda den i den bakåtkompatibla syntaxen.

GROUP BY column-expression [ ,... n ] MED { KUB | SAMMANSLAGNING }

Gäller för: SQL Server, Azure SQL Database, Azure SQL Managed Instance och SQL database in Fabric

Legacy GROUP BY <column-expression> WITH CUBE och GROUP BY <column-expression> WITH ROLLUP syntax stöds endast för bakåtkompatibilitet.

Note

Använd endast den här syntaxen för bakåtkompatibilitet. Undvik att använda den här syntaxen i det nya utvecklingsarbetet och planera att ändra program som för närvarande använder den här syntaxen.

MED (DISTRIBUTED_AGG)

gäller för: Azure Synapse Analytics

Frågetipset DISTRIBUTED_AGG stöds inte i SQL Server, Azure SQL Database, Azure SQL Managed Instance, SQL-databaser i Fabric eller Fabric Data Warehouse.

Frågetipset DISTRIBUTED_AGG tvingar MPP-systemet (massively parallel processing) att omdistribuera en tabell i en specifik kolumn innan du utför en aggregering. Du kan bara använda frågetipset DISTRIBUTED_AGG på en kolumn i GROUP BY -satsen. När frågan är klar tas den omdelade tabellen bort. Den ursprungliga tabellen ändras inte.

Note

Frågeledtråden DISTRIBUTED_AGG ger bakåtkompatibilitet och förbättrar inte prestandan för de flesta sökningar. Som standard distribuerar MPP redan data efter behov för att förbättra prestanda för aggregeringar.

Anmärkningar

Så interagerar GROUP BY med SELECT-instruktionen

SELECT Lista:

• Vektoraggregat. Om du inkluderar mängdfunktioner i SELECT listan GROUP BY beräknar du ett sammanfattningsvärde för varje grupp. Dessa funktioner kallas vektoraggregat.
• Distinkta sammansättningar. Aggregerar AVG(DISTINCT <column_name>), COUNT(DISTINCT <column_name>)och SUM(DISTINCT <column_name>) arbetar med ROLLUP, CUBEoch GROUPING SETS.

WHERE-klausul:

• SQL tar bort rader som inte uppfyller villkoren i WHERE -satsen innan de utför någon grupperingsåtgärd.

HAVING-klausul:

• SQL använder HAVING -satsen för att filtrera grupper i resultatuppsättningen.

ORDER BY-klausul:

• ORDER BY Använd -satsen för att beställa resultatuppsättningen. GROUP BY Satsen beställer inte resultatuppsättningen.

NULL värden:

• Om en grupperingskolumn innehåller NULL värden behandlar databasmotorn alla NULL värden som lika och samlar in dem i en enda grupp.

Begränsningar

Gäller för: SQL Server och Azure Synapse Analytics

För en GROUP BY sats som använder ROLLUP, CUBEeller GROUPING SETS, är det maximala antalet uttryck 32. Det maximala antalet grupper är 4 096 (2¹²). Följande exempel misslyckas eftersom GROUP BY satsen har fler än 4 096 grupper.

• I följande exempel genereras grupperingsuppsättningar på 4 097 (2¹² + 1) och misslyckas sedan.

  GROUP BY GROUPING SETS( CUBE(a1, ..., a12), b)
  

• I följande exempel genereras 4 097 grupper (2¹² + 1) och misslyckas sedan. Både CUBE () och grupperingsuppsättningen () skapar en total summarad och dubblettgrupperingsuppsättningar elimineras inte.

  GROUP BY GROUPING SETS( CUBE(a1, ..., a12), ())
  

• I det här exemplet används den bakåtkompatibla syntaxen. Den genererar 8 192 (2¹³) grupperingsuppsättningar och misslyckas sedan.

  GROUP BY CUBE (a1, ..., a13)
  GROUP BY a1, ..., a13 WITH CUBE
  

  För bakåtkompatibla GROUP BY satser som inte innehåller CUBE eller ROLLUPbegränsar GROUP BY kolumnstorlekarna, de aggregerade kolumnerna och de mängdvärden som ingår i frågan antalet GROUP BY objekt. Den här gränsen kommer från gränsen på 8 060 byte på den mellanliggande arbetstabellen som innehåller mellanliggande frågeresultat. Du kan använda högst 12 grupperingsuttryck när du anger CUBE eller ROLLUP.

Jämförelse av GROUP BY-funktioner som stöds

I följande tabell beskrivs de GROUP BY funktioner som olika produkter stöder.

Feature	služba SSIS	SQL Server 1
DISTINCT Aggregat	Stöds inte för WITH CUBE eller WITH ROLLUP.	Stöds för WITH CUBE, WITH ROLLUP, GROUPING SETS, CUBEeller ROLLUP.
Användardefinierad funktion med CUBE eller ROLLUP namn i GROUP BY -satsen	Användardefinierad funktion dbo.cube(<arg1>, ...<argN>) eller dbo.rollup(<arg1>, ...<argN>) i -satsen tillåts GROUP BY . Till exempel: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);	Användardefinierad funktion dbo.cube (<arg1>, ...<argN>) eller dbo.rollup(<arg1>, ...<argN>) i GROUP BY -satsen tillåts inte. Till exempel: SELECT SUM (x) FROM T GROUP BY dbo.cube(y); SQL Server returnerar ett felmeddelande 2. Undvik det här problemet genom att ersätta dbo.cube med [dbo].[cube] eller dbo.rollup med [dbo].[rollup]. Följande exempel tillåts: SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);
GROUPING SETS	Stöds inte	Supported
CUBE	Stöds inte	Supported
ROLLUP	Stöds inte	Supported
Totalsumma, till exempel GROUP BY()	Stöds inte	Supported
funktion GROUPING_ID	Stöds inte	Supported
funktion GROUPING	Supported	Supported
WITH CUBE	Supported	Supported
WITH ROLLUP	Supported	Supported
WITH CUBE eller WITH ROLLUP "duplicera" borttagning av gruppering	Supported	Supported

¹Databaskompatibilitetsnivå 100 och högre.

² Felmeddelandet som returneras är: Incorrect syntax near the keyword 'cube'|'rollup'.

Examples

Kodexemplen i denna artikel använder AdventureWorks2025, AdventureWorksDW2025, eller AdventureWorksLT2025 exempeldatabasen, som du kan ladda ner från Azure Data SQL Samples Repository GitHub-arkivet.

A. Använda en grundläggande GROUP BY-sats

I följande exempel hämtas summan för var och en SalesOrderID från SalesOrderDetail tabellen. I det här exemplet används AdventureWorks.

SELECT SalesOrderID,
       SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail AS sod
GROUP BY SalesOrderID
ORDER BY SalesOrderID;

B. Använda en GROUP BY-sats med flera tabeller

I följande exempel hämtas antalet anställda för var och en City från tabellen Address som är ansluten till EmployeeAddress tabellen. I det här exemplet används AdventureWorks.

SELECT a.City,
       COUNT(bea.AddressID) AS EmployeeCount
FROM Person.BusinessEntityAddress AS bea
     INNER JOIN Person.Address AS a
         ON bea.AddressID = a.AddressID
GROUP BY a.City
ORDER BY a.City;

C. Använda en GROUP BY-sats med ett uttryck

I följande exempel hämtas den totala försäljningen för varje år med hjälp DATEPART av funktionen . Du måste inkludera samma uttryck i både SELECT listan och GROUP BY -satsen.

SELECT DATEPART(yyyy, OrderDate) AS N'Year',
       SUM(TotalDue) AS N'Total Order Amount'
FROM Sales.SalesOrderHeader
GROUP BY DATEPART(yyyy, OrderDate)
ORDER BY DATEPART(yyyy, OrderDate);

D. Använda en GROUP BY-sats med en HAVING-sats

I följande exempel används HAVING -satsen för att ange vilka grupper som genereras i GROUP BY satsen ska ingå i resultatuppsättningen.

SELECT DATEPART(yyyy, OrderDate) AS N'Year',
       SUM(TotalDue) AS N'Total Order Amount'
FROM Sales.SalesOrderHeader
GROUP BY DATEPART(yyyy, OrderDate)
HAVING DATEPART(yyyy, OrderDate) >= N'2003'
ORDER BY DATEPART(yyyy, OrderDate);

Exempel: Azure Synapse Analytics

E. Grundläggande användning av GROUP BY-satsen

I följande exempel hittar du det totala beloppet för all försäljning varje dag. Frågan returnerar en rad som innehåller summan av all försäljning för varje dag.

-- Uses AdventureWorksDW
SELECT OrderDateKey,
       SUM(SalesAmount) AS TotalSales
FROM FactInternetSales
GROUP BY OrderDateKey
ORDER BY OrderDateKey;

F. Grundläggande användning av DISTRIBUTED_AGG tips

I det här exemplet används DISTRIBUTED_AGG frågetips för att tvinga installationen att blanda tabellen i CustomerKey kolumnen innan den utför aggregeringen.

-- Uses AdventureWorksDW
SELECT CustomerKey,
       SUM(SalesAmount) AS sas
FROM FactInternetSales
GROUP BY CustomerKey WITH(DISTRIBUTED_AGG)
ORDER BY CustomerKey DESC;

G. Syntaxvariationer för GROUP BY

När den valda listan inte har några sammansättningar måste du inkludera varje kolumn i urvalslistan i GROUP BY listan. Du kan inkludera beräknade kolumner i urvalslistan, men du behöver inte inkludera dem i GROUP BY listan. De här exemplen visar syntaktiskt giltiga SELECT instruktioner:

-- Uses AdventureWorks
SELECT LastName,
       FirstName
FROM DimCustomer
GROUP BY LastName, FirstName;

SELECT NumberCarsOwned
FROM DimCustomer
GROUP BY YearlyIncome, NumberCarsOwned;

SELECT (SalesAmount + TaxAmt + Freight) AS TotalCost
FROM FactInternetSales
GROUP BY SalesAmount, TaxAmt, Freight;

SELECT SalesAmount,
       SalesAmount * 1.10 AS SalesTax
FROM FactInternetSales
GROUP BY SalesAmount;

SELECT SalesAmount
FROM FactInternetSales
GROUP BY SalesAmount, SalesAmount * 1.10;

H. Använda en GROUP BY-sats med flera GROUP BY-uttryck

I följande exempel grupperas resultat med hjälp av flera GROUP BY villkor. Om det finns undergrupper inom varje OrderDateKey grupp som DueDateKey värdet skiljer sig åt definierar frågan en ny gruppering för resultatuppsättningen.

-- Uses AdventureWorks
SELECT OrderDateKey,
       DueDateKey,
       SUM(SalesAmount) AS TotalSales
FROM FactInternetSales
GROUP BY OrderDateKey, DueDateKey
ORDER BY OrderDateKey;

I. Använda en GROUP BY-sats med en HAVING-sats

I följande exempel används HAVING -satsen för att ange de grupper som genereras i GROUP BY satsen som ska ingå i resultatuppsättningen. Endast de grupper med orderdatum 2004 eller senare ingår i resultaten.

-- Uses AdventureWorks
SELECT OrderDateKey,
       SUM(SalesAmount) AS TotalSales
FROM FactInternetSales
GROUP BY OrderDateKey
HAVING OrderDateKey > 20040000
ORDER BY OrderDateKey;

Relaterat innehåll

• GROUPING_ID (Transact-SQL)
• GRUPPERING (Transact-SQL)
• SELECT (Transact-SQL)
• SELECT-sats (Transact-SQL)