SELECT: GROUP BY (Transact-SQL)SELECT - GROUP BY- Transact-SQL

SE APLICA A: síSQL Server síAzure SQL Database síAzure Synapse Analytics (SQL DW) síAlmacenamiento de datos paralelos APPLIES TO: yesSQL Server yesAzure SQL Database yesAzure Synapse Analytics (SQL DW) yesParallel Data Warehouse

Cláusula de la instrucción SELECT que divide el resultado de la consulta en grupos de filas, normalmente con el fin de realizar una o varias agregaciones en cada grupo.A SELECT statement clause that divides the query result into groups of rows, usually for the purpose of performing one or more aggregations on each group. La instrucción SELECT devuelve una fila por grupo.The SELECT statement returns one row per group.

SintaxisSyntax

Icono de vínculo a temas Convenciones de sintaxis de Transact-SQL (Transact-SQL)Topic link icon Transact-SQL Syntax Conventions (Transact-SQL)

-- Syntax for SQL Server and Azure SQL Database   
-- ISO-Compliant Syntax  
  
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 ] )  
  

-- For backward compatibility only.
-- Non-ISO-Compliant Syntax for SQL Server and Azure SQL Database 
  
GROUP BY 
      [ ALL ] column-expression [ ,...n ] 
    | column-expression [ ,...n ] [ WITH { CUBE | ROLLUP } ]   

-- Syntax for Azure SQL Data Warehouse and Parallel Data Warehouse  
  
GROUP BY {
      column-name [ WITH (DISTRIBUTED_AGG) ]  
    | column-expression
    | ROLLUP ( <group_by_expression> [ ,...n ] ) 
} [ ,...n ]

ArgumentosArguments

column-expressioncolumn-expression

Especifica una columna o un cálculo no agregado en una columna.Specifies a column or a non-aggregate calculation on a column. Esta columna puede pertenecer a una tabla, una tabla derivada o una vista.This column can belong to a table, derived table, or view. La columna debe aparecer en la cláusula FROM de la instrucción SELECT, pero no es necesario que aparezca en la lista SELECT.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list.

Para conocer las expresiones válidas, vea Expresiones.For valid expressions, see expression.

La columna debe aparecer en la cláusula FROM de la instrucción SELECT, pero no es necesario que aparezca en la lista SELECT.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list. Aun así, deben incluirse en la lista GROUP BY todas las columnas de la tabla o la vista de cualquier expresión no agregada de la lista de <select>:However, each table or view column in any nonaggregate expression in the <select> list must be included in the GROUP BY list:

Están permitidas las siguientes instrucciones:The following statements are allowed:

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;  

No están permitidas las siguientes instrucciones:The following statements are not allowed:

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

La expresión de columna no puede contener:The column expression cannot contain:

  • Un alias de columna que esté definido en la lista SELECT.A column alias that is defined in the SELECT list. Puede usar un alias de columna para una tabla derivada que esté definida en la cláusula FROM.It can use a column alias for a derived table that is defined in the FROM clause.
  • Una columna de tipo text, ntext o image.A column of type text, ntext, or image. Aun así, puede usar una columna de tipo text, ntext o image como argumento para una función que devuelva un valor de un tipo de datos válido.However, you can use a column of text, ntext, or image as an argument to a function that returns a value of a valid data type. Por ejemplo, la expresión puede usar SUBSTRING() y CAST().For example, the expression can use SUBSTRING() and CAST(). Esto también se aplica a las expresiones de la cláusula HAVING.This also applies to expressions in the HAVING clause.
  • Métodos de tipo de datos xml.xml data type methods. Puede incluir una función definida por el usuario que use métodos de tipo de datos xml.It can include a user-defined function that uses xml data type methods. Puede incluir una columna calculada que use métodos de tipo de datos xml.It can include a computed column that uses xml data type methods.
  • Una subconsulta.A subquery. Se devuelve el error 144.Error 144 is returned.
  • Una columna de una vista indexada.A column from an indexed view.

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

Agrupa los resultados de la instrucción SELECT según los valores en una lista con una o varias expresiones de columna.Groups the SELECT statement results according to the values in a list of one or more column expressions.

Por ejemplo, esta consulta crea una tabla de ventas con columnas para el país, la región y las ventas.For example, this query creates a Sales table with columns for Country, Region, and Sales. Inserta cuatro filas, y dos de las filas tienen valores coincidentes para el país y la región.It inserts four rows and two of the rows have matching values for Country and Region.

