DAX SUMMARIZE() : Un guide pour regrouper et résumer les données

DAX SUMMARIZE() et regroupement de données

Voici comment la fonction SUMMARIZE() crée des tableaux récapitulatifs sur la base de colonnes et d'agrégations spécifiées :

SUMMARIZE (<table>, <groupBy_columnName>[, <groupBy_columnName>]…[, <name>, <expression>]…)

Dans la syntaxe ci-dessus :

• table est le tableau source de vos données.

• groupBy_columnName est la (les) colonne(s) par laquelle (lesquelles) vous souhaitez effectuer le regroupement.

• name est le nom de votre nouvelle colonne calculée.

• expression est le calcul que vous souhaitez effectuer.

Vous pouvez utiliser SUMMARIZE() avec n'importe quel tableau ou colonne de votre ensemble de données, ce qui le rend très polyvalent.

Groupement de base

Prenons un exemple simple de regroupement de base avec SUMMARIZE().

Commencez par importer l'ensemble de données dans Power BI. Pour ce faire, allez sur l'onglet Home de > Get Data. Sélectionnez l'option correspondant à votre fichier enregistré dans le menu déroulant et chargez-le. Dans cet exemple, j'ai un ensemble de données avec des colonnes pour l'année, le produit et le montant des ventes. Je vais maintenant l'importer dans Power BI.

Un tableau nommé sales. Image par l'auteur.

Une fois les données importées, allez dans l'ongletModeling > New table. Ensuite, saisissez la formule suivante pour regrouper les données en fonction de l'année. Année et agréger le Ventes totales.

	SummaryTable =
	SUMMARIZE(
	    sales,
	    sales[Year],
	    "Total Sales", SUM(sales[SalesAmount])
	)

Barre de formule. Image par l'auteur.

Dans cette formule :

• SummarizedTable crée un nouveau tableau.

