Partage via

SELECT - Clause GROUP BY (Transact-SQL)

S’applique à :SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsAnalytics Platform System (PDW)Point 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.

Syntax

Conventions de la syntaxe Transact-SQL

Syntaxe conforme iso pour SQL Server et Azure SQL Database :

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

Syntaxe non conforme ISO pour SQL Server et Azure SQL Database (compatibilité descendante uniquement) :

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

Syntaxe pour Azure Synapse Analytics :

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

Syntaxe pour le système de plateforme Analytics (PDW) :

GROUP BY {
      column-name [ WITH (DISTRIBUTED_AGG) ]
    | column-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)

    Shorthand for computing only the grand total across all rows. Utilisez-le seul comme GROUP BY () ou à l’intérieur GROUPING SETS.

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

    Shorthand to group by all nonaggregated select items. 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.

  • WITH (DISTRIBUTED_AGG)

    Indicateurs d’exécution distribuée pour les agrégations lors du regroupement par une seule colonne. Les pools SQL dédiés Azure Synapse Analytics et pdW (Analytics Platform System) sont les seules plateformes qui 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 :

Region Du territoire Sales
Canada Alberta 100
Canada Colombie-britannique 200
Canada Colombie-britannique 300
United States Montana 100

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.

Region Du territoire TotalSales
Canada Alberta 100
Canada Colombie-britannique 500
United States Montana 100

L’expression de colonne dans GROUP BY ne peut pas contenir :

  • 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 colonne de type text, 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.
  • méthodes de type de données xml. Il peut inclure une fonction définie par l’utilisateur qui utilise des méthodes de type de données xml . Il peut inclure une colonne calculée qui utilise des méthodes de type de données xml .
  • Une sous-question. La requête retourne l’erreur 144.
  • Une colonne 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;

GROUP BY 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 :

Region Du territoire TotalSales
Canada Alberta 100
Canada Colombie-britannique 500
Canada NULL 600
United States Montana 100
United States NULL 100
NULL NULL 700

GROUP BY 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 :

Region Du territoire TotalSales
Canada Alberta 100
NULL Alberta 100
Canada Colombie-britannique 500
NULL Colombie-britannique 500
United States Montana 100
NULL Montana 100
NULL NULL 700
Canada NULL 600
United States NULL 100

GROUP BY GROUPING SETS ()

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 et Azure SQL Database

Note

Utilisez cette syntaxe uniquement pour la compatibilité descendante. Évitez d’utiliser cette syntaxe dans de nouveaux travaux de développement et prévoyez de modifier les applications qui utilisent actuellement cette syntaxe.

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 :

  • N’est pas pris en charge dans les requêtes qui accèdent aux tables distantes s’il existe également une WHERE clause dans la requête.
  • É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 et Azure SQL Database

Note

Utilisez cette syntaxe uniquement pour la compatibilité descendante. Évitez d’utiliser cette syntaxe dans de nouveaux travaux de développement et prévoyez de modifier les applications qui utilisent actuellement cette syntaxe.

AVEC (DISTRIBUTED_AGG)

S’applique à : Azure Synapse Analytics and Analytics Platform System (PDW)

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.

Note

L’indicateur DISTRIBUTED_AGG de requête fournit une compatibilité descendante avec les versions antérieures de PDW (Analytics Platform System) et n’améliore pas les performances de la plupart des requêtes. Par défaut, MPP redistribue déjà les données de façon à améliorer les performances des agrégations.

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 (212). Les exemples suivants échouent, car la GROUP BY clause comporte plus de 4 096 groupes.

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

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

  • L’exemple suivant génère 4 097 groupes (212 + 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 (213) 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.

Feature SQL Server Integration Services SQL Server 1
DISTINCT Agrégats Non pris en charge pour WITH CUBE ou WITH ROLLUP. Prise en charge pour WITH CUBE, , WITH ROLLUPGROUPING SETS, CUBEou ROLLUP.
Fonction définie par l’utilisateur avec CUBE ou ROLLUP nom dans la GROUP BY clause La fonction dbo.cube(<arg1>, ...<argN>) définie par l’utilisateur ou dbo.rollup(<arg1>, ...<argN>) dans la GROUP BY clause est autorisée.

Par exemple : SELECT SUM (x) FROM T GROUP BY dbo.cube(y);		 La fonction dbo.cube (<arg1>, ...<argN>) définie par l’utilisateur ou dbo.rollup(<arg1>, ...<argN>) dans la GROUP BY clause n’est pas autorisée.

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

SQL Server retourne un message d’erreur 2.

Pour éviter ce problème, remplacez dbo.cube par [dbo].[cube] ou dbo.rollup par [dbo].[rollup].

L’exemple suivant est autorisé : SELECT SUM (x) FROM T GROUP BY [dbo].[cube](y);
GROUPING SETS Non prise en charge Supported
CUBE Non prise en charge Supported
ROLLUP Non prise en charge Supported
Total général, tel que GROUP BY() Non prise en charge Supported
GROUPING_ID Fonction Non prise en charge Supported
GROUPING Fonction Supported Supported
WITH CUBE Supported Supported
WITH ROLLUP Supported Supported
WITH CUBE ou WITH ROLLUP suppression de regroupement « dupliquée » Supported Supported

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

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

Examples

Les exemples de code de cet article utilisent les bases de données d'exemple AdventureWorks2025 ou AdventureWorksDW2025, que vous pouvez télécharger à partir de la page d'accueil Microsoft SQL Server Samples and Community Projects.

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 et Analytics Platform System (PDW)

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 HAVING clause pour spécifier les groupes générés dans la GROUP BY clause qui 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

  • Last updated on