Edit pass

rwestMSFT · rwestMSFT · commit 0e14252fba60 · 2026-03-13T17:42:15.000-06:00
diff --git a/docs/t-sql/queries/select-group-by-transact-sql.md b/docs/t-sql/queries/select-group-by-transact-sql.md
@@ -1,10 +1,10 @@
 ---
-title: "GROUP BY (Transact-SQL)"
+title: GROUP BY (Transact-SQL)
 description: A SELECT statement clause that divides the query result into groups of rows, usually by performing one or more aggregations on each group.
 author: MikeRayMSFT
 ms.author: mikeray
 ms.reviewer: randolphwest
-ms.date: 02/02/2026
+ms.date: 03/13/2026
 ms.service: sql
 ms.subservice: t-sql
 ms.topic: reference
@@ -30,25 +30,23 @@ helpviewer_keywords:
   - "groups [SQL Server], tables divided into groups"
   - "summary values [SQL Server]"
 dev_langs:
-  - "TSQL"
+  - TSQL
 monikerRange: ">=aps-pdw-2016 || =azuresqldb-current || =azure-sqldw-latest || >=sql-server-2016 || >=sql-server-linux-2017 || =azuresqldb-mi-current || =fabric || =fabric-sqldb"
 ---
 
 # SELECT - GROUP BY clause (Transact-SQL)
 
 [!INCLUDE [sql-asdb-asdbmi-asa-pdw-fabricse-fabricdw-fabricsqldb](../../includes/applies-to-version/sql-asdb-asdbmi-asa-pdw-fabricse-fabricdw-fabricsqldb.md)]
 
-A `SELECT` statement clause that divides the query result into groups of rows, usually by performing one or more aggregations on each group. The `SELECT` statement returns one row per group.
+A `SELECT` statement clause that divides the query result into groups of rows, usually by performing one or more aggregations on each group. The `SELECT` statement returns one row for each group.
 
 ## Syntax
 
 :::image type="icon" source="../../includes/media/topic-link-icon.svg" border="false"::: [Transact-SQL syntax conventions](../../t-sql/language-elements/transact-sql-syntax-conventions-transact-sql.md)
 
-Syntax for SQL Server and Azure SQL Database:
+ISO-compliant syntax for SQL Server and Azure SQL Database:
 
 ```syntaxsql
--- ISO-Compliant Syntax
-
 GROUP BY {
       column-expression
     | ROLLUP ( <group_by_expression> [ , ...n ] )
@@ -70,10 +68,11 @@ GROUP BY {
       <group_by_expression>
     | ROLLUP ( <group_by_expression> [ , ...n ] )
     | CUBE ( <group_by_expression> [ , ...n ] )
+```
 
--- For backward compatibility only.
--- Non-ISO-Compliant Syntax for SQL Server and Azure SQL Database
+Non-ISO-compliant syntax for SQL Server and Azure SQL Database (backward compatibility only):
 
+```syntaxsql
 GROUP BY {
        ALL column-expression [ , ...n ]
     | column-expression [ , ...n ]  WITH { CUBE | ROLLUP }
@@ -90,7 +89,7 @@ GROUP BY {
 } [ , ...n ]
 ```
 
