SELECT - GROUP BY- Transact-SQLSELECT - GROUP BY- Transact-SQL

S’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data WarehouseS’applique à :Applies to: ouiSQL ServerSQL Server (toutes les versions prises en charge) yesSQL ServerSQL Server (all supported versions) OuiAzure SQL DatabaseAzure SQL DatabaseYesAzure SQL DatabaseAzure SQL Database OuiAzure SQL Managed InstanceAzure SQL Managed InstanceYesAzure SQL Managed InstanceAzure SQL Managed Instance ouiAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics ouiParallel Data WarehouseParallel Data WarehouseyesParallel Data WarehouseParallel Data Warehouse

Clause de l’instruction SELECT qui scinde le résultat de la requête en groupes de lignes, généralement pour effectuer ensuite une ou plusieurs agrégations sur chaque groupe.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. L’instruction SELECT retourne une ligne par groupe.The SELECT statement returns one row per group.

SyntaxeSyntax

Icône du lien de rubrique Conventions de la syntaxe 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 Synapse Analytics 
  
GROUP BY {
      column-name [ WITH (DISTRIBUTED_AGG) ]  
    | column-expression
    | ROLLUP ( <group_by_expression> [ ,...n ] ) 
} [ ,...n ]

-- Syntax for Parallel Data Warehouse  
  
GROUP BY {
      column-name [ WITH (DISTRIBUTED_AGG) ]  
    | column-expression
} [ ,...n ]

Notes

Pour afficher la syntaxe Transact-SQL pour SQL Server 2014 et versions antérieures, consultez Versions antérieures de la documentation.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumentsArguments

column-expressioncolumn-expression

Spécifie une colonne ou un calcul non agrégé sur une colonne.Specifies a column or a non-aggregate calculation on a column. Il peut s’agir d’une colonne d’une table, d’une table dérivée ou d’une vue.This column can belong to a table, derived table, or view. La colonne doit figurer dans la clause FROM de l’instruction SELECT, mais elle n’est pas obligatoire dans la liste SELECT.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list.

Pour connaître les expressions valides, consultez expression.For valid expressions, see expression.

La colonne doit figurer dans la clause FROM de l’instruction SELECT, mais elle n’est pas obligatoire dans la liste SELECT.The column must appear in the FROM clause of the SELECT statement, but is not required to appear in the SELECT list. Toutefois, chaque colonne de table ou de vue dans une expression non agrégée de la liste <select> doit être dans la liste GROUP BY :However, each table or view column in any nonaggregate expression in the <select> list must be included in the GROUP BY list:

Les instructions suivantes sont autorisées :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;  

Les instructions suivantes ne sont pas autorisées :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;  

L’expression de colonne ne peut pas contenir les éléments suivants :The column expression cannot contain:

  • Un alias de colonne qui est défini dans la liste SELECT.A column alias that is defined in the SELECT list. Vous pouvez utiliser un alias de colonne pour une table dérivée qui est définie dans la clause FROM.It can use a column alias for a derived table that is defined in the FROM clause.
  • Une colonne de type text, ntext ou image.A column of type text, ntext, or image. Toutefois, vous pouvez utiliser une colonne text, ntext ou image comme argument d’une fonction qui retourne une valeur d’un type de données valide.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. Par exemple, l’expression peut utiliser SUBSTRING() et CAST().For example, the expression can use SUBSTRING() and CAST(). Cela s’applique aussi aux expressions définies dans la clause HAVING.This also applies to expressions in the HAVING clause.
  • Des méthodes ayant le type de données xml.xml data type methods. L’expression peut inclure une fonction définie par l’utilisateur qui utilise des méthodes de type de données xml.It can include a user-defined function that uses xml data type methods. Elle peut inclure une colonne calculée qui utilise des méthodes de ce type.It can include a computed column that uses xml data type methods.
  • Une sous-requête.A subquery. L’erreur 144 est retournée.Error 144 is returned.
  • Une colonne d’une vue indexée.A column from an indexed view.

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