CREATE TABLE Sales ( Country varchar(50), Region varchar(50), Sales int );

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);

La tabla de ventas contiene estas filas:The Sales table contains these rows:

PaísCountry RegionRegion SalesSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada Columbia BritánicaBritish Columbia 200200
CanadaCanada Columbia BritánicaBritish Columbia 300300
United StatesUnited States MontanaMontana 100100

La siguiente consulta agrupa el país y la región y devuelve la suma de agregados de cada combinación de valores.This next query groups Country and Region and returns the aggregate sum for each combination of values.

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

El resultado de la consulta tiene tres filas, ya que hay tres combinaciones de valores para el país y la región.The query result has 3 rows since there are 3 combinations of values for Country and Region. El valor de las ventas totales para Canadá y Columbia Británica es la suma de dos filas.The TotalSales for Canada and British Columbia is the sum of two rows.

PaísCountry RegionRegion Ventas totalesTotalSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada Columbia BritánicaBritish Columbia 500500
United StatesUnited States MontanaMontana 100100

GROUP BY ROLLUPGROUP BY ROLLUP

Crea un grupo para cada combinación de expresiones de columna.Creates a group for each combination of column expressions. Además, "acumula" los resultados en subtotales y totales generales.In addition, it "rolls up" the results into subtotals and grand totals. Para ello, mueve de derecha a izquierda reduciendo el número de expresiones de columna para las que crea grupos y agregaciones.To do this, it moves from right to left decreasing the number of column expressions over which it creates groups and the aggregation(s).

El orden de las columnas influye en la salida de ROLLUP y también puede afectar al número de filas del conjunto de resultados.The column order affects the ROLLUP output and can affect the number of rows in the result set.

Por ejemplo, GROUP BY ROLLUP (col1, col2, col3, col4) crea grupos para cada combinación de expresiones de columna en las listas siguientes.For example, GROUP BY ROLLUP (col1, col2, col3, col4) creates groups for each combination of column expressions in the following lists.

  • col1, col2, col3, col4col1, col2, col3, col4
  • col1, col2, col3, NULLcol1, col2, col3, NULL
  • col1, col2, NULL, NULLcol1, col2, NULL, NULL
  • col1, NULL, NULL, NULLcol1, NULL, NULL, NULL
  • NULL, NULL, NULL, NULL (este es el total general)NULL, NULL, NULL, NULL --This is the grand total

Con la tabla del ejemplo anterior, este código ejecuta una operación GROUP BY ROLLUP en lugar de una operación GROUP BY simple.Using the table from the previous example, this code runs a GROUP BY ROLLUP operation instead of a simple GROUP BY.

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

El resultado de la consulta tiene las mismas agregaciones que la operación GROUP BY simple sin ROLLUP.The query result has the same aggregations as the simple GROUP BY without the ROLLUP. Además, crea subtotales para cada valor de país.In addition, it creates subtotals for each value of Country. Por último, proporciona un total general para todas las filas.Finally, it gives a grand total for all rows. El resultado tiene el aspecto siguiente:The result looks like this:

PaísCountry RegionRegion Ventas totalesTotalSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada Columbia BritánicaBritish Columbia 500500
CanadaCanada NULLNULL 600600
United StatesUnited States MontanaMontana 100100
United StatesUnited States NULLNULL 100100
NULLNULL NULLNULL 700700

GROUP BY CUBE ( )GROUP BY CUBE ( )

GROUP BY CUBE crea grupos para todas las combinaciones posibles de columnas.GROUP BY CUBE creates groups for all possible combinations of columns. Para GROUP BY CUBE (a, b), el resultado tiene grupos de valores únicos de (a, b), (NULL, b), (a, NULL) y (NULL, NULL).For GROUP BY CUBE (a, b) the results has groups for unique values of (a, b), (NULL, b), (a, NULL), and (NULL, NULL).

Con la tabla de los ejemplos anteriores, este código ejecuta una operación GROUP BY CUBE en el país y la región.Using the table from the previous examples, this code runs a GROUP BY CUBE operation on Country and Region.

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

El resultado de la consulta tiene grupos para valores únicos de (Country, Region), (NULL, Region), (Country, NULL) y (NULL, NULL).The query result has groups for unique values of (Country, Region), (NULL, Region), (Country, NULL), and (NULL, NULL). El resultado tiene el aspecto siguiente:The results look like this:

