Tutoriel : Utiliser des fonctions d’agrégation

Changer de service à l’aide de la liste déroulante Version . En savoir plus sur la navigation.
S’applique à : ✅ Microsoft Fabric ✅ Azure Data Explorer ✅ Azure Monitor ✅ Microsoft Sentinel

Les fonctions d’agrégation regroupent et combinent les données de plusieurs lignes en une valeur de synthèse. La valeur récapitulative dépend de la fonction choisie, telle qu’un nombre, un maximum ou une valeur moyenne.

Dans ce tutoriel, vous allez apprendre à :

Ce didacticiel s’appuie sur la base du premier didacticiel, learn common operators.

Prérequis

Pour exécuter les requêtes suivantes, vous avez besoin d’un environnement de requête avec accès aux exemples de données. Utilisez l’une des options suivantes :

Utiliser l’opérateur de synthèse

L’opérateur de synthèse est essentiel pour effectuer des agrégations sur vos données. L’opérateur summarize regroupe des lignes en fonction de la by clause, puis utilise la fonction d’agrégation fournie pour combiner chaque groupe en une seule ligne.

Recherchez le nombre d’événements par état à l’aide summarize de la fonction d’agrégation de nombre .

StormEvents
| summarize TotalStorms = count() by State

Sortie

Visualiser les résultats de requête

La visualisation des résultats d’une requête dans un diagramme ou un graphique peut vous aider à identifier des motifs, des tendances et des valeurs aberrantes dans vos données. Vous pouvez créer ces visualisations à l’aide de l’opérateur de rendu .

Tout au long du tutoriel, vous voyez des exemples d’utilisation render pour afficher vos résultats. Certains types de graphiques disponibles incluent des graphiques à barres, des graphiques en courbes, des graphiques en secteurs et des graphiques à nuages de points. Pour l’instant, utilisez cette option render pour afficher les résultats de la requête précédente dans un graphique à barres.

StormEvents
| summarize TotalStorms = count() by State
| render barchart

Compter les lignes selon une condition

Lors de l’analyse de vos données, utilisez countif() pour compter les lignes en fonction d’une condition spécifique. Cette fonction vous aide à comprendre le nombre de lignes qui répondent aux critères donnés.

La requête suivante utilise countif() pour compter les tempêtes qui ont causé des dommages. La requête utilise ensuite l’opérateur top pour filtrer les résultats et afficher les états avec la quantité la plus élevée de dommages causés par les tempêtes.

StormEvents
| summarize StormsWithCropDamage = countif(DamageCrops > 0) by State
| top 5 by StormsWithCropDamage

Sortie

Regrouper des données dans des compartiments

Pour agréger des données par valeurs numériques ou temporelles, commencez par regrouper les données dans des bacs à l’aide de la fonction bin(). L’utilisation bin() vous aide à comprendre comment les valeurs sont distribuées dans une certaine plage et facilite la comparaison de différentes périodes.

La requête suivante compte le nombre de tempêtes qui ont causé des dommages aux cultures pour chaque semaine en 2007. L’argument 7d représente une semaine, car la fonction requiert une valeur d’intervalle de temps valide.

StormEvents
| where StartTime between (datetime(2007-01-01) .. datetime(2007-12-31)) 
    and DamageCrops > 0
| summarize EventCount = count() by bin(StartTime, 7d)

Sortie

Ajoutez | render timechart à la fin de la requête pour visualiser les résultats.

Calculer les valeurs min, max, avg et sum

Pour en savoir plus sur les types de tempêtes qui causent des dégâts aux cultures, calculez les dégâts aux cultures min(), max() et avg() pour chaque type d’événement. Ensuite, triez le résultat par les dommages moyens.

Vous pouvez utiliser plusieurs fonctions d’agrégation dans un seul summarize opérateur pour produire plusieurs colonnes calculées.

StormEvents
| where DamageCrops > 0
| summarize
    MaxCropDamage=max(DamageCrops), 
    MinCropDamage=min(DamageCrops), 
    AvgCropDamage=avg(DamageCrops)
    by EventType
| sort by AvgCropDamage

Sortie

Les résultats de la requête précédente indiquent que les événements Frost/Freeze entraînent en moyenne le plus de dégâts sur les cultures. Toutefois, la requête bin() indique que les événements avec des dommages aux cultures ont eu lieu principalement dans les mois d’été.

Utilisez sum() pour vérifier le nombre total de cultures endommagées au lieu de la quantité d’événements qui ont causé des dommages, comme dans count() la requête bin() précédente.

StormEvents
| where StartTime between (datetime(2007-01-01) .. datetime(2007-12-31)) 
    and DamageCrops > 0
| summarize CropDamage = sum(DamageCrops) by bin(StartTime, 7d)
| render timechart

On peut maintenant observer un pic des dégâts causés aux cultures en janvier, ce qui était probablement dû au gel.

Calculer des pourcentages

Le calcul des pourcentages peut vous aider à comprendre la distribution et la proportion de différentes valeurs au sein de vos données. Cette section traite de deux méthodes courantes pour calculer des pourcentages à l’aide du langage de requête Kusto (KQL).

Calculer le pourcentage en fonction de deux colonnes

Utilisez count() et countif pour trouver le pourcentage d’événements de tempête qui ont provoqué des dommages de culture dans chaque état. Tout d’abord, comptez le nombre total de tempêtes dans chaque état. Ensuite, comptez le nombre de tempêtes qui ont causé des dommages aux cultures dans chaque état.

Ensuite, utilisez l’extension pour calculer le pourcentage entre les deux colonnes en divisant le nombre de tempêtes avec des dommages de culture par le nombre total de tempêtes et en multipliant par 100.