Regroupe les résultats de l’instruction SELECT en fonction des valeurs dans une liste contenant une ou plusieurs expressions de colonne.Groups the SELECT statement results according to the values in a list of one or more column expressions.

Par exemple, cette requête crée une table Sales avec les colonnes Country, Region et Sales.For example, this query creates a Sales table with columns for Country, Region, and Sales. Elle insère quatre lignes, dont deux ont des valeurs identiques dans les colonnes Country et Region.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 table Sales contient les lignes suivantes :The Sales table contains these rows:

CountryCountry RegionRegion VentesSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada British ColumbiaBritish Columbia 200200
CanadaCanada British ColumbiaBritish Columbia 300300
États-UnisUnited States MontanaMontana 100100

La requête suivante regroupe les résultats par pays (colonne Country) et par région (colonne Region), et retourne la somme agrégée de chaque combinaison de valeurs.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;

La requête retourne trois lignes de résultats, car il y a trois combinaisons de valeurs pour les colonnes Country et Region.The query result has 3 rows since there are 3 combinations of values for Country and Region. Le montant total des ventes (TotalSales) pour les pays Canada et British Columbia correspond à la somme de deux lignes.The TotalSales for Canada and British Columbia is the sum of two rows.

CountryCountry RégionRegion TotalSalesTotalSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada British ColumbiaBritish Columbia 500500
États-UnisUnited States MontanaMontana 100100

GROUP BY ROLLUPGROUP BY ROLLUP

Crée un groupe pour chaque combinaison d’expressions de colonne.Creates a group for each combination of column expressions. De plus, l’instruction regroupe les résultats en sous-totaux et en totaux globaux.In addition, it "rolls up" the results into subtotals and grand totals. Pour cela, elle va de droite à gauche en diminuant le nombre d’expressions de colonne sur lesquelles elle crée des groupes et chaque agrégation.To do this, it moves from right to left decreasing the number of column expressions over which it creates groups and the aggregation(s).

L'ordre des colonnes affecte la sortie de ROLLUP et peut affecter le nombre de lignes du jeu de résultats.The column order affects the ROLLUP output and can affect the number of rows in the result set.

Par exemple, GROUP BY ROLLUP (col1, col2, col3, col4) crée des groupes pour chaque combinaison d’expressions de colonne dans les listes suivantes.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 (total global)NULL, NULL, NULL, NULL --This is the grand total

En utilisant la table de l’exemple précédent, ce code exécute une opération GROUP BY ROLLUP au lieu d’une opération 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);

Le résultat de la requête a les mêmes agrégations que l’opération GROUP BY simple sans ROLLUP.The query result has the same aggregations as the simple GROUP BY without the ROLLUP. De plus, la requête crée des sous-totaux pour chaque valeur Country.In addition, it creates subtotals for each value of Country. Enfin, elle donne un total global pour toutes les lignes.Finally, it gives a grand total for all rows. Le résultat ressemble à ceci :The result looks like this:

CountryCountry RégionRegion TotalSalesTotalSales
CanadaCanada AlbertaAlberta 100100
CanadaCanada British ColumbiaBritish Columbia 500500
CanadaCanada NULLNULL 600600
États-UnisUnited States MontanaMontana 100100
États-UnisUnited States NULLNULL 100100
NULLNULL NULLNULL 700700

GROUP BY CUBE ( )GROUP BY CUBE ( )

GROUP BY CUBE crée des groupes pour toutes les combinaisons possibles de colonnes.GROUP BY CUBE creates groups for all possible combinations of columns. Pour GROUP BY CUBE (a, b), le résultat donne des groupes de valeurs uniques (a, b), (NULL, b), (a, NULL) et (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).

En utilisant la table des exemples précédents, ce code exécute une opération GROUP BY CUBE sur les colonnes Country et Region.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);

Le résultat de la requête donne des groupes de valeurs uniques pour (Country, Region), (NULL, Region), (Country, NULL) et (NULL, NULL).The query result has groups for unique values of (Country, Region), (NULL, Region), (Country, NULL), and (NULL, NULL). Le résultat ressemble à ceci :The results look like this:

