Lernprogramm: Verwenden von Aggregationsfunktionen

Wechseln Sie Dienste mit der Dropdownliste "Version". Weitere Informationen zur Navigation.
Gilt für: ✅ Microsoft Fabric ✅ Azure Data Explorer ✅ Azure Monitor ✅ Microsoft Sentinel

Aggregationsfunktionen gruppieren und kombinieren Daten aus mehreren Zeilen zu einem zusammengefassten Wert. Der Zusammenfassungswert hängt von der ausgewählten Funktion ab, z. B. einer Anzahl, einem Maximum oder einem Mittelwert.

In diesem Tutorial erfahren Sie, wie:

Dieses Lernprogramm baut auf der Grundlage des ersten Lernprogramms auf, lernen Sie allgemeine Operatoren kennen.

Voraussetzungen

Zum Ausführen der folgenden Abfragen benötigen Sie eine Abfrageumgebung mit Zugriff auf die Beispieldaten. Verwenden Sie eine der folgenden Optionen:

Verwenden Sie den summarize-Operator

Der Zusammenfassungsoperator ist für die Durchführung von Aggregationen über Ihre Daten unerlässlich. Der summarize Operator gruppiert Zeilen basierend auf der by Klausel und verwendet dann die bereitgestellte Aggregationsfunktion, um jede Gruppe in einer einzelnen Zeile zu kombinieren.

Ermitteln Sie die Anzahl der Ereignisse nach Status mithilfe von summarize mit der Aggregationsfunktion Anzahl.

StormEvents
| summarize TotalStorms = count() by State

Ausgabe

Visualisieren von Abfrageergebnissen

Durch die Visualisierung von Abfrageergebnissen in einem Diagramm können Sie Muster, Trends und Ausreißer in Ihren Daten identifizieren. Sie können diese Visualisierungen mithilfe des Renderoperators erstellen.

Im gesamten Lernprogramm sehen Sie Beispiele für die Verwendung render zum Anzeigen Ihrer Ergebnisse. Einige verfügbare Diagrammtypen umfassen Balkendiagramme, Liniendiagramme, Kreisdiagramme und Punktdiagramme. Vorerst verwenden Sie render, um die Ergebnisse der vorherigen Abfrage in einem Balkendiagramm anzuzeigen.

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

Bedingte Anzahl von Zeilen

Wenn Sie Ihre Daten analysieren, verwenden Sie countif(), um Zeilen basierend auf einer bestimmten Bedingung zu zählen. Diese Funktion hilft Ihnen zu verstehen, wie viele Zeilen den angegebenen Kriterien entsprechen.

Die folgende Abfrage verwendet countif() , um Stürme zu zählen, die Schäden verursacht haben. Die Abfrage verwendet dann den Operator top, um die Ergebnisse zu filtern und die Bundesstaaten mit den größten durch Stürme verursachten Ernteschäden anzuzeigen.

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

Ausgabe

Gruppieren von Daten in Container

Um Daten nach numerischen oder Zeitwerten zu aggregieren, gruppieren Sie die Daten zuerst mithilfe der Bin() -Funktion in Bins. Die Verwendung von bin() hilft Ihnen zu verstehen, wie sich Werte in einem bestimmten Bereich verteilen, und erleichtert den Vergleich verschiedener Zeiträume.

Die folgende Abfrage zählt die Anzahl der Stürme, die für jede Woche im Jahr 2007 Ernteschäden verursacht haben. Das 7d Argument stellt eine Woche dar, da für die Funktion ein gültiger Zeitbereichswert erforderlich ist.

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

Ausgabe

Fügen Sie zum Ende der Abfrage hinzu | render timechart , um die Ergebnisse zu visualisieren.

Berechnen von Min., Max., Mittelwert und Summe

Um mehr über die Arten von Stürmen zu erfahren, die Ernteschäden verursachen, berechnen Sie die min()-, max()- und avg()-Ernteschäden für jeden Ereignistyp. Sortieren Sie dann das Ergebnis nach dem durchschnittlichen Schaden.

Sie können mehrere Aggregationsfunktionen in einem einzigen summarize Operator verwenden, um mehrere berechnete Spalten zu erzeugen.

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

Ausgabe

Die Ergebnisse der vorangegangenen Abfrage deuten darauf hin, dass Frost/Freeze-Ereignisse im Durchschnitt die größten Ernteschäden verursachen. Die bin()-Abfrage zeigt jedoch, dass Ereignisse mit Ernteschäden hauptsächlich in den Sommermonaten stattfinden.

Verwenden Sie Summe(), um die Gesamtanzahl der beschädigten Kulturen anstelle der Anzahl der Ereignisse zu überprüfen, die einen Schaden verursacht haben, wie in count() der vorherigen Bin()-Abfrage.

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

Jetzt können Sie im Januar einen Höhepunkt der Ernteschäden sehen, was wahrscheinlich auf Frost/Freeze zurückzuführen war.

Berechnen von Prozentsätzen

Die Berechnung von Prozentsätzen kann Ihnen dabei helfen, die Verteilung und den Anteil verschiedener Werte in Ihren Daten zu verstehen. In diesem Abschnitt werden zwei gängige Methoden zum Berechnen von Prozentsätzen mithilfe der Kusto Query Language (KQL) behandelt.