-Syntax for Analytics Platform System/Paralel Data Warehouse (APS/PDW):
+Syntax for Analytics Platform System (PDW):
 
 ```syntaxsql
 GROUP BY {
@@ -107,32 +106,45 @@ Specifies a column or a nonaggregate calculation on a column. This column can be
 
 For valid expressions, see [expression](../language-elements/expressions-transact-sql.md).
 
-The column must appear in the `FROM` clause of the `SELECT` statement, but isn't required to appear in the `SELECT` list. However, each table or view column in any nonaggregate expression in the `<select>` list must be included in the `GROUP BY` list.
+The column must appear in the `FROM` clause of the `SELECT` statement, but isn't required to appear in the `SELECT` list. However, you must include each table or view column in the `GROUP BY` list if you use it in any nonaggregate expression in the `<select>` list.
 
 ### GROUP BY options
 
-The following options extend the basic `GROUP BY` clause to support hierarchical aggregation, multidimensional summarization, custom grouping combinations, and platform‑specific execution behaviors. These options allow queries to produce subtotals and grand totals in a single logical operation.
-
-- **ROLLUP ( <group_by_expression> [ , ...n ] )**  
-  Generates hierarchical subtotals for the listed columns and a final grand total (for example, `(a,b,c)`, `(a,b)`, `(a)`, `()`). Use for drill‑up reports like **year** > **quarter** > **month**.
-- **CUBE ( <group_by_expression> [ , ...n ] )**  
-  Produces all combinations of the specified columns (the full 2^n lattice) plus the grand total. Best suited for multi‑dimensional analysis across every slice.
-- **GROUPING SETS ( <grouping_set> [ , ...n ] )**  
-  Defines the exact groupings to compute (including `()` for grand total) in one pass; functionally similar to a `UNION ALL` of multiple `GROUP BY` queries but optimized together. 
-- **`()` (empty grouping set)**  
-  Shorthand for computing only the **grand total** across all rows—used alone as `GROUP BY ()` or inside `GROUPING SETS`. 
-- **ALL column-expression [ , ...n ]** *(non‑ISO; backward compatibility)*  
+The following options extend the basic `GROUP BY` clause to support hierarchical aggregation, multidimensional summarization, custom grouping combinations, and platform-specific execution behaviors. Queries can use these options to produce subtotals and grand totals in a single logical operation.
+
+- **ROLLUP ( \<group_by_expression> [ , ...n ] )**
+
+  Generates hierarchical subtotals for the listed columns and a final grand total (for example, `(a,b,c)`, `(a,b)`, `(a)`, `()`). Use it for drill-up reports like **year** > **quarter** > **month**.
+
+- **CUBE ( \<group_by_expression> [ , ...n ] )**
+
+  Produces all combinations of the specified columns (the full 2^n lattice) plus the grand total. Use it for multi-dimensional analysis across every slice.
+
+- **GROUPING SETS ( \<grouping_set> [ , ...n ] )**
+
+  Defines the exact groupings to compute (including `()` for grand total) in one pass. This option is functionally similar to a `UNION ALL` of multiple `GROUP BY` queries but optimized together.
+
+- **() (empty grouping set)**
+
+  Shorthand for computing only the **grand total** across all rows. Use it alone as `GROUP BY ()` or inside `GROUPING SETS`.
+
+- **ALL column-expression [ , ...n ]** *(non-ISO; backward compatibility)*
+
   Shorthand to group by all nonaggregated select items. Retained for compatibility; availability and semantics vary.
-- **column-expression [ , ...n ] WITH { CUBE | ROLLUP }** *(legacy form)*  
-  Older, non‑ISO syntax equivalent to `GROUP BY CUBE(...)` or `GROUP BY ROLLUP(...)`. Supported for backward compatibility; use the ISO subclauses when possible.
+
+- **column-expression [ , ...n ] WITH { CUBE | `ROLLUP }** *(legacy form)*
+
+    Older, non-ISO syntax that's equivalent to `GROUP BY CUBE(...)` or `GROUP BY ROLLUP(...)`. Supported for backward compatibility only. Use the ISO subclauses when possible.
+
 - **WITH (DISTRIBUTED_AGG)**
-  Hints distributed execution for aggregations when grouping by a single column. It's supported only in Azure Synapse Analytics dedicated SQL pools and Analytics Platform System/Parallel Data Warehouse (APS/PDW).
 
-## GROUP BY *column-expression* [ ,...n ]
+  Hints distributed execution for aggregations when grouping by a single column. Azure Synapse Analytics dedicated SQL pools and Analytics Platform System (PDW) are the only platforms that support this option.
+
+### GROUP BY *column-expression* [ ,...n ]
 
 Groups the `SELECT` statement results according to the values in a list of one or more column expressions.
 
-For example, this query creates a `Sales` table with columns for `Region`, `Territory`, and `Sales`. It inserts four rows and two of the rows have matching values for `Region` and `Territory`.
+For example, this query creates a `Sales` table with columns for `Region`, `Territory`, and `Sales`. It inserts four rows, and two of the rows have matching values for `Region` and `Territory`.
 
 ```sql
 CREATE TABLE Sales
@@ -218,9 +230,9 @@ FROM T
 GROUP BY ColumnA + ColumnB;
 ```
 