CountryCountry RégionRegion TotalSalesTotalSales
CanadaCanada AlbertaAlberta 100100
NULLNULL AlbertaAlberta 100100
CanadaCanada British ColumbiaBritish Columbia 500500
NULLNULL British ColumbiaBritish Columbia 500500
États-UnisUnited States MontanaMontana 100100
NULLNULL MontanaMontana 100100
NULLNULL NULLNULL 700700
CanadaCanada NULLNULL 600600
États-UnisUnited States NULLNULL 100100

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

L’option GROUPING SETS vous permet de combiner plusieurs clauses GROUP BY dans une seule clause GROUP BY.The GROUPING SETS option gives you the ability to combine multiple GROUP BY clauses into one GROUP BY clause. Les résultats sont l'équivalent de l'opération UNION ALL des groupes spécifiés.The results are the equivalent of UNION ALL of the specified groups.

Par exemple, GROUP BY ROLLUP (Country, Region) et GROUP BY GROUPING SETS ( ROLLUP (Country, Region) ) retournent les mêmes résultats.For example, GROUP BY ROLLUP (Country, Region) and GROUP BY GROUPING SETS ( ROLLUP (Country, Region) ) return the same results.

Quand GROUPING SETS contient plusieurs éléments, les résultats sont une union des éléments.When GROUPING SETS has two or more elements, the results are a union of the elements. Cet exemple retourne l’union des résultats ROLLUP et CUBE pour les colonnes Country et Region.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) );

Les résultats sont les mêmes que cette requête qui retourne une union de deux instructions 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 ne consolide pas les groupes dupliqués qui sont générés pour une liste GROUPING SETS.SQL does not consolidate duplicate groups generated for a GROUPING SETS list. Par exemple, dans GROUP BY ( (), CUBE (Country, Region) ), les deux éléments retournent une ligne pour le total global, et les deux lignes figurent dans les résultats.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 ()

Spécifie le groupe vide qui génère le total global.Specifies the empty group which generates the grand total. Il peut être utilisé comme élément d’un GROUPING SET.This is useful as one of the elements of a GROUPING SET. Par exemple, cette instruction donne le total des ventes pour chaque pays, puis le total global pour tous les pays.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 ]

S’applique à : SQL Server et Azure SQL DatabaseApplies to: SQL Server and Azure SQL Database

REMARQUE : Cette syntaxe est fournie uniquement pour la compatibilité descendante.NOTE: This syntax is provided for backward compatibility only. Elle sera supprimée dans une version ultérieure.It will be removed in a future version. Évitez d’utiliser cette syntaxe dans de nouveaux travaux de développement et prévoyez de modifier les applications qui utilisent actuellement cette syntaxe.Avoid using this syntax in new development work, and plan to modify applications that currently use this syntax.

Spécifie d’inclure tous les groupes dans les résultats, qu’ils remplissent ou non les critères de recherche définis dans la clause WHERE.Specifies to include all groups in the results regardless of whether they meet the search criteria in the WHERE clause. Les groupes qui ne remplissent pas les critères de recherche ont la valeur NULL pour l’agrégation.Groups that don't meet the search criteria have NULL for the aggregation.

GROUP BY ALL :GROUP BY ALL:

  • N’est pas pris en charge dans les requêtes qui accèdent aux tables distantes et qui contiennent également une clause WHERE.Is not supported in queries that access remote tables if there is also a WHERE clause in the query.
  • Échoue sur les colonnes qui ont l’attribut FILESTREAM.Will fail on columns that have the FILESTREAM attribute.

WITH (DISTRIBUTED_AGG)WITH (DISTRIBUTED_AGG)

S’applique à : Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) et Parallel Data WarehouseParallel Data WarehouseApplies to: Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse) and Parallel Data WarehouseParallel Data Warehouse