PaísCountry RegionRegion Ventas totalesTotalSales
CanadaCanada AlbertaAlberta 100100
NULLNULL AlbertaAlberta 100100
CanadaCanada Columbia BritánicaBritish Columbia 500500
NULLNULL Columbia BritánicaBritish Columbia 500500
United StatesUnited States MontanaMontana 100100
NULLNULL MontanaMontana 100100
NULLNULL NULLNULL 700700
CanadaCanada NULLNULL 600600
United StatesUnited States NULLNULL 100100

GROUP BY GROUPING SETS ( )GROUP BY GROUPING SETS ( )

La opción GROUPING SETS permite combinar varias cláusulas GROUP BY en una cláusula GROUP BY.The GROUPING SETS option gives you the ability to combine multiple GROUP BY clauses into one GROUP BY clause. Los resultados son equivalentes a usar la instrucción UNION ALL en los grupos especificados.The results are the equivalent of UNION ALL of the specified groups.

Por ejemplo, GROUP BY ROLLUP (Country, Region) y GROUP BY GROUPING SETS ( ROLLUP (Country, Region) ) devuelven los mismos resultados.For example, GROUP BY ROLLUP (Country, Region) and GROUP BY GROUPING SETS ( ROLLUP (Country, Region) ) return the same results.

Cuando GROUPING SETS tiene dos o más elementos, los resultados son la unión de los elementos.When GROUPING SETS has two or more elements, the results are a union of the elements. En este ejemplo se devuelve la unión de los resultados ROLLUP y CUBE para el país y la región.This example returns the union of the ROLLUP and CUBE results for Country and Region.

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

Los resultados son los mismos que los de esta consulta que devuelve la unión de las dos instrucciones GROUP BY.The results are the same as this query that returns a union of the two GROUP BY statements.

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

SQL no consolida los grupos duplicados generados para una lista GROUPING SETS.SQL does not consolidate duplicate groups generated for a GROUPING SETS list. Por ejemplo, en GROUP BY ( (), CUBE (Country, Region) ), ambos elementos devuelven una fila para el total general y ambas filas se mostrarán en los resultados.For example, in GROUP BY ( (), CUBE (Country, Region) ), both elements return a row for the grand total and both rows will be listed in the results.

GROUP BY ()GROUP BY ()

Especifica el grupo vacío que genera el total general.Specifies the empty group which generates the grand total. Esto resulta útil como uno de los elementos de GROUPING SET.This is useful as one of the elements of a GROUPING SET. Por ejemplo, esta instrucción proporciona el total de ventas de cada país y, después, el total general para todos los países.For example, this statement gives the total sales for each country and then gives the grand-total for all countries.

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

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

Se aplica a: SQL Server y Azure SQL DatabaseApplies to: SQL Server and Azure SQL Database

NOTA: Esta sintaxis se proporciona únicamente por motivos de compatibilidad con versiones anteriores.NOTE: This syntax is provided for backward compatibility only. Se quitará en una versión futura.It will be removed in a future version. Evite usar esta sintaxis en nuevos trabajos de desarrollo y tenga previsto modificar las aplicaciones que actualmente la usan.Avoid using this syntax in new development work, and plan to modify applications that currently use this syntax.

Especifica que se incluyen todos los grupos en los resultados independientemente de que cumplan los criterios de búsqueda en la cláusula WHERE.Specifies to include all groups in the results regardless of whether they meet the search criteria in the WHERE clause. Los grupos que no cumplen los criterios de búsqueda tienen el valor NULL para la agregación.Groups that don't meet the search criteria have NULL for the aggregation.

GROUP BY ALL:GROUP BY ALL:

  • No se admite en consultas que tienen acceso a tablas remotas si también hay una cláusula WHERE en la consulta.Is not supported in queries that access remote tables if there is also a WHERE clause in the query.
  • Generará un error en las columnas que tengan el atributo FILESTREAM.Will fail on columns that have the FILESTREAM attribute.

WITH (DISTRIBUTED_AGG)WITH (DISTRIBUTED_AGG)

Se aplica a: Azure SQL Data Warehouse y Almacenamiento de datos paralelosApplies to: Azure SQL Data Warehouse and Parallel Data Warehouse