-## GROUP BY ROLLUP ()
+### GROUP BY ROLLUP ()
 
-Creates a group for each combination of column expressions. In addition, it *rolls up* the results into subtotals and grand totals. While creating the groups, it moves from right to left, decreasing the number of column expressions over which it creates groups and the aggregations.
+Creates a group for each combination of column expressions. In addition, it *rolls up* the results into subtotals and grand totals. When it creates the groups, it moves from right to left, decreasing the number of column expressions for grouping and aggregations.
 
 The column order affects the `ROLLUP` output and can affect the number of rows in the result set.
 
@@ -230,9 +242,9 @@ For example, `GROUP BY ROLLUP (col1, col2, col3, col4)` creates groups for each
 - col1, col2, col3, NULL
 - col1, col2, NULL, NULL
 - col1, NULL, NULL, NULL
-- NULL, NULL, NULL, NULL (The group with the NULL values is the grand total)
+- NULL, NULL, NULL, NULL (The group with the `NULL` values is the grand total)
 
-Using the table from the previous example, this code runs a `GROUP BY ROLLUP` operation instead of a simple `GROUP BY`.
+Using the table from the previous example, this code runs a `GROUP BY ROLLUP` operation instead of a basic `GROUP BY`.
 
 ```sql
 SELECT Region,
@@ -242,7 +254,7 @@ FROM Sales
 GROUP BY ROLLUP(Region, Territory);
 ```
 
-The query result has the same aggregations as the simple `GROUP BY` without the `ROLLUP`. In addition, it creates subtotals for each value of Region. Finally, it gives a grand total for all rows. The result looks like this:
+The query result has the same aggregations as the basic `GROUP BY` without the `ROLLUP`. In addition, it creates subtotals for each value of Region. Finally, it gives a grand total for all rows. The result looks like this:
 
 | Region | Territory | TotalSales |
 | --- | --- | ---: |
@@ -253,7 +265,7 @@ The query result has the same aggregations as the simple `GROUP BY` without the
 | United States | NULL | 100 |
 | NULL | NULL | 700 |
 
-## GROUP BY CUBE ()
+### GROUP BY CUBE ()
 
 `GROUP BY CUBE` creates groups for all possible combinations of columns. For `GROUP BY CUBE (a, b)`, the results have groups for unique values of `(a, b)`, `(NULL, b)`, `(a, NULL)`, and `(NULL, NULL)`.
 
@@ -281,7 +293,7 @@ The query result has groups for unique values of `(Region, Territory)`, `(NULL,
 | Canada | NULL | 600 |
 | United States | NULL | 100 |
 
-## GROUP BY GROUPING SETS ()
+### GROUP BY GROUPING SETS ()
 
 The `GROUPING SETS` option combines multiple `GROUP BY` clauses into one `GROUP BY` clause. The results are the same as using `UNION ALL` on the specified groups.
 
@@ -315,7 +327,7 @@ GROUP BY CUBE(Region, Territory);
 
 SQL doesn't consolidate duplicate groups generated for a `GROUPING SETS` list. For example, in `GROUP BY ((), CUBE (Region, Territory))`, both elements return a row for the grand total, and both rows appear in the results.
 
-### Support for ISO and ANSI SQL-2006 GROUP BY features
+#### Support for ISO and ANSI SQL-2006 GROUP BY features
 
 The `GROUP BY` clause supports all `GROUP BY` features that are included in the SQL-2006 standard with the following syntax exceptions:
 
@@ -334,7 +346,7 @@ FROM Sales
 GROUP BY GROUPING SETS(Region, ());
 ```
 
-## GROUP BY ALL column-expression [ ,...n ]
+### GROUP BY ALL column-expression [ ,...n ]
 
 **Applies to**: SQL Server and Azure SQL Database
 
@@ -348,23 +360,24 @@ Specifies whether to include all groups in the results, regardless of whether th
 - Isn't supported in queries that access remote tables if there's also a `WHERE` clause in the query.
 - Fails on columns that have the FILESTREAM attribute.
 