L’indicateur de requête DISTRIBUTED_AGG force le système MPP (Massively Parallel Processing) à redistribuer une table sur une colonne spécifique avant d’effectuer une agrégation.The DISTRIBUTED_AGG query hint forces the massively parallel processing (MPP) system to redistribute a table on a specific column before performing an aggregation. Une seule colonne dans la clause GROUP BY peut avoir un indicateur de requête DISTRIBUTED_AGG.Only one column in the GROUP BY clause can have a DISTRIBUTED_AGG query hint. À la fin de la requête, la table redistribuée est supprimée.After the query finishes, the redistributed table is dropped. La table d’origine n’est pas modifiée.The original table is not changed.

REMARQUE : L’indicateur de requête DISTRIBUTED_AGG est fourni à des fins de compatibilité descendante avec les versions de Parallel Data WarehouseParallel Data Warehouse antérieures et n’améliore pas les performances de la plupart des requêtes.NOTE: The DISTRIBUTED_AGG query hint is provided for backwards compatibility with earlier Parallel Data WarehouseParallel Data Warehouse versions and will not improve performance for most queries. Par défaut, MPP redistribue déjà les données de façon à améliorer les performances des agrégations.By default, MPP already redistributes data as necessary to improve performance for aggregations.

Remarques d'ordre généralGeneral Remarks

Interactions de GROUP BY avec l’instruction SELECTHow GROUP BY interacts with the SELECT statement

Liste SELECT :SELECT list:

  • Agrégations vectorielles.Vector aggregates. Si des fonctions d’agrégation sont incluses dans la liste SELECT, GROUP BY calcule une valeur récapitulative pour chaque groupe.If aggregate functions are included in the SELECT list, GROUP BY calculates a summary value for each group. Ces expressions sont dites agrégations vectorielles.These are known as vector aggregates.
  • Agrégations distinctes.Distinct aggregates. Les agrégations AVG (DISTINCT column_name), COUNT (DISTINCT column_name) et SUM (DISTINCT column_name) sont prises en charge avec ROLLUP, CUBE et 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.

Clause WHERE :WHERE clause:

  • SQL supprime les lignes qui ne remplissent pas les conditions définies dans la clause WHERE avant toute opération de regroupement.SQL removes Rows that do not meet the conditions in the WHERE clause before any grouping operation is performed.

Clause HAVING :HAVING clause:

  • SQL utilise la clause HAVING pour filtrer les groupes dans le jeu de résultats.SQL uses the having clause to filter groups in the result set.

Clause ORDER BY :ORDER BY clause:

  • Utilisez la clause ORDER BY pour classer le jeu de résultats.Use the ORDER BY clause to order the result set. La clause GROUP BY ne classe pas le jeu de résultats.The GROUP BY clause does not order the result set.

Valeurs NULL :NULL values:

  • Si une colonne de regroupement contient des valeurs NULL, toutes les valeurs NULL sont considérées comme égales et sont collectées dans un même groupe.If a grouping column contains NULL values, all NULL values are considered equal and they are collected into a single group.

Limitations et restrictionsLimitations and Restrictions

S’applique à : SQL Server (à partir de 2008) et Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)Applies to: SQL Server (starting with 2008) and Azure Synapse Analytics (SQL Data Warehouse)Azure Synapse Analytics (SQL Data Warehouse)

Capacité maximaleMaximum capacity