La sugerencia de consulta DISTRIBUTED_AGG obliga al sistema de procesamiento paralelo masivo (MPP) a redistribuir una tabla en una columna específica antes de realizar una agregación.The DISTRIBUTED_AGG query hint forces the massively parallel processing (MPP) system to redistribute a table on a specific column before performing an aggregation. Solo una columna de la cláusula GROUP BY puede tener una sugerencia de consulta DISTRIBUTED_AGG.Only one column in the GROUP BY clause can have a DISTRIBUTED_AGG query hint. Una vez finalizada la consulta, se quita la tabla redistribuida.After the query finishes, the redistributed table is dropped. La tabla original no se cambia.The original table is not changed.

NOTA: La sugerencia de consulta DISTRIBUTED_AGG se proporciona para ofrecer compatibilidad con versiones anteriores de Almacenamiento de datos paralelos y no mejorará el rendimiento de la mayoría de las consultas.NOTE: The DISTRIBUTED_AGG query hint is provided for backwards compatibility with earlier Parallel Data Warehouse versions and will not improve performance for most queries. De forma predeterminada, MPP redistribuye los datos según sea necesario para mejorar el rendimiento de las agregaciones.By default, MPP already redistributes data as necessary to improve performance for aggregations.

Notas generalesGeneral Remarks

Cómo interactúa GROUP BY con la instrucción SELECTHow GROUP BY interacts with the SELECT statement

Lista SELECT:SELECT list:

  • Agregados vectoriales.Vector aggregates. Si se incluyen funciones de agregado en la lista SELECT, GROUP BY calcula un valor de resumen para cada grupo.If aggregate functions are included in the SELECT list, GROUP BY calculates a summary value for each group. Se conocen como agregados vectoriales.These are known as vector aggregates.
  • Agregados distintos.Distinct aggregates. Los agregados AVG (DISTINCT column_name), COUNT (DISTINCT column_name) y SUM (DISTINCT column_name) se admiten con ROLLUP, CUBE, and GROUPING SETS.The aggregates AVG (DISTINCT column_name), COUNT (DISTINCT column_name), and SUM (DISTINCT column_name) are supported with ROLLUP, CUBE, and GROUPING SETS.

Cláusula WHERE:WHERE clause:

  • SQL quita las filas que no cumplen las condiciones especificadas en la cláusula WHERE antes de realizar ninguna operación de agrupación.SQL removes Rows that do not meet the conditions in the WHERE clause before any grouping operation is performed.

Cláusula HAVING:HAVING clause:

  • SQL usa la cláusula HAVING para filtrar los grupos en el conjunto de resultados.SQL uses the having clause to filter groups in the result set.

Cláusula ORDER BY:ORDER BY clause:

  • En su lugar, use la cláusula ORDER BY para ordenarlo.Use the ORDER BY clause to order the result set. La cláusula GROUP BY no ordena el conjunto de resultados.The GROUP BY clause does not order the result set.

Valores NULL:NULL values:

  • Si una columna de agrupamiento contiene valores NULL, todos ellos se consideran equivalentes y se recopilan en un solo grupo.If a grouping column contains NULL values, all NULL values are considered equal and they are collected into a single group.

Limitaciones y restriccionesLimitations and Restrictions

Se aplica a: SQL Server (a partir de 2008) y Azure SQL Data WarehouseApplies to: SQL Server (starting with 2008) and Azure SQL Data Warehouse

Capacidad máximaMaximum capacity

