SELECT - Clause GROUP BY (Transact-SQL)

S’applique à :SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsPoint de terminaison d’analytique SQL dans Microsoft FabricEntrepôt dans Microsoft FabricBase de données SQL dans Microsoft Fabric

Clause d’instruction SELECT qui divise le résultat de la requête en groupes de lignes, généralement en effectuant une ou plusieurs agrégations sur chaque groupe. L’instruction SELECT retourne une ligne pour chaque groupe.

Cet article fournit différentes syntaxes, arguments, remarques, autorisations et exemples basés sur la version de produit sélectionnée. Sélectionnez la version de votre produit souhaitée dans la liste déroulante des versions.

Syntax

Conventions de la syntaxe Transact-SQL

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

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

GROUP BY {
      column-name [ WITH (DISTRIBUTED_AGG) ]
    | column-expression
    | ROLLUP ( <group_by_expression> [ , ...n ] )
} [ , ...n ]

      ALL
     | {
           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 ] )

Arguments

column-expression

Spécifie une colonne ou un calcul non agrégé sur une colonne. Il peut s’agir d’une colonne d’une table, d’une table dérivée ou d’une vue. La colonne doit apparaître dans la FROM clause de l’instruction SELECT , mais n’a pas besoin d’apparaître dans la SELECT liste.

Pour connaître les expressions valides, consultez expression.

La colonne doit apparaître dans la FROM clause de l’instruction SELECT , mais n’est pas nécessaire pour apparaître dans la SELECT liste. Toutefois, vous devez inclure chaque colonne de table ou d’affichage dans la GROUP BY liste si vous l’utilisez dans une expression non agrégée dans la <select> liste.

Options GROUP BY

Les options suivantes étendent la clause de base GROUP BY pour prendre en charge l’agrégation hiérarchique, la synthèse multidimensionnelle, les combinaisons de regroupement personnalisées et les comportements d’exécution spécifiques à la plateforme. Les requêtes peuvent utiliser ces options pour produire des sous-totaux et des totaux généraux dans une seule opération logique.

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

  Génère des sous-totaux hiérarchiques pour les colonnes répertoriées et un total général final (par exemple, , (a,b,c), (a,b)(a), ()). Utilisez-le pour les rapports d’exploration commele mois du trimestre> del’année>.

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

  Produit toutes les combinaisons des colonnes spécifiées (les 2^n lattices complètes) plus le total général. Utilisez-la pour une analyse multidimensionnelle sur chaque tranche.

• GROUPING SETS ( <grouping_set> [ , ... n ] )

  Définit les regroupements exacts à calculer (y compris () pour le total général) en une seule passe. Cette option est fonctionnellement similaire à une UNION ALL de plusieurs GROUP BY requêtes, mais optimisée ensemble.

• () (jeu de regroupement vide)

  Raccourci pour calculer uniquement le total général sur toutes les lignes. Utilisez-le seul comme GROUP BY () ou à l’intérieur GROUPING SETS.

• ALL column-expression [ , ... n ](non-ISO ; compatibilité descendante)

  Abrégé pour regrouper par tous les éléments sélectionnés non agrégés. Conservé pour la compatibilité ; la disponibilité et la sémantique varient.