Pour une clause GROUP BY qui utilise ROLLUP, CUBE ou GROUPING SETS, le nombre maximal d’expressions est de 32.For a GROUP BY clause that uses ROLLUP, CUBE, or GROUPING SETS, the maximum number of expressions is 32. Le nombre maximal de groupes est de 4 096 (212).The maximum number of groups is 4096 (212). Les exemples suivants échouent car la clause GROUP BY a plus de 4 096 groupes.The following examples fail because the GROUP BY clause has more than 4096 groups.

  • L’exemple suivant échoue, car il génère 4 097 (212 + 1) jeux de regroupement.The following example generates 4097 (212 + 1) grouping sets and will fail.

    GROUP BY GROUPING SETS( CUBE(a1, ..., a12), b )  
    
  • L’exemple suivant échoue, car il génère 4 097 (212 + 1) groupes.The following example generates 4097 (212 + 1) groups and will fail. CUBE () et le jeu de regroupement () produisent une ligne de total global et les jeux de regroupement en double ne sont pas éliminés.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), ())  
    
  • Cet exemple utilise la syntaxe à compatibilité descendante.This example uses the backwards compatible syntax. Il échoue, car il génère 8 192 (213) jeux de regroupement.It generates 8192 (213) grouping sets and will fail.

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

    Pour les clauses GROUP BY à compatibilité descendante qui ne contiennent pas CUBE ou ROLLUP, la limite du nombre d’éléments regroupés est déterminée par les tailles de colonne GROUP BY, les colonnes agrégées et les valeurs d’agrégation utilisées dans la requête.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. Cette limite provient de la limite de 8 060 octets de la table de travail intermédiaire requise pour stocker les résultats de requêtes intermédiaires.This limit originates from the limit of 8,060 bytes on the intermediate worktable that is needed to hold intermediate query results. Un maximum de 12 expressions de regroupement est autorisé quand CUBE ou ROLLUP est spécifié.A maximum of 12 grouping expressions is permitted when CUBE or ROLLUP is specified.

Prise en charge des fonctionnalités GROUP BY ISO et ANSI SQL-2006Support for ISO and ANSI SQL-2006 GROUP BY Features

La clause GROUP BY prend en charge toutes les fonctions GROUP BY incluses dans la norme SQL-2006, avec les exceptions de syntaxe suivantes :The GROUP BY clause supports all GROUP BY features that are included in the SQL-2006 standard with the following syntax exceptions:

  • Les jeux de regroupement ne sont pas autorisés dans la clause GROUP BY, à moins de faire partie d'une liste GROUPING SETS explicite.Grouping sets are not allowed in the GROUP BY clause unless they are part of an explicit GROUPING SETS list. Par exemple, GROUP BY Column1, (Column2, ...ColumnN) est autorisé dans la norme, mais pas dans Transact-SQL.For example, GROUP BY Column1, (Column2, ...ColumnN) is allowed in the standard but not in Transact-SQL. Transact-SQL prend en charge les syntaxes GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)) et GROUP BY Column1, Column2, ... ColumnN, qui sont sémantiquement équivalentes.Transact-SQL supports GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)) and GROUP BY Column1, Column2, ... ColumnN, which are semantically equivalent. Ils sont sémantiquement équivalents à l'exemple GROUP BY précédent.These are semantically equivalent to the previous GROUP BY example. Cela permet d’éviter que la syntaxe GROUP BY Column1, (Column2, ...ColumnN) soit interprétée de façon incorrecte comme la syntaxe GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), ces deux syntaxes n’étant pas sémantiquement équivalentes.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.

  • Les jeux de regroupement ne sont pas autorisés à l'intérieur des jeux de regroupement.Grouping sets are not allowed inside grouping sets. Par exemple, GROUP BY GROUPING SETS (A1, A2,...An, GROUPING SETS (C1, C2, ...Cn)) est autorisé dans la norme SQL-2006, mais pas dans 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 autorise les syntaxes GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn ) et GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn) ), qui sont sémantiquement équivalentes au premier exemple GROUP BY, tout en étant plus claires.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] est uniquement autorisée dans une clause GROUP BY simple qui contient des expressions de colonne.GROUP BY [ALL/DISTINCT] is only allowed in a simple GROUP BY clause that contains column expressions. Elle n’est pas autorisée avec les constructions GROUPING SETS, ROLLUP, CUBE, WITH CUBE ou WITH ROLLUP.It is not allowed with the GROUPING SETS, ROLLUP, CUBE, WITH CUBE or WITH ROLLUP constructs. ALL est la valeur par défaut et est implicite.ALL is the default and is implicit. Elle est uniquement autorisée dans la syntaxe à compatibilité descendante.It is also only allowed in the backwards compatible syntax.

