Seleccione - GROUP BY de Transact-SQLSELECT - GROUP BY- Transact-SQL

ESTE TEMA SE APLICA A: síSQL Server (a partir de 2008)síAzure SQL DatabasesíAzure SQL Data Warehouse síAlmacenamiento de datos paralelos THIS TOPIC APPLIES TO: yesSQL Server (starting with 2008)yesAzure SQL DatabaseyesAzure SQL Data Warehouse yesParallel Data Warehouse

Una 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 cada grupo.The SELECT statement returns one row per group.

SintaxisSyntax

Icono de vínculo de tema 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
} [ ,...n ]

ArgumentosArguments

expresión de columnacolumn-expression

Especifica una columna o un cálculo de agregado no 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 necesaria que aparezcan en la lista de selección.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list.

Para las expresiones válidas, vea expresión.For valid expressions, see expression.

La columna debe aparecer en la cláusula FROM de la instrucción SELECT, pero no es necesaria que aparezcan en la lista de selección.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list. Sin embargo, cada tabla o vista de columna en una expresión no agregada en el <seleccione > lista debe incluirse en la lista GROUP BY: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 se define en la lista de selección.A column alias that is defined in the SELECT list. Puede usar un alias de columna para una tabla derivada que se define 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 texto, ntext, o imagen.A column of type text, ntext, or image. Sin embargo, puede usar una columna de text, ntext o image como argumento a una función que devuelve 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, puede usar la expresión 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 utiliza los 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 usa los 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 indizada.A column from an indexed view.

GROUP BY expresión de columna [,.. .n]GROUP BY column-expression [ ,...n ]

Agrupa los resultados de la instrucción SELECT según los valores en una lista de 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 las columnas de país, región y 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 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 país y región y devuelve la suma de agregados para 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 3 filas puesto que hay 3 combinaciones de valores de país y región.The query result has 3 rows since there are 3 combinations of values for Country and Region. El valor de TotalSales 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 TotalSalesTotalSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada Columbia BritánicaBritish Columbia 500500
United StatesUnited States MontanaMontana 100100

AGRUPAR POR EL PAQUETE ACUMULATIVO DE ACTUALIZACIONESGROUP BY ROLLUP

Crea un grupo para cada combinación de expresiones de columna.Creates a group for each combination of column expressions. Además, "acumulan" 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 así el número de expresiones de columna en la que crea grupos y la aggregation(s).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 afecta a la salida del paquete acumulativo de actualizaciones y 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 generalNULL, 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 cláusula 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 como simple GROUP BY sin el paquete acumulativo de actualizaciones.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, le ofrece un total general para todas las filas.Finally, it gives a grand total for all rows. El resultado tiene el siguiente aspecto:The result looks like this:

PaísCountry RegionRegion TotalSalesTotalSales
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

AGRUPAR POR () DE CUBOGROUP BY CUBE ( )

GROUP BY CUBE crea grupos para todas las posibles combinaciones de columnas.GROUP BY CUBE creates groups for all possible combinations of columns. Para GROUP BY CUBE (a, b) los resultados tiene grupos de valores únicos (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 país y 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 de valores únicos de (país, región), (NULL, región), (país, NULL) y (NULL, NULL).The query result has groups for unique values of (Country, Region), (NULL, Region), (Country, NULL), and (NULL, NULL). El resultado tendrá este aspecto:The results look like this:

PaísCountry RegionRegion TotalSalesTotalSales
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

AGRUPAR POR () DE CONJUNTOS DE AGRUPACIÓNGROUP BY GROUPING SETS ( )

La opción de GROUPING SETS le ofrece la capacidad de 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 los conjuntos de agrupación 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. Este ejemplo devuelve la unión de los resultados ROLLUP y CUBE para país y 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 la 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 Consolide grupos duplicados generados para obtener 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 devolver 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 un conjunto de agrupación.This is useful as one of the elements of a GROUPING SET. Por ejemplo, esta instrucción da como resultado el total de ventas de cada país y, a continuación, proporciona 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]-expresión de columna [,.. .n]GROUP BY [ ALL ] column-expression [ ,...n ]

Se aplica a: SQL Server y base de datos SQL AzureApplies to: SQL Server and Azure SQL Database

Nota: Esta sintaxis se proporciona por razones de compatibilidad.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 utilizar esta sintaxis en nuevos trabajos de desarrollo y piense en modificar las aplicaciones que actualmente utilizan esta sintaxis.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. 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.