-### Support for ISO and ANSI SQL-2006 GROUP BY Features
+#### Support for ISO and ANSI SQL-2006 GROUP BY features
 
 The `GROUP BY` clause supports all `GROUP BY` features that are included in the SQL-2006 standard with the following syntax exceptions:
-- `GROUP BY ALL` and `GROUP BY DISTINCT` are only allowed in a simple `GROUP BY` clause that contains column expressions. You can't use them with the `GROUPING SETS`, `ROLLUP`, `CUBE`, `WITH CUBE`, or `WITH ROLLUP` constructs. `ALL` is the default and is implicit. It's also only allowed in the backward compatible syntax.
 
-## GROUP BY column-expression [ ,...n ] WITH { CUBE | ROLLUP }
+- You can only use `GROUP BY ALL` and `GROUP BY DISTINCT` in a basic `GROUP BY` clause that contains column expressions. You can't use them with the `GROUPING SETS`, `ROLLUP`, `CUBE`, `WITH CUBE`, or `WITH ROLLUP` constructs. `ALL` is the default and is implicit. You can only use it in the backward compatible syntax.
+
+### GROUP BY column-expression [ ,...n ] WITH { CUBE | ROLLUP }
 
 **Applies to**: SQL Server and Azure SQL Database
 
 > [!NOTE]  
 > Use this syntax only for backward compatibility. Avoid using this syntax in new development work, and plan to modify applications that currently use this syntax.
 
-## WITH (DISTRIBUTED_AGG)
+### WITH (DISTRIBUTED_AGG)
 
 **Applies to**: [!INCLUDE [ssazuresynapse-md](../../includes/ssazuresynapse-md.md)] and [!INCLUDE [ssPDW](../../includes/sspdw-md.md)]
 
-The `DISTRIBUTED_AGG` query hint forces the massively parallel processing (MPP) system to redistribute a table on a specific column before performing an aggregation. Only one column in the `GROUP BY` clause can have a `DISTRIBUTED_AGG` query hint. After the query finishes, the redistributed table is dropped. The original table isn't changed.
+The `DISTRIBUTED_AGG` query hint forces the massively parallel processing (MPP) system to redistribute a table on a specific column before performing an aggregation. You can use the `DISTRIBUTED_AGG` query hint on only one column in the `GROUP BY` clause. After the query finishes, the redistributed table is dropped. The original table isn't changed.
 
 > [!NOTE]  
 > The `DISTRIBUTED_AGG` query hint provides backward compatibility with earlier [!INCLUDE [ssPDW](../../includes/sspdw-md.md)] versions and doesn't improve performance for most queries. By default, MPP already redistributes data as necessary to improve performance for aggregations.
@@ -392,9 +405,9 @@ The `DISTRIBUTED_AGG` query hint forces the massively parallel processing (MPP)
 
 `NULL` values:
 
-- If a grouping column contains `NULL` values, all `NULL` values are considered equal, and they're collected into a single group.
+- If a grouping column contains `NULL` values, the Database Engine treats all `NULL` values as equal and collects them into a single group.
 
-### Limitations
+## Limitations
 
 **Applies to**: SQL Server and [!INCLUDE [ssazuresynapse-md](../../includes/ssazuresynapse-md.md)]
 
@@ -421,14 +434,14 @@ For a `GROUP BY` clause that uses `ROLLUP`, `CUBE`, or `GROUPING SETS`, the maxi
 
   For backward compatible `GROUP BY` clauses that don't contain `CUBE` or `ROLLUP`, the `GROUP BY` column sizes, the aggregated columns, and the aggregate values involved in the query limit the number of `GROUP BY` items. This limit originates from the limit of 8,060 bytes on the intermediate worktable that holds intermediate query results. You can use a maximum of 12 grouping expressions when you specify `CUBE` or `ROLLUP`.
 
-### Comparison of supported `GROUP BY` features
+## Comparison of supported GROUP BY features
 
-The following table describes the `GROUP BY` features that different SQL Server versions and database compatibility levels support.
+The following table describes the `GROUP BY` features that different products support.
 