Comparaison des fonctionnalités GROUP BY prises en chargeComparison of Supported GROUP BY Features

Le tableau suivant décrit les fonctions GROUP BY prises en charge en fonction des versions de SQL et du niveau de compatibilité de la base de données.The following table describes the GROUP BY features that are supported based upon SQL versions and database compatibility level.

FonctionnalitéFeature SQL Server Integration ServicesSQL Server Integration Services Niveau de compatibilité SQL Server 100 ou supérieurSQL Server compatibility level 100 or higher SQL Server 2008 ou version ultérieure avec niveau de compatibilité 90.SQL Server 2008 or later with compatibility level 90.
Agrégats DISTINCTDISTINCT aggregates Non pris en charge pour WITH CUBE ou WITH ROLLUP.Not supported for WITH CUBE or WITH ROLLUP. Pris en charge pour WITH CUBE, WITH ROLLUP, GROUPING SETS, CUBE ou ROLLUP.Supported for WITH CUBE, WITH ROLLUP, GROUPING SETS, CUBE, or ROLLUP. Identique au niveau de comptabilité 100.Same as compatibility level 100.
Fonction définie par l'utilisateur avec nom CUBE ou ROLLUP dans la clause GROUP BYUser-defined function with CUBE or ROLLUP name in the GROUP BY clause Les fonctions définies par l’utilisateur dbo.cube( arg1 , ...argN ) ou dbo.rollup( arg1 , ...argN ) dans la clause GROUP BY sont autorisées.User-defined function dbo.cube(arg1,...argN) or dbo.rollup(arg1,...argN) in the GROUP BY clause is allowed.

Par exemple : SELECT SUM (x) FROM T GROUP BY dbo.cube(y);For example: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);
Les fonctions définies par l’utilisateur dbo.cube ( arg1 , ...argN ) ou dbo.rollup( arg1 , ...argN ) dans la clause GROUP BY ne sont pas autorisées.User-defined function dbo.cube (arg1,...argN ) or dbo.rollup( arg1 ,...argN) in the GROUP BY clause is not allowed.

Par exemple : SELECT SUM (x) FROM T GROUP BY dbo.cube(y);For example: SELECT SUM (x) FROM T GROUP BY dbo.cube(y);

Le message d’erreur suivant est retourné : « Syntaxe incorrecte près du mot clé 'cube'|'rollup'. »The following error message is returned: "Incorrect syntax near the keyword 'cube'|'rollup'."

Pour éviter ce problème, remplacez dbo.cube par [dbo].[cube] ou dbo.rollup par [dbo].[rollup].To avoid this problem, replace dbo.cube with [dbo].[cube] or dbo.rollup with [dbo].[rollup].

L’exemple suivant est autorisé : 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);
Les fonctions définies par l’utilisateur dbo.cube ( arg1 , ...argN) ou dbo.rollup( arg1 , ...argN ) dans la clause GROUP BY sont autoriséesUser-defined function dbo.cube (arg1,...argN) or dbo.rollup(arg1,...argN) in the GROUP BY clause is allowed

Par exemple : 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 Non pris en chargeNot supported Prise en chargeSupported Prise en chargeSupported
CUBECUBE Non pris en chargeNot supported Prise en chargeSupported Non pris en chargeNot supported
ROLLUPROLLUP Non pris en chargeNot supported Prise en chargeSupported Non pris en chargeNot supported
Total global, tel que GROUP BY ()Grand total, such as GROUP BY () Non pris en chargeNot supported Prise en chargeSupported Prise en chargeSupported
GROUPING_ID, fonctionGROUPING_ID function Non pris en chargeNot supported Prise en chargeSupported Prise en chargeSupported
GROUPING (fonction)GROUPING function Prise en chargeSupported Prise en chargeSupported Prise en chargeSupported
WITH CUBEWITH CUBE Prise en chargeSupported Prise en chargeSupported Prise en chargeSupported
WITH ROLLUPWITH ROLLUP Prise en chargeSupported Prise en chargeSupported Prise en chargeSupported
Suppression de regroupement WITH CUBE ou WITH ROLLUP « en double »WITH CUBE or WITH ROLLUP "duplicate" grouping removal Prise en chargeSupported Prise en chargeSupported Prise en chargeSupported