• column-expression [ , ... n] WITH { CUBE | 'ROLLUP }(legacy form)

  Syntaxe antérieure, non ISO équivalente à GROUP BY CUBE(...) ou GROUP BY ROLLUP(...). Pris en charge pour la compatibilité descendante uniquement. Utilisez les sous-clauses ISO lorsque cela est possible.

• AVEC (DISTRIBUTED_AGG)

  Indicateurs d’exécution distribuée pour les agrégations lors du regroupement par une seule colonne. Seuls les pools SQL dédiés Azure Synapse Analytics prennent en charge cette option.

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

Regroupe les résultats de l’instruction SELECT en fonction des valeurs d’une ou de plusieurs expressions de colonne.

Par exemple, cette requête crée une Sales table avec des colonnes pour Region, Territoryet Sales. Il insère quatre lignes, et deux des lignes ont des valeurs correspondantes pour Region et Territory.

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

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

Le Sales tableau contient ces lignes :

Cette requête suivante regroupe Region et Territory retourne la somme d’agrégation pour chaque combinaison de valeurs.

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

Le résultat de la requête comporte trois lignes, car il existe trois combinaisons de valeurs pour Region et Territory. Le TotalSales Canada et la Colombie-Britannique sont la somme de deux lignes.

L’expression en colonne ne GROUP BY peut pas contenir les éléments suivants :

• Une GROUP BY expression de colonne ne peut pas contenir un alias de colonne que vous définissez dans la SELECT liste. Il peut utiliser un alias de colonne pour une table dérivée définie dans la FROM clause.
• Une GROUP BY expression en colonne ne peut pas contenir une colonne de texte, ntext ou image. Toutefois, vous pouvez utiliser une colonne de texte, ntext ou image comme argument pour une fonction qui retourne une valeur d’un type de données valide. Par exemple, l’expression peut utiliser SUBSTRING() et CAST(). Cette règle s’applique également aux expressions de la HAVING clause.
• Une GROUP BY expression colonne ne peut pas contenir une méthode de type de données xml . Elle peut inclure une fonction définie par l’utilisateur ou une colonne calculée utilisant des méthodes de type de données xml .
• Une GROUP BY expression de colonne ne peut pas contenir une sous-requête ; la requête renvoie l’erreur 144.
• Une expression de GROUP BY colonne ne peut pas contenir une colonne provenant d’une vue indexée.

Les instructions suivantes sont autorisées :

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 :

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

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

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

GROUPER PAR ROLLUP ()

Crée un groupe pour chaque combinaison d’expressions de colonne. En outre, il cumule les résultats en sous-totaux et totaux généraux. Lorsqu’il crée les groupes, il passe de droite à gauche, réduisant le nombre d’expressions de colonne pour le regroupement et les agrégations.

L’ordre des colonnes affecte la ROLLUP sortie et peut affecter le nombre de lignes dans le jeu de résultats.

Par exemple, GROUP BY ROLLUP (col1, col2, col3, col4) crée des groupes pour chaque combinaison d’expressions de colonne dans les listes suivantes :

• Col1, Col2, Col3, Col4
• col1, col2, col3, NULL
• col1, col2, NULL, NULL
• COL1, NUL, NUL, NUL
• NULL, NULL, NULL, NULL (Le groupe avec les NULL valeurs est le total général)

À l’aide de la table de l’exemple précédent, ce code exécute une GROUP BY ROLLUP opération au lieu d’une opération de base GROUP BY.

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

Le résultat de la requête a les mêmes agrégations que la base GROUP BY sans le ROLLUP. En outre, il crée des sous-totaux pour chaque valeur de Région. Enfin, elle donne un total global pour toutes les lignes. Le résultat ressemble à ceci :

GROUPE PAR CUBE ()

GROUP BY CUBE crée des groupes pour toutes les combinaisons possibles de colonnes. Pour GROUP BY CUBE (a, b), les résultats ont des groupes pour des valeurs uniques de (a, b), (NULL, b), (a, NULL)et (NULL, NULL).

À l’aide du tableau des exemples précédents, ce code exécute une GROUP BY CUBE opération sur Region and Territory.

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

Le résultat de la requête contient des groupes pour des valeurs uniques de (Region, Territory), , (NULL, Territory)(Region, NULL)et (NULL, NULL). Le résultat ressemble à ceci :

GROUPE PAR GROUPES D’ENSEMBLES ()

L’option GROUPING SETS combine plusieurs GROUP BY clauses en une GROUP BY seule clause. Les résultats sont identiques à l’utilisation UNION ALL sur les groupes spécifiés.

Par exemple, GROUP BY ROLLUP (Region, Territory) et GROUP BY GROUPING SETS ( ROLLUP (Region, Territory)) retournent les mêmes résultats.

Lorsqu’il GROUPING SETS existe deux éléments ou plus, les résultats sont une union des éléments. Cet exemple retourne l’union des résultats et ROLLUP de la CUBE région et du territoire.

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

Les résultats sont identiques à cette requête qui retourne une union des deux GROUP BY instructions.

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

SQL ne consolide pas les groupes en double générés pour une GROUPING SETS liste. Par exemple, dans GROUP BY ((), CUBE (Region, Territory)), les deux éléments retournent une ligne pour le total général, et les deux lignes apparaissent dans les résultats.

Prise en charge des fonctionnalités ISO et ANSI SQL-2006 GROUP BY

La GROUP BY clause prend en charge toutes les GROUP BY fonctionnalités incluses dans la norme SQL-2006 avec les exceptions de syntaxe suivantes :

• Les jeux de regroupement ne sont pas autorisés dans la GROUP BY clause, sauf s’ils font partie d’une liste explicite GROUPING SETS . Par exemple, GROUP BY Column1, (Column2, ...ColumnN) est autorisé dans la norme, mais pas dans 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. Ces clauses sont sémantiquement équivalentes à l’exemple précédent GROUP BY . Cette restriction évite la possibilité qu’elle GROUP BY Column1, (Column2, ...ColumnN) puisse être mal interprétée comme GROUP BY C1, GROUPING SETS ((Column2, ...ColumnN)), qui ne sont pas sémantiquement équivalentes.

• Les jeux de regroupement ne sont pas autorisés au sein de jeux de regroupement. 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. Transact-SQL autorise GROUP BY GROUPING SETS( A1, A2,...An, C1, C2, ...Cn) ou GROUP BY GROUPING SETS( (A1), (A2), ... (An), (C1), (C2), ... (Cn)), qui sont sémantiquement équivalents au premier GROUP BY exemple et ont une syntaxe plus claire.

GROUPE PAR ()

Spécifie le groupe vide qui génère le total général. Ce groupe est utile comme l’un des éléments d’un GROUPING SET. Par exemple, cette instruction donne le total des ventes pour chaque région, puis donne le total général pour toutes les régions.

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

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

S’applique à : SQL Server, Azure SQL Database, Azure SQL Managed Instance, et SQL database in Fabric

La GROUP BY ALL syntaxe T-SQL est différente en Fabric Data Warehouse. Pour la version Fabric Data Warehouse de cet article, voir SELECT - GROUP BY pour Fabric Data Warehouse.

Spécifie s’il faut inclure tous les groupes dans les résultats, qu’ils répondent aux critères de recherche dans la WHERE clause. Les groupes qui ne répondent pas aux critères de recherche ont NULL pour l’agrégation.

• GROUP BY ALL {columns} n’est pas prise en charge dans les requêtes qui accèdent à des tables distantes s’il y a aussi une WHERE clause dans la requête.
• GROUP BY ALL {columns} échoue sur les colonnes qui ont l’attribut FILESTREAM.

Prise en charge des fonctionnalités ISO et ANSI SQL-2006 GROUP BY

La GROUP BY clause prend en charge toutes les GROUP BY fonctionnalités incluses dans la norme SQL-2006 avec les exceptions de syntaxe suivantes :

• Vous ne pouvez utiliser GROUP BY ALL et GROUP BY DISTINCT dans une clause de base GROUP BY qui contient des expressions de colonne. Vous ne pouvez pas les utiliser avec les constructions ou les GROUPING SETSconstructions ROLLUPCUBEWITH CUBEWITH ROLLUP. ALL est la valeur par défaut et est implicite. Vous ne pouvez l’utiliser que dans la syntaxe rétrocompatible.

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

S’applique à : SQL Server, Azure SQL Database, Azure SQL Managed Instance, et SQL database in Fabric

L’héritage GROUP BY <column-expression> WITH CUBE et GROUP BY <column-expression> WITH ROLLUP la syntaxe sont pris en charge uniquement pour la rétrocompatibilité.

AVEC (DISTRIBUTED_AGG)

Applies à : Azure Synapse Analytics

L'DISTRIBUTED_AGGindice de requête n'est pas pris en charge dans SQL Server, Azure SQL Database, Azure SQL Managed Instance, SQL Database dans Fabric ou Fabric Data Warehouse.

L’indicateur DISTRIBUTED_AGG de requête force le système de traitement massivement parallèle (MPP) à redistribuer une table sur une colonne spécifique avant d’effectuer une agrégation. Vous pouvez utiliser l’indicateur de DISTRIBUTED_AGG requête sur une seule colonne de la GROUP BY clause. À la fin de la requête, la table redistribuée est supprimée. La table d’origine n’est pas modifiée.

Remarques

Interactions de GROUP BY avec l’instruction SELECT

SELECT Liste:

• Agrégats vectoriels. Si vous incluez des fonctions d’agrégation dans la SELECT liste, GROUP BY calcule une valeur récapitulative pour chaque groupe. Ces fonctions sont appelées agrégats vectoriels.
• Agrégats distincts. Les agrégats AVG(DISTINCT <column_name>), COUNT(DISTINCT <column_name>)et SUM(DISTINCT <column_name>) fonctionnent avec ROLLUP, CUBEet GROUPING SETS.

Clause WHERE :

• SQL supprime les lignes qui ne répondent pas aux conditions de la WHERE clause avant d’effectuer une opération de regroupement.

Clause HAVING :

• SQL utilise la HAVING clause pour filtrer les groupes dans le jeu de résultats.

Clause ORDER BY :

• Utilisez la ORDER BY clause pour classer le jeu de résultats. La GROUP BY clause ne trie pas le jeu de résultats.

valeurs NULL :

• Si une colonne de regroupement contient NULL des valeurs, le moteur de base de données traite toutes les NULL valeurs comme égales et les collecte dans un seul groupe.

Limites

S’applique à : SQL Server et Azure Synapse Analytics

Pour une GROUP BY clause qui utilise ROLLUP, CUBEou GROUPING SETS, le nombre maximal d’expressions est 32. Le nombre maximal de groupes est de 4 096 (2¹²). Les exemples suivants échouent, car la GROUP BY clause comporte plus de 4 096 groupes.

• L’exemple suivant génère 4 097 (2¹² + 1) ensembles de regroupements, puis échoue.

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

• L’exemple suivant génère 4 097 groupes (2¹² + 1), puis échoue. CUBE () et le jeu de regroupement () produisent une ligne de total général. Les jeux de regroupement en double ne sont pas éliminés.

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

• Cet exemple utilise la syntaxe compatible descendante. Il génère 8 192 (2¹³) ensembles de regroupements, puis échoue.

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

  Pour les clauses compatibles descendantes GROUP BY qui ne contiennent CUBE pas ou ROLLUP, les GROUP BY tailles de colonne, les colonnes agrégées et les valeurs d’agrégation impliquées dans la requête limitent le nombre d’éléments GROUP BY . Cette limite provient de la limite de 8 060 octets sur la table de travail intermédiaire qui contient les résultats de requête intermédiaires. Vous pouvez utiliser au maximum 12 expressions de regroupement lorsque vous spécifiez CUBE ou ROLLUP.

Comparaison des fonctionnalités GROUP BY prises en charge

Le tableau suivant décrit les GROUP BY fonctionnalités prises en charge par différents produits.

¹Niveau de compatibilité de base de données 100 et versions ultérieures.

² Le message d’erreur retourné est : Incorrect syntax near the keyword 'cube'|'rollup'.

Examples

Les exemples de code de cet article utilisent la AdventureWorks2025base de données , AdventureWorksDW2025, ou AdventureWorksLT2025 exemple de base de données, que vous pouvez télécharger depuis le dépôt GitHub Azure Data SQL Samples Repository.

A. Utiliser une clause GROUP BY de base

L'exemple suivant extrait le total pour chaque SalesOrderID de la table SalesOrderDetail. Cet exemple utilise AdventureWorks.

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

B. Utiliser une clause GROUP BY avec plusieurs tables

L'exemple suivant extrait le nombre d'employés pour chaque City de la table Address en conjonction avec la table EmployeeAddress. Cet exemple utilise AdventureWorks.

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

C. Utiliser une clause GROUP BY avec une expression

L'exemple suivant récupère le total des ventes pour chaque année en utilisant la fonction DATEPART. Vous devez inclure la même expression dans la liste et SELECT la 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. Utiliser une clause GROUP BY avec une clause HAVING

L’exemple suivant utilise la HAVING clause pour spécifier quels groupes générés dans la GROUP BY clause doivent être inclus dans le jeu de résultats.

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

E. Utilisation de base de la clause GROUP BY

L’exemple suivant calcule le montant total des ventes réalisées par jour. La requête retourne une ligne contenant la somme de toutes les ventes pour chaque jour.

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

F. Utilisation de base de l’indicateur DISTRIBUTED_AGG

Cet exemple utilise l’indicateur de requête DISTRIBUTED_AGG pour forcer l’appliance à mélanger la table sur la CustomerKey colonne avant d’effectuer l’agrégation.

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

G. Variantes de syntaxe pour GROUP BY

Lorsque la liste de sélection n’a aucune agrégation, vous devez inclure chaque colonne dans la liste de sélection.GROUP BY Vous pouvez inclure des colonnes calculées dans la liste de sélection, mais vous n’êtes pas obligé de les inclure dans la GROUP BY liste. Ces exemples montrent des instructions valides SELECT de manière syntactique :

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

SELECT NumberCarsOwned
FROM DimCustomer
GROUP BY YearlyIncome, NumberCarsOwned;

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

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

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

H. Utiliser une clause GROUP BY avec plusieurs expressions GROUP BY

L’exemple suivant regroupe les résultats selon plusieurs critères GROUP BY. Si, dans chaque OrderDateKey groupe, des sous-groupes existent que la DueDateKey valeur différencie, la requête définit un nouveau regroupement pour le jeu de résultats.

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

I. Utiliser une clause GROUP BY avec une clause HAVING

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. Seuls les groupes avec des dates de commande en 2004 ou version ultérieure sont inclus dans les résultats.

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

Contenu connexe

• GROUPING_ID (Transact-SQL)
• GROUPEMENT (Transact-SQL)
• SELECT (Transact-SQL)
• CLAUSE SELECT (Transact-SQL)