• SUMMARIZE( commence à regrouper et à résumer les données.

• SalesData, est le tableau source.

• SalesData[Year], groupes selon l'année Année colonne.

• "Total Sales", SUM(SalesData[SalesAmount]) crée une nouvelle colonne appelée Ventes totales qui additionne Montant des ventes pour chaque année.

Résultats résumés. Image par l'auteur.

Ici, la fonction SUMMARIZE() crée un tableau récapitulatif en regroupant les données par année et calcule le Ventes totales en additionnant le Montant des ventes pour chaque année.

Regroupement multiple

SUMMARIZE() peut également gérer des regroupements plus complexes. Comprenons-le à l'aide d'un exemple. Ici, J'ai un jeu de données avec des colonnes pour Year, Product, Region et SalesAmount.

Un tableau nommé sales_data. Image par l'auteur.

Ici, je regroupe par l'année et région pour calculer le ventes totales pour chaque combinaison.

	SummarizedTable =
	SUMMARIZE(
	    sales_data,
	    sales_data[Year],
	    sales_data[Region],
	    "Total Sales", SUM(sales_data[SalesAmount])
	)

Dans cette formule : 

• sales_data est le tableau dans lequel vos données sont stockées.

• sales_data[Year] est la première colonne à être regroupée par l'année.

• sales_data[Region] est la deuxième colonne à regrouper par région.

• "Total Sales" est le nom de la colonne personnalisée pour la somme des ventes.

• SUM(SalesData[SalesAmount]) fait la somme des ventes pour chaque groupe.

Résumé de plusieurs colonnes. Image par l'auteur.

Ici, les regroupements multiples nous ont permis de visualiser les tendances des ventes par région et par année. Les régions Nord et Est affichent une croissance de 2021 à 2023. Le Sud ( ) a enregistré des ventes élevées en 2022, tandis que l'Ouest ne dispose de données que pour 2022-2023 .

Techniques avancées avec DAX SUMMARIZE()

Bien que SUMMARIZE() soit utile, vous pouvez le combiner avec d'autres fonctions DAX pour obtenir des capacités d'analyse de données encore plus sophistiquées. Explorons donc quelques exemples pour voir comment des techniques avancées peuvent exploiter SUMMARIZE() pour des agrégations et des résumés complexes.

Utilisation de SUMMARIZE() avec ROLLUP()

La fonction ROLLUP() de SUMMARIZE() ajoute des lignes de sous-totaux à vos tableaux récapitulatifs afin d'afficher les sous-totaux à différents niveaux de regroupement et de fournir des récapitulatifs hiérarchiques plus détaillés. Si vous travaillez dans le domaine de la finance ou dans toute autre fonction d'analyse pertinente, cette fonction est particulièrement utile pour effectuer des agrégations à plusieurs niveaux.

1. Ajoutez le mot-clé ROLLUP() après vos colonnes de regroupement dans SUMMARIZE().

2. Indiquez quelles colonnes doivent être incluses dans le calcul de ROLLUP().

SUMMARIZE(<table>, <groupBy_columnName>[, <groupBy_columnName>]…[, ROLLUP(<groupBy_columnName>[,< groupBy_columnName>…])][, <name>, <expression>]…)

Par exemple, cet ensemble de données montre les ventes et la quantité de chaque produit dans une régionparticulière . Je dois maintenant trouver le résumé des ventes par Région et Produit, avec des sous-totaux et des totaux.

Un tableau nommé sales_rollup. Image par l'auteur.

Pour ce faire, j'utilise la formule suivante :

	SalesWithRollup =
	SUMMARIZE(
	    sales_rollup,
	    ROLLUP(sales_rollup[Region], sales_rollup[Product]),
	    "Total Sales", SUM(sales_rollup[Sales]),
	    "Total Quantity", SUM(sales_rollup[Quantity])
	)

Utilisation de la fonction ROLLUP(). Image par l'auteur.

Vous pouvez voir - ici la fonction SUMMARIZE() regroupe les données de vente par région et produit pour calculer les ventes totales et la quantité totale. ROLLUP() ajoute des lignes de sous-total et de total général pour obtenir un résumé hiérarchique des performances de vente à différents niveaux de détail.

Combiner SUMMARIZE() avec ADDCOLUMNS()

Vous pouvez également étendre SUMMARIZE() avec ADDCOLUMNS() pour inclure des colonnes calculées personnalisées dans les données groupées. Cela peut s'avérer utile si vous souhaitez ajouter des mesures ou des calculs complexes à votre tableau récapitulatif.

Par exemple, j'utilise le même ensemble de données et j'applique la formule suivante pour ajouter une nouvelle colonne :

	SalesWithAddColumns =
	ADDCOLUMNS(
	    SUMMARIZE(
	        sales_rollup,
	        sales_rollup[Region],
	        sales_rollup[Product],
	        "Total Sales", SUM(sales_rollup[Sales]),
	        "Total Quantity", SUM(sales_rollup[Quantity])
	    ),
	    "Average Sales per Unit",
	        DIVIDE(SUM(sales_rollup[Sales]), SUM(sales_rollup[Quantity]), 0)
	)

Combinaison de SUMMARIZE() et ADDCOLUMNS(). Image par l'auteur.

Ici, la fonction SUMMARIZE() regroupe les ventes par région et produit pour calculer les ventes totales et la quantité totale. ADDCOLUMNS() calcule ensuite le Ventes moyennes par unité en divisant les ventes totales par la quantité totale pour chaque groupe.

Problèmes DAX courants et comment les résoudre

Lorsque vous utilisez SUMMARIZE(), vous pouvez rencontrer quelques problèmes. Mais ne vous inquiétez pas, nous sommes tous passés par là - je vais vous présenter quelques défis courants et vous expliquer comment les relever.

Éviter les résultats ambigus

Parfois, SUMMARIZE() peut vous donner des résultats qui ne sont pas tout à fait logiques. Cela se produit souvent lorsque votre modèle de données ou vos relations ne sont pas clairs. Voici comment éviter cela :

1. Vérifiez deux fois votre modèle de données : Assurez-vous que tous vos tableaux sont correctement connectés.

2. Utilisez des noms de colonnes clairs : Évitez les noms en double dans les différents tableaux.

3. Indiquez les noms des tableaux : Lorsque vous faites référence à des colonnes, indiquez le nom du tableau (comme Orders[OrderDate]) afin d'éviter toute confusion.

Considérations sur les performances

Bien que SUMMARIZE() soit une fonction utile, elle peut être gourmande en ressources et ralentir le traitement de grands ensembles de données. Cela signifie que l'actualisation de vos rapports peut prendre un peu plus de temps, en particulier si vous utilisez la fonction dans le cadre de mesures complexes ou avec de nombreuses colonnes groupées.

Voici quelques conseils pour que vos requêtes soient rapides :

• Pensez aux colonnes calculées : Pour les résumés fréquemment utilisés, créez des colonnes calculées au lieu d'utiliser SUMMARIZE() à chaque fois.

• Supprimez les colonnes inutiles : Éliminez les colonnes non pertinentes pour votre analyse, telles que les clés primaires ou les colonnes qui peuvent être calculées à partir d'autres colonnes.

• Utilisez des filtres : Utilisez DAX SUMMARIZE() avec Filter() avant de résumer pour réduire la quantité de données traitées.

Alternatives DAX à SUMMARIZE()

Bien que SUMMARIZE() soit une fonction utile, d'autres outils peuvent parfois mieux faire le travail. Examinons quelques alternatives et les cas dans lesquels vous pourriez vouloir les utiliser.

SUMMARIZECOLUMNS()

SUMMARIZECOLUMNS() est une autre fonction DAX qui facilite la création de tableaux récapitulatifs lorsque vous travaillez avec des données volumineuses ou des situations complexes. Il est similaire à SUMMARIZE(), mais avec quelques différences.

• Vous pouvez ajouter des filtres directement à SUMMARIZECOLUMNS(), ce qui accélère le processus.

• Avec SUMMARIZECOLUMNS(), vous pouvez inclure des mesures directement dans votre production. Il n'est pas nécessaire d'utiliser des fonctions supplémentaires telles que ADDCOLUMNS().

• SUMMARIZECOLUMNS() traite automatiquement les lignes vides, de sorte que vous n'avez pas à vous en préoccuper.

SUMMARIZECOLUMNS(
    <groupBy_columnName> [, <groubBy_columnName>] …, [<filterTable>] … [, <name>, <expression>] …
)

Par exemple, je dispose d'un ensemble de données et je souhaite résumer les salaires des employés par région et par département tout en filtrant les employés dont le prénom est Raven. J'utiliserai la fonction SUMMARIZECOLUMNS() pour calculer le salaire total de Raven dans les différentes régions et départements.

Un tableau nommé employee_data. Image par l'auteur.

Pour ce faire, j'utilise la formule suivante :  

	SalarySummary =
	SUMMARIZECOLUMNS(
	    employee_data[Name],
	    employee_data[Region],
	    employee_data[Department],
	    FILTER(employee_data, employee_data[Name] = "Raven"),
	    "Total Salary", SUM(employee_data[Salary])
	)

Dans la formule ci-dessus : 

• SalarySummary est le nom donné au tableau calculé en cours de création.

• SUMMARIZECOLUMNS(...) crée un tableau récapitulatif basé sur les tableaux et les calculs spécifiés.

• employee_data[Name], employee_data[Region], employee_data[Department] sont les colonnes par lesquelles les données seront regroupées.

• FILTER(employee_data, employee_data[Name] = "Raven") restreint les résultats aux seules lignes où le paramètre nom est Corbeau.

• "Total Salary", SUM(employee_data[Salary]) crée une colonne calculée dans le résultat.

• SUM(employee_data[Salary]) calcule la somme de toutes les valeurs salariales pour chaque groupe.

Utilisez SUMMARIZECOLUMNS pour résumer les résultats. Image par l'auteur.

Vous pouvez voir les résultats - la fonction SUMMARIZECOLUMNS() filtre l'ensemble des données et calcule les totaux des salaires de Raven dans les différents lieux et départements. 

GROUPBY()

GROUPBY() est une autre fonction qui peut parfois remplacer SUMMARIZE() lorsque vous avez simplement besoin de regrouper des données et d'effectuer des calculs sur ces groupes. Il peut être plus efficace que SUMMARIZE() pour les opérations de regroupement simples.

Alors que SUMMARIZE() peut travailler sur des tableaux connexes, GROUPBY() se concentre sur le regroupement et l'agrégation au sein d'un seul tableau, ce qui améliore les performances dans certains scénarios.

Prenons un exemple. Je dois créer un ensemble de données d'inventaire pour le cursus des articles, des catégories, des unités vendues et des prix unitaires, puis regrouper les données par catégorie pour calculer le revenu total pour chacune d'entre elles.

Tableau d'inventaire. Image par l'auteur.

Pour ce faire, j'utilise la formule suivante :  

	SummaryGroupBY =
	GROUPBY(
	    Inventory,
	    Inventory[Category],
	    "Total Revenue",
	    SUMX(
	        CURRENTGROUP(),
	        Inventory[Units Sold] * Inventory[Unit Price]
	    )
	)

Dans la formule ci-dessus :

• GROUPBY() regroupe les données par Catégorie.

• CURRENTGROUP() se réfère à chaque groupe de catégorie (par exemple, électronique, meubles ou appareils électroménagers).

• SUMX() calcule le revenu total de chaque groupe en multipliant le nombre d'unités vendues par le nombre d'unités vendues. Unités vendues avec le le prix unitaire.

Utiliser GROUPBY pour regrouper les données. Image par l'auteur. 

Comme vous pouvez le constater, la fonction GROUPBY() calcule facilement les éléments suivants revenu total en multipliant Unités vendues par le prix unitaire pour chaque article de la catégorie et en résumant ces recettes individuelles.

Dernières réflexions sur DAX SUMMARIZE()

Vous savez maintenant comment la fonction SUMMARIZE() de DAX peut vous aider à regrouper et à analyser des données dans Power BI, Excel et d'autres outils. Du regroupement de base aux techniques avancées telles que ROLLUP() et ADDCOLUMNS(), SUMMARIZE() permet de créer des résumés pertinents.

Comme c'est en forgeant qu'on devient forgeron, essayez ces techniques avec vos propres données pour voir comment elles peuvent vous aider à découvrir des informations utiles. Si vous souhaitez peaufiner davantage vos compétences DAX, inscrivez-vous à notre cours Introduction à DAX dans Power BI pour devenir un véritable power user.