Para una cláusula GROUP BY que usa ROLLUP, CUBE o GROUPING SETS, el número máximo de expresiones es 32.For a GROUP BY clause that uses ROLLUP, CUBE, or GROUPING SETS, the maximum number of expressions is 32. El número máximo de grupos es 4096 (212).The maximum number of groups is 4096 (212). En los ejemplos siguientes se produce un error debido a que la cláusula GROUP BY tiene más de 4096 grupos.The following examples fail because the GROUP BY clause has more than 4096 groups.

  • En el ejemplo siguiente se generan 4097 (212 + 1) conjuntos de agrupamiento y se producirá un error.The following example generates 4097 (212 + 1) grouping sets and will fail.

    GROUP BY GROUPING SETS( CUBE(a1, ..., a12), b )  
    
  • En el ejemplo siguiente se generan 4097 (212 + 1) grupos y se producirá un error.The following example generates 4097 (212 + 1) groups and will fail. Los conjuntos de agrupación CUBE () y () generan una fila de total general y los conjuntos de agrupación duplicados no se eliminan.Both CUBE () and the () grouping set produce a grand total row and duplicate grouping sets are not eliminated.

    GROUP BY GROUPING SETS( CUBE(a1, ..., a12), ())  
    
  • En este ejemplo se usa sintaxis compatible con versiones anteriores.This example uses the backwards compatible syntax. Se generan se generan 8192 (213) conjuntos de agrupamiento y se producirá un error.It generates 8192 (213) grouping sets and will fail.

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

    En las cláusulas GROUP BY compatibles con versiones anteriores que no contengan CUBE o ROLLUP, el número de grupos por elementos está limitado por los tamaños de columna de GROUP BY, las columnas de agregado y los valores de agregado que participan en la consulta.For backwards compatible GROUP BY clauses that do not contain CUBE or ROLLUP, the number of group by items is limited by the GROUP BY column sizes, the aggregated columns, and the aggregate values involved in the query. Este límite procede del límite de 8.060 bytes de la tabla de trabajo intermedia que se necesita para contener los resultados intermedios de la consulta.This limit originates from the limit of 8,060 bytes on the intermediate worktable that is needed to hold intermediate query results. Se permite un máximo de 12 expresiones de agrupamiento cuando se especifica CUBE o ROLLUP.A maximum of 12 grouping expressions is permitted when CUBE or ROLLUP is specified.

Compatibilidad con las características GROUP BY de ISO y ANSI SQL-2006Support for ISO and ANSI SQL-2006 GROUP BY Features

La cláusula GROUP BY admite todas las características GROUP BY incluidas en el estándar SQL-2006 con las excepciones de sintaxis siguientes:The GROUP BY clause supports all GROUP BY features that are included in the SQL-2006 standard with the following syntax exceptions:

  • Los conjuntos de agrupamiento no se pueden usar en la cláusula GROUP BY a menos que formen parte de una lista GROUPING SETS explícita.Grouping sets are not allowed in the GROUP BY clause unless they are part of an explicit GROUPING SETS list. Por ejemplo, GROUP BY Column1, (Column2, ...ColumnN) se admite en el estándar, pero no en Transact-SQL.For example, GROUP BY Column1, (Column2, ...ColumnN) is allowed in the standard but not in Transact-SQL. Transact-SQL admite GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)) y GROUP BY Column1, Column2, ... ColumnN, que son equivalentes semánticamente.Transact-SQL supports GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)) and GROUP BY Column1, Column2, ... ColumnN, which are semantically equivalent. Éstos son equivalentes semánticamente al ejemplo de GROUP BY anterior.These are semantically equivalent to the previous GROUP BY example. Con ello se evita la posibilidad de que GROUP BY Column1, (Column2, ...ColumnN) se pueda malinterpretar como GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), que no son equivalentes semánticamente.This is to avoid the possibility that GROUP BY Column1, (Column2, ...ColumnN) might be misinterpreted as GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), which are not semantically equivalent.

  • No se pueden usar conjuntos de agrupamiento dentro de conjuntos de agrupamiento.Grouping sets are not allowed inside grouping sets. Por ejemplo, GROUP BY GROUPING SETS (A1, A2,...An, GROUPING SETS (C1, C2, ...Cn)) se admite en el estándar SQL-2006, pero no en Transact-SQL.For example, GROUP BY GROUPING SETS (A1, A2,...An, GROUPING SETS (C1, C2, ...Cn)) is allowed in the SQL-2006 standard but not in Transact-SQL. Transact-SQL admite GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn ) o GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn) ), que son equivalentes semánticamente al primer ejemplo de GROUP BY y tienen una sintaxis más clara.Transact-SQL allows GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn ) or GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn) ), which are semantically equivalent to the first GROUP BY example and have a more clear syntax.

  • GROUP BY [ALL/DISTINCT] solo se permite en una cláusula GROUP BY simple que contenga expresiones de columna.GROUP BY [ALL/DISTINCT] is only allowed in a simple GROUP BY clause that contains column expressions. No se permite con las construcciones GROUPING SETS, ROLLUP, CUBE, WITH CUBE o WITH ROLLUP.It is not allowed with the GROUPING SETS, ROLLUP, CUBE, WITH CUBE or WITH ROLLUP constructs. ALL es el valor predeterminado y es implícito.ALL is the default and is implicit. Solo se permite en sintaxis compatible con versiones anteriores.It is also only allowed in the backwards compatible syntax.