ExemplesExamples

R.A. Utiliser une clause GROUP BY simpleUse a simple GROUP BY clause

L'exemple suivant extrait le total pour chaque SalesOrderID de la table SalesOrderDetail.The following example retrieves the total for each SalesOrderID from the SalesOrderDetail table. Cet exemple utilise AdventureWorks.This example uses AdventureWorks.

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

B.B. Utiliser une clause GROUP BY avec plusieurs tablesUse a GROUP BY clause with multiple tables

L'exemple suivant extrait le nombre d'employés pour chaque City de la table Address en conjonction avec la table EmployeeAddress.The following example retrieves the number of employees for each City from the Address table joined to the EmployeeAddress table. Cet exemple utilise 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. Utiliser une clause GROUP BY avec une expressionUse a GROUP BY clause with an expression

L'exemple suivant récupère le total des ventes pour chaque année en utilisant la fonction DATEPART.The following example retrieves the total sales for each year by using the DATEPART function. La même expression doit être présente dans la liste SELECT et dans la clause 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. Utiliser une clause GROUP BY avec une clause HAVINGUse a GROUP BY clause with a HAVING clause

L'exemple suivant utilise la clause HAVING pour spécifier lequel des groupes générés dans la clause GROUP BY doit être inclus dans le jeu de résultats.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);  

Exemples : Azure Synapse Analytics et Parallel Data WarehouseExamples: Azure Synapse Analytics and Parallel Data Warehouse

E.E. Utilisation de base de la clause GROUP BYBasic use of the GROUP BY clause

L’exemple suivant calcule le montant total des ventes réalisées par jour.The following example finds the total amount for all sales on each day. Une seule ligne contenant la somme de toutes les ventes est retournée pour chaque jour.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. Utilisation de base de l’indicateur DISTRIBUTED_AGGBasic use of the DISTRIBUTED_AGG hint

Cet exemple utilise l’indicateur de requête DISTRIBUTED_AGG pour forcer l’application à redistribuer la table sur la colonne CustomerKey avant d’effectuer l’agrégation.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. Variantes de syntaxe pour GROUP BYSyntax Variations for GROUP BY

Quand la liste SELECT n’a pas d’agrégations, chaque colonne dans cette liste doit être incluse dans la liste GROUP BY.When the select list has no aggregations, each column in the select list must be included in the GROUP BY list. Les colonnes calculées dans la liste SELECT peuvent être incluses dans la liste GROUP BY, mais cela n’est pas obligatoire.Computed columns in the select list can be listed, but are not required, in the GROUP BY list. Voici des exemples d’instructions SELECT avec une syntaxe valide :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. Utiliser GROUP BY avec plusieurs expressions GROUP BYUsing a GROUP BY with multiple GROUP BY expressions

L’exemple suivant regroupe les résultats selon plusieurs critères GROUP BY.The following example groups results using multiple GROUP BY criteria. Si chaque groupe OrderDateKey contient des sous-groupes qui peuvent être différenciés par la valeur DueDateKey, un nouveau regroupement est défini pour le jeu de résultats.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. Utilisation d'une clause GROUP BY avec une clause HAVINGUsing a GROUP BY clause with a HAVING clause

L’exemple suivant utilise la clause HAVING pour spécifier quels groupes générés dans la clause GROUP BY doivent être inclus dans le jeu de résultats.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. Seuls les groupes ayant des dates de commande en 2004 ou après sont inclus dans les résultats.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;  

Voir aussiSee Also

GROUPING_ID (Transact-SQL) GROUPING_ID (Transact-SQL)
GROUPING (Transact-SQL) GROUPING (Transact-SQL)
SELECT (Transact-SQL) SELECT (Transact-SQL)
SELECT, clause (Transact-SQL)SELECT Clause (Transact-SQL)