Pour vous assurer que vous obtenez un résultat décimal, utilisez la fonction todouble() pour convertir au moins une des valeurs de nombre entier en double avant d’effectuer la division.

StormEvents
| summarize 
    TotalStormsInState = count(),
    StormsWithCropDamage = countif(DamageCrops > 0)
    by State
| extend PercentWithCropDamage = 
    round((todouble(StormsWithCropDamage) / TotalStormsInState * 100), 2)
| sort by StormsWithCropDamage

Sortie

Calculer le pourcentage en fonction de la taille de la table

Pour comparer le nombre de tempêtes par type d’événement au nombre total de tempêtes dans la base de données, commencez par enregistrer le nombre total de tempêtes dans la base de données sous forme de variable. Utilisez des instructions Let pour définir des variables dans une requête.

Étant donné que les instructions d’expression tabulaire retournent des résultats tabulaires, utilisez la fonction toscalar() pour convertir le résultat tabulaire de la count() fonction en valeur scalaire. Ensuite, utilisez la valeur numérique dans le calcul du pourcentage.

let TotalStorms = toscalar(StormEvents | summarize count());
StormEvents
| summarize EventCount = count() by EventType
| project EventType, EventCount, Percentage = todouble(EventCount) / TotalStorms * 100.0

Sortie

Extraire des valeurs uniques

Utilisez make_set() pour transformer une sélection de lignes dans une table en tableau de valeurs uniques.

La requête suivante utilise make_set() pour créer un tableau des types d’événements qui provoquent des décès dans chaque état. La table résultante est ensuite triée en fonction du nombre de types de tempête dans chaque tableau.

StormEvents
| where DeathsDirect > 0 or DeathsIndirect > 0
| summarize StormTypesWithDeaths = make_set(EventType) by State
| project State, StormTypesWithDeaths
| sort by array_length(StormTypesWithDeaths)

Sortie

Regrouper les données par condition

La fonction case() regroupe les données dans des compartiments en fonction des conditions spécifiées. La fonction renvoie l’expression de résultat correspondante pour le premier prédicat satisfait, ou l’expression else finale si aucun des prédicats n’est satisfait.

Cet exemple regroupe les états basés sur le nombre de blessures liées à la tempête que leurs citoyens ont subis.

StormEvents
| summarize InjuriesCount = sum(InjuriesDirect) by State
| extend InjuriesBucket = case (
                              InjuriesCount > 50,
                              "Large",
                              InjuriesCount > 10,
                              "Medium",
                              InjuriesCount > 0,
                              "Small",
                              "No injuries"
                          )
| sort by State asc

Sortie

Créez un graphique en secteurs pour visualiser la proportion d’états qui ont connu des tempêtes entraînant un grand, moyen ou petit nombre de blessures.

StormEvents
| summarize InjuriesCount = sum(InjuriesDirect) by State
| extend InjuriesBucket = case (
                              InjuriesCount > 50,
                              "Large",
                              InjuriesCount > 10,
                              "Medium",
                              InjuriesCount > 0,
                              "Small",
                              "No injuries"
                          )
| summarize InjuryBucketByState=count() by InjuriesBucket
| render piechart 

Effectuer des agrégations sur une fenêtre glissante

L’exemple suivant montre comment synthétiser des colonnes à l’aide d’une fenêtre glissante.

La requête calcule les dommages matériels minimums, maximums et moyens causés par les tornades, les inondations et les feux de forêt au moyen d’une fenêtre glissante de sept jours. Chaque enregistrement du jeu de résultats regroupe les sept jours précédents et les résultats contiennent un enregistrement par jour dans la période d’analyse.

Voici une explication pas à pas de la requête :

1. Attribuez chaque enregistrement à une seule journée par rapport à windowStart.
2. Ajoutez sept jours à la valeur bin pour définir la fin de la plage pour chaque enregistrement. Si la valeur est en dehors de la plage de windowStart et windowEnd, ajustez-la en conséquence.
3. Créez un tableau de sept jours pour chaque enregistrement, à partir du jour actuel de l’enregistrement.
4. Développez le tableau de l’étape 3 à l’aide de mv-expand pour dupliquer chaque enregistrement à sept enregistrements avec des intervalles d’un jour entre eux.
5. Effectuez les agrégations pour chaque jour. À cause de l’étape 4, cette étape résume réellement les sept jours précédents.
6. Excluez les sept premiers jours du résultat final, car il n’y a pas de période de rétrospection de sept jours pour ces jours.

let windowStart = datetime(2007-07-01);
let windowEnd = windowStart + 13d;
StormEvents
| where EventType in ("Tornado", "Flood", "Wildfire") 
| extend bin = bin_at(startofday(StartTime), 1d, windowStart) // 1
| extend endRange = iff(bin + 7d > windowEnd, windowEnd, 
                      iff(bin + 7d - 1d < windowStart, windowStart, 
                        iff(bin + 7d - 1d < bin, bin, bin + 7d - 1d))) // 2
| extend range = range(bin, endRange, 1d) // 3
| mv-expand range to typeof(datetime) // 4
| summarize min(DamageProperty), max(DamageProperty), round(avg(DamageProperty)) by Timestamp=bin_at(range, 1d, windowStart), EventType // 5
| where Timestamp >= windowStart + 7d; // 6

Sortie

Le tableau de résultats suivant est tronqué. Pour voir la sortie complète, exécutez la requête.

Étape suivante

Maintenant que vous êtes familiarisé avec les opérateurs de requête courants et les fonctions d’agrégation, passez au tutoriel suivant pour découvrir comment joindre des données à partir de plusieurs tables.