-| Feature | SQL Server Integration Services | SQL Server compatibility level 100 or higher |
+| Feature | SQL Server Integration Services | SQL Server <sup>1</sup> |
 | --- | --- | --- |
 | `DISTINCT` aggregates | Not supported for `WITH CUBE` or `WITH ROLLUP`. | Supported for `WITH CUBE`, `WITH ROLLUP`, `GROUPING SETS`, `CUBE`, or `ROLLUP`. |
-| User-defined function with `CUBE` or `ROLLUP` name in the `GROUP BY` clause | User-defined function `dbo.cube(<arg1>, ...<argN>)` or `dbo.rollup(<arg1>, ...<argN>)` in the `GROUP BY` clause is allowed.<br /><br />For example: `SELECT SUM (x) FROM T GROUP BY dbo.cube(y);` | User-defined function `dbo.cube (<arg1>, ...<argN>)` or `dbo.rollup(arg1>, ...<argN>)` in the `GROUP BY` clause isn't allowed.<br /><br />For example: `SELECT SUM (x) FROM T GROUP BY dbo.cube(y);`<br /><br />SQL Server returns the following error message: "Incorrect syntax near the keyword 'cube'&#124;'rollup'."<br /><br />To avoid this problem, replace `dbo.cube` with `[dbo].[cube]` or `dbo.rollup` with `[dbo].[rollup]`.<br /><br />The following example is allowed: `SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);` |
+| User-defined function with `CUBE` or `ROLLUP` name in the `GROUP BY` clause | User-defined function `dbo.cube(<arg1>, ...<argN>)` or `dbo.rollup(<arg1>, ...<argN>)` in the `GROUP BY` clause is allowed.<br /><br />For example: `SELECT SUM (x) FROM T GROUP BY dbo.cube(y);` | User-defined function `dbo.cube (<arg1>, ...<argN>)` or `dbo.rollup(<arg1>, ...<argN>)` in the `GROUP BY` clause isn't allowed.<br /><br />For example: `SELECT SUM (x) FROM T GROUP BY dbo.cube(y);`<br /><br />SQL Server returns an error message <sup>2</sup>.<br /><br />To avoid this problem, replace `dbo.cube` with `[dbo].[cube]` or `dbo.rollup` with `[dbo].[rollup]`.<br /><br />The following example is allowed: `SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);` |
 | `GROUPING SETS` | Not supported | Supported |
 | `CUBE` | Not supported | Supported |
 | `ROLLUP` | Not supported | Supported |
@@ -439,8 +452,14 @@ The following table describes the `GROUP BY` features that different SQL Server
 | `WITH ROLLUP` | Supported | Supported |
 | `WITH CUBE` or `WITH ROLLUP` "duplicate" grouping removal | Supported | Supported |
 
+<sup>1</sup> [Database compatibility level](../statements/alter-database-transact-sql-compatibility-level.md#differences-between-compatibility-levels) 100 and higher.
+
+<sup>2</sup> The error message returned is: `Incorrect syntax near the keyword 'cube'|'rollup'.`
+
 ## Examples
 
+[!INCLUDE [article-uses-adventureworks](../../includes/article-uses-adventureworks.md)]
+
 ### A. Use a basic GROUP BY clause
 
 The following example retrieves the total for each `SalesOrderID` from the `SalesOrderDetail` table. This example uses AdventureWorks.
@@ -492,7 +511,7 @@ HAVING DATEPART(yyyy, OrderDate) >= N'2003'
 ORDER BY DATEPART(yyyy, OrderDate);
 ```
 
-## Examples: Azure Synapse Analytics and Analytics Platform System / Parallel Data Warehouse (PDW)
+## Examples: Azure Synapse Analytics and Analytics Platform System (PDW)
 
 ### E. Basic use of the GROUP BY clause
 
@@ -530,16 +549,20 @@ 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;
@@ -565,7 +588,7 @@ ORDER BY OrderDateKey;
 
 ### I. Use a GROUP BY clause with a HAVING clause
 
-The following example uses the `HAVING` clause to specify the groups generated in the `GROUP BY` clause that should be included in the result set. Only those groups with order dates in 2004 or later are included in the results.
+The following example uses the `HAVING` clause to specify the groups generated in the `GROUP BY` clause that should be includes in the result set. Only those groups with order dates in 2004 or later are included in the results.
 
 ```sql
 -- Uses AdventureWorks