Comparación de las características GROUP BY compatiblesComparison of Supported GROUP BY Features

En la tabla siguiente se describen las características de GROUP BY que son compatibles en función de las versiones de SQL y del nivel de compatibilidad de la base de datos.The following table describes the GROUP BY features that are supported based upon SQL versions and database compatibility level.

CaracterísticaFeature SQL Server Integration ServicesSQL Server Integration Services Nivel de compatibilidad 100 o superior con SQL ServerSQL Server compatibility level 100 or higher SQL Server 2008 o posterior con el nivel de compatibilidad 90.SQL Server 2008 or later with compatibility level 90.
Agregados DISTINCTDISTINCT aggregates No se admite en WITH CUBE ni en WITH ROLLUP.Not supported for WITH CUBE or WITH ROLLUP. Se admite en WITH CUBE, WITH ROLLUP, GROUPING SETS, CUBE o ROLLUP.Supported for WITH CUBE, WITH ROLLUP, GROUPING SETS, CUBE, or ROLLUP. Igual que el nivel de compatibilidad 100.Same as compatibility level 100.
Función definida por el usuario con un nombre CUBE o ROLLUP en la cláusula GROUP BYUser-defined function with CUBE or ROLLUP name in the GROUP BY clause Se admite la función definida por el usuario dbo.cube( arg1 , ...argN ) o dbo.rollup( arg1 , ...argN ) en la cláusula GROUP BY.User-defined function dbo.cube(arg1,...argN) or dbo.rollup(arg1,...argN) in the GROUP BY clause is allowed.

Por ejemplo, SELECT SUM (x) FROM T GROUP BY dbo.cube(y);For example: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);
No se admite la función definida por el usuario dbo.cube ( arg1 , ...argN ) o dbo.rollup( arg1 , ...argN ) en la cláusula GROUP BY.User-defined function dbo.cube (arg1,...argN ) or dbo.rollup( arg1 ,...argN) in the GROUP BY clause is not allowed.

Por ejemplo, SELECT SUM (x) FROM T GROUP BY dbo.cube(y);For example: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);

Se devuelve un mensaje de error que indica lo siguiente: "Sintaxis incorrecta cerca de la palabra clave "cube"|"rollup"."The following error message is returned: "Incorrect syntax near the keyword 'cube'|'rollup'."

Para evitar este problema, reemplace dbo.cube por [dbo].[cube] o dbo.rollup por [dbo].[rollup].To avoid this problem, replace dbo.cube with [dbo].[cube] or dbo.rollup with [dbo].[rollup].

Se admite el siguiente ejemplo: SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);.The following example is allowed: SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);
Se admite la función definida por el usuario dbo.cube ( arg1 , ...argN) o dbo.rollup( arg1 , ...argN ) en la cláusula GROUP BY.User-defined function dbo.cube (arg1,...argN) or dbo.rollup(arg1,...argN) in the GROUP BY clause is allowed

Por ejemplo, SELECT SUM (x) FROM T GROUP BY dbo.cube(y);For example: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);
GROUPING SETSGROUPING SETS No compatibleNot supported AdmitidaSupported AdmitidaSupported
CUBECUBE No compatibleNot supported AdmitidaSupported No compatibleNot supported
ROLLUPROLLUP No compatibleNot supported AdmitidaSupported No compatibleNot supported
Total general, como GROUP BY ()Grand total, such as GROUP BY () No compatibleNot supported AdmitidaSupported AdmitidaSupported
GROUPING_ID, funciónGROUPING_ID function No compatibleNot supported AdmitidaSupported AdmitidaSupported
GROUPING, funciónGROUPING function AdmitidaSupported AdmitidaSupported AdmitidaSupported
WITH CUBEWITH CUBE AdmitidaSupported AdmitidaSupported AdmitidaSupported
WITH ROLLUPWITH ROLLUP AdmitidaSupported AdmitidaSupported AdmitidaSupported
Eliminación de grupos duplicados de WITH CUBE o WITH ROLLUPWITH CUBE or WITH ROLLUP "duplicate" grouping removal AdmitidaSupported AdmitidaSupported AdmitidaSupported

EjemplosExamples

A.A. Usar una cláusula GROUP BY simpleUse a simple GROUP BY clause

En el ejemplo siguiente se recupera el total de cada SalesOrderID de la tabla SalesOrderDetail.The following example retrieves the total for each SalesOrderID from the SalesOrderDetail table. En este ejemplo se usa AdventureWorks.This example uses AdventureWorks.

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

B.B. Usar una cláusula GROUP BY con varias tablasUse a GROUP BY clause with multiple tables

En el ejemplo siguiente se recupera el número de empleados de cada City de la tabla Address combinada con la tabla EmployeeAddress.The following example retrieves the number of employees for each City from the Address table joined to the EmployeeAddress table. En este ejemplo se usa AdventureWorks.This example uses AdventureWorks.

SELECT a.City, COUNT(bea.AddressID) 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.C. Usar una cláusula GROUP BY con una expresiónUse a GROUP BY clause with an expression

En el ejemplo siguiente se recuperan las ventas totales de cada año con la función DATEPART.The following example retrieves the total sales for each year by using the DATEPART function. Debe incluirse la misma expresión en la lista SELECT y en la cláusula GROUP BY.The same expression must be present in both the SELECT list and GROUP BY clause.

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.D. Usar una cláusula GROUP BY con una cláusula HAVINGUse a GROUP BY clause with a HAVING clause

En el ejemplo siguiente se usa la cláusula HAVING para especificar cuáles de los grupos generados en la cláusula GROUP BY deben incluirse en el conjunto de resultados.The following example uses the HAVING clause to specify which of the groups generated in the GROUP BY clause should be included in the result set.

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);  

Ejemplos: SQL Data Warehouse y almacenamiento de datos paralelosExamples: SQL Data Warehouse and Parallel Data Warehouse

E.E. Uso básico de la cláusula GROUP BYBasic use of the GROUP BY clause

En el ejemplo siguiente se busca la cantidad total de todas las ventas de cada día.The following example finds the total amount for all sales on each day. Se devuelve para cada día una fila que contiene la suma de todas las ventas.One row containing the sum of all sales is returned for each day.

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

F.F. Uso básico de la sugerencia DISTRIBUTED_AGGBasic use of the DISTRIBUTED_AGG hint

En este ejemplo se usa la sugerencia de consulta DISTRIBUTED_AGG para forzar a que el dispositivo ordene la tabla en la columna CustomerKey antes de realizar la agregación.This example uses the DISTRIBUTED_AGG query hint to force the appliance to shuffle the table on the CustomerKey column before performing the aggregation.

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

G.G. Variaciones de sintaxis para GROUP BYSyntax Variations for GROUP BY

Cuando la lista SELECT no tiene agregaciones, todas las columnas de la lista SELECT deben incluirse en la lista GROUP BY.When the select list has no aggregations, each column in the select list must be included in the GROUP BY list. Las columnas calculadas de la lista SELECT pueden mostrarse en la lista GROUP BY, pero no son necesarias.Computed columns in the select list can be listed, but are not required, in the GROUP BY list. Estos son algunos ejemplos de instrucciones SELECT correctas sintácticamente:These are examples of syntactically valid SELECT statements:

-- 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 SalesTax FROM FactInternetSales GROUP BY SalesAmount;  
SELECT SalesAmount FROM FactInternetSales GROUP BY SalesAmount, SalesAmount*1.10;  

H.H. Usar GROUP BY con varias expresiones GROUP BYUsing a GROUP BY with multiple GROUP BY expressions

En el ejemplo siguiente se agrupan los resultados mediante varios criterios GROUP BY.The following example groups results using multiple GROUP BY criteria. Si dentro de cada grupo OrderDateKey hay subgrupos que se pueden diferenciar mediante DueDateKey, se definirá una nueva agrupación para el conjunto de resultados.If, within each OrderDateKey group, there are subgroups that can be differentiated by DueDateKey, a new grouping will be defined for the result set.

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

I.I. Utilizar una cláusula GROUP BY con una cláusula HAVINGUsing a GROUP BY clause with a HAVING clause

En el ejemplo siguiente se usa la cláusula HAVING para especificar los grupos generados en la cláusula GROUP BY que deben incluirse en el conjunto de resultados.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. Solo se incluirán en los resultados los grupos con fechas de pedido de 2004 o años posteriores.Only those groups with order dates in 2004 or later will be included in the results.

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

Consulte tambiénSee Also

GROUPING_ID (Transact-SQL) GROUPING_ID (Transact-SQL)
GROUPING (Transact-SQL) GROUPING (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
Cláusula SELECT (Transact-SQL)SELECT Clause (Transact-SQL)