AGRUPAR POR TODOS:GROUP BY ALL:

  • No se admite en las 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.
  • Se producirá un error en las columnas que tienen el atributo FILESTREAM.Will fail on columns that have the FILESTREAM attribute.

CON (DISTRIBUTED_AGG)WITH (DISTRIBUTED_AGG)

Se aplica a: almacenamiento de datos SQL Azure 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) para 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 en 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. No se cambia la tabla original.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 paralelo y no mejorará el rendimiento para 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 ya 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 agrupar por interactúa con la instrucción SELECTHow GROUP BY interacts with the SELECT statement

Lista de selección: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 DISTINCT.Distinct aggregates. Los agregados AVG (DISTINCT column_name), COUNT (DISTINCT column_name) y SUM (DISTINCT column_name) son compatibles con ROLLUP, CUBE y 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 de la cláusula WHERE antes de realiza cualquier 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 utiliza el tener cláusula para filtrar los grupos del 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 los valores NULL se consideran iguales y que se recopilan en un único 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 almacenamiento de datos de SQL AzureApplies to: SQL Server (starting with 2008) and Azure SQL Data Warehouse

Capacidad máximaMaximum capacity

Para una cláusula GROUP BY que utiliza 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 4.096 (212).The maximum number of groups is 4096 (212). Los ejemplos siguientes producirá un error porque 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 genera 4.097 (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 genera 4.097 (212 + 1) agrupa 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), ())  
    
  • Este ejemplo utiliza la sintaxis compatible con versiones anteriores.This example uses the backwards compatible syntax. Genera 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   
    

    Compatible con versiones anteriores con las cláusulas GROUP BY que no contengan CUBE o ROLLUP, el número de grupo de elementos está limitado por el grupo por tamaño de las columnas, las columnas de agregado y los valores de agregado implicados 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 es compatible con todas las características GROUP BY que se incluyen en el estándar SQL-2006 con las siguientes excepciones de sintaxis: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 semánticamente equivalentes.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. Esto es para evitar la posibilidad de que GROUP BY Column1, (Column2, ...ColumnN) se pueda malinterpretar como GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), que no son semánticamente equivalentes.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 permite 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 permite GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn ) o GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn) ), que son semánticamente equivalentes para el 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 contiene 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 la 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 describe las características GROUP BY que son compatibles en función de las versiones de SQL y el nivel de compatibilidad de 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 Función definida por el usuario dbo.cube (arg1,.. .argN) o dbo.Rollup (arg1,... argN) en GROUP BY se permite la cláusula.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);
Función definida por el usuario dbo.cube (arg1,.. .argN) o dbo.rollup (arg1,.. .argN) en GROUP BY no se permite la cláusula.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 el siguiente mensaje de error: "sintaxis incorrecta cerca de la palabra clave"cubo"' |' paquete acumulativo de actualizaciones '. "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 permite en el ejemplo siguiente: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);
Función definida por el usuario dbo.cube (arg1,.. .argN) o dbo.rollup ( arg1,.. .argN) en GROUP BY se permite la cláusulaUser-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. Este ejemplo utiliza AdventureWorks.This example uses AdventureWorks.

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

B.B. Utilice 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. Este ejemplo utiliza 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. Utilice 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: Almacenamiento de datos SQL 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 una fila que contiene la suma de todas las ventas para cada día.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

Este ejemplo utiliza la sugerencia de consulta DISTRIBUTED_AGG para forzar que el dispositivo a la selección aleatoria de la tabla en la CustomerKey columna 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 agrupar porSyntax Variations for GROUP BY

Cuando la lista de selección no tiene ninguna agregación, cada columna de la lista de selección debe 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 de selección pueden ser que se muestran, pero no son necesarias, en la lista GROUP BY.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 sintácticamente válidas: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 de GROUP BYUsing a GROUP BY with multiple GROUP BY expressions

En el ejemplo siguiente se agrupa los resultados utilizando varias GROUP BY criterios.The following example groups results using multiple GROUP BY criteria. If, dentro de cada OrderDateKey grupo, hay subgrupos que se pueden diferenciar por 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 FactInternetSalesGROUP 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 el HAVING cláusula para especificar los grupos generados en el GROUP BY cláusula que debe 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. Sólo los grupos con fechas de pedidos en 2004 o una versión posterior se incluirán en los resultados.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;  

Vea tambiénSee Also

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