Berechnen des Prozentsatzes basierend auf zwei Spalten

Verwenden Sie count() und countif, um den prozentualen Anteil der Sturmereignisse zu ermitteln, die in jedem Bundesstaat Ernteschäden verursacht haben. Zählen Sie zunächst die Gesamtzahl der Stürme in jedem Bundesland. Zählen Sie dann, wie viele Stürme in jedem Bundesstaat Ernteschäden verursacht haben.

Verwenden Sie dann extend, um den Prozentsatz aus den beiden Spalten zu berechnen, indem Sie die Anzahl der Stürme mit Ernteschäden durch die Gesamtzahl der Stürme dividieren und mit 100 multiplizieren.

Um sicherzustellen, dass Sie ein Dezimalergebnis erhalten, verwenden Sie die Todouble() -Funktion, um mindestens einen der Ganzzahlwerte in ein Double zu konvertieren, bevor Sie die Division ausführen.

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

Ausgabe

Berechnen des Prozentsatzes basierend auf der Tabellengröße

Um die Anzahl der Stürme nach Ereignistyp mit der Gesamtzahl der Stürme in der Datenbank zu vergleichen, speichern Sie zuerst die Gesamtzahl der Stürme in der Datenbank als Variable. Verwenden Sie Let-Anweisungen , um Variablen innerhalb einer Abfrage zu definieren.

Da tabellarische Ausdrucksanweisungen tabellarische Ergebnisse zurückgeben, verwenden Sie die Toscalar() -Funktion, um das tabellarische Ergebnis der count() Funktion in einen skalaren Wert zu konvertieren. Verwenden Sie dann den numerischen Wert in der Prozentberechnung.

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

Ausgabe

Eindeutige Werte extrahieren

Verwenden Sie make_set(), um eine Auswahl von Zeilen in einer Tabelle in ein Array eindeutiger Werte umzuwandeln.

Die folgende Abfrage verwendet make_set() , um ein Array der Ereignistypen zu erstellen, die zu Todesfällen in jedem Zustand führen. Die resultierende Tabelle wird dann nach der Anzahl der Sturmtypen in den einzelnen Arrays sortiert.

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

Ausgabe

Daten nach Bedingung gruppieren

Die Case()- Funktion gruppiert Daten basierend auf angegebenen Bedingungen in Buckets. Die Funktion gibt den entsprechenden Ergebnisausdruck für das erste erfüllte Prädikat oder den abschließenden Else-Ausdruck zurück, falls keines der Prädikate erfüllt ist.

In diesem Beispiel werden Staaten basierend auf der Anzahl der stürmischen Verletzungen gruppiert, die ihre Bürger erlitten haben.

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

Ausgabe

Erstellen Sie ein Kreisdiagramm, um den Anteil der Bundesstaaten zu visualisieren, in denen Stürme eine hohe, mittlere oder geringe Anzahl an Verletzungen verursachten.

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 

Aggregationen in einem gleitenden Fenster durchführen

Das folgende Beispiel zeigt, wie Sie Spalten mithilfe eines gleitenden Fensters zusammenfassen.

Die Abfrage berechnet den minimalen, maximalen und durchschnittlichen Schaden von Tornados, Überschwemmungen und Waldbränden mithilfe eines Gleitfensters von sieben Tagen. Jeder Datensatz im Resultset aggregiert die vorangegangenen sieben Tage, und die Ergebnisse enthalten einen Datensatz pro Tag im Analysezeitraum.

Hier ist eine schrittweise Erläuterung der Abfrage:

1. Ordnen Sie jeden Datensatz genau einem Tag bezogen auf windowStart zu.
2. Fügen Sie dem Bin-Wert sieben Tage hinzu, um das Ende des Bereichs für jeden Datensatz festzulegen. Wenn sich der Wert außerhalb des Bereichs von windowStart bis windowEnd befindet, passen Sie den Wert entsprechend an.
3. Erstellen Sie ein Array von sieben Tagen für jeden Datensatz ab dem aktuellen Tag des Datensatzes.
4. Erweitern Sie das Array aus Schritt 3, indem Sie mv-expand verwenden, um jeden Datensatz mit sieben Datensätzen mit eintägigen Intervallen zu duplizieren.
5. Führen Sie die Aggregationen für jeden Tag aus. Aufgrund von Schritt 4 fasst dieser Schritt tatsächlich die vorherigen sieben Tage zusammen.
6. Schließen Sie die ersten sieben Tage vom Endergebnis aus, da es keinen Sieben-Tage-Lookbackzeitraum für sie gibt.

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

Ausgabe

Die folgende Ergebnistabelle ist gekürzt. Führen Sie die Abfrage aus, um die vollständige Ausgabe anzuzeigen.

Nächster Schritt

Nachdem Sie nun mit allgemeinen Abfrageoperatoren und Aggregationsfunktionen vertraut sind, fahren Sie mit dem nächsten Lernprogramm fort, um zu erfahren, wie Sie Daten aus mehreren Tabellen verknüpfen.