Esercitazione: Usare le funzioni di aggregazione

Cambiare i servizi usando l'elenco a discesa Versione. Altre informazioni sulla navigazione.
Si applica a: ✅ Microsoft Fabric ✅ Esplora dati di Azure ✅ Monitoraggio di Azure ✅ Microsoft Sentinel

Le funzioni di aggregazione raggruppano e combinano i dati di più righe in un valore di riepilogo. Il valore di riepilogo dipende dalla funzione scelta, ad esempio un conteggio, un valore massimo o medio.

In questa esercitazione apprenderai a:

Questo tutorial si basa sulle nozioni fondamentali del primo tutorial, Impara gli operatori comuni.

Prerequisiti

Per eseguire le query seguenti, è necessario un ambiente di query con accesso ai dati di esempio. Usare una delle seguenti opzioni:

Usare l'operatore di riepilogo

L'operatore summarize è essenziale per eseguire aggregazioni sui dati. L'operatore summarize raggruppa le righe in base alla by clausola e quindi usa la funzione di aggregazione fornita per combinare ogni gruppo in una singola riga.

Trova il numero di eventi per stato usando summarize con la funzione di aggregazione count.

StormEvents
| summarize TotalStorms = count() by State

Output

Visualizzare i risultati delle query

Visualizzare i risultati delle query in un grafico o in un diagramma può aiutarti a identificare schemi, tendenze e valori anomali nei dati. È possibile creare queste visualizzazioni usando l'operatore render .

Nell'esercitazione vengono visualizzati esempi di come usare render per visualizzare i risultati. Alcuni tipi di grafico disponibili includono grafici a barre, grafici a linee, grafici a torta e grafici a dispersione. Per il momento, usare render per visualizzare i risultati della query precedente in un grafico a barre.

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

Conteggio condizionale delle righe

Quando si analizzano i dati, usare countif() per contare le righe in base a una condizione specifica. Questa funzione consente di comprendere il numero di righe che soddisfano i criteri specificati.

La query seguente usa countif() per contare le tempeste che hanno causato danni. La query usa quindi l'operatore top per filtrare i risultati e visualizzare gli stati con la quantità più elevata di danni alle colture causati da tempeste.

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

Output

Raggruppare i dati in contenitori

Per aggregare i dati in base a valori numerici o temporali, raggruppare prima i dati in contenitori usando la funzione bin(). L'uso bin() di consente di comprendere in che modo i valori vengono distribuiti all'interno di un determinato intervallo e semplificano il confronto di periodi diversi.

La query seguente conta il numero di tempeste che hanno causato danni alle colture per ogni settimana nel 2007. L'argomento 7d rappresenta una settimana, perché la funzione richiede un valore timepan valido.

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

Output

Aggiungere | render timechart alla fine della query per visualizzare i risultati.

Calcolare il minimo, il massimo, la media e la somma

Per saperne di più sui tipi di tempeste che causano danni alle colture, calcolare i danni alle colture min(), max() e avg() per ogni tipo di evento. Ordinare quindi il risultato in base al danno medio.

È possibile usare più funzioni di aggregazione in un singolo summarize operatore per produrre diverse colonne calcolate.

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

Output

I risultati della query precedente indicano che gli eventi Frost/Freeze generano in media il maggior numero di danni alle colture. Tuttavia, la query bin() indica che gli eventi con danni alle colture si svolgono principalmente nei mesi estivi.

Usare sum() per controllare il numero totale di colture danneggiate anziché la quantità di eventi che hanno causato alcuni danni, come nella count() query bin() precedente.

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

Ora si può vedere un picco di danni alle colture nel mese di gennaio, che probabilmente era dovuto a Frost/Freeze.

Calcolare le percentuali

Il calcolo delle percentuali consente di comprendere la distribuzione e la proporzione di valori diversi all'interno dei dati. Questa sezione illustra due metodi comuni per calcolare le percentuali usando il linguaggio di query Kusto (KQL).

Calcolare la percentuale in base a due colonne

Usare count() e countif per trovare la percentuale di eventi di tempesta che hanno causato danni alle colture in ogni stato. In primo luogo, contare il numero totale di tempeste in ogni stato. Quindi, contare il numero di tempeste che hanno causato danni alle colture in ogni stato.

Usare quindi l'estensione per calcolare la percentuale tra le due colonne dividendo il numero di tempeste con danni alle colture per il numero totale di tempeste e moltiplicando per 100.

Per assicurarsi di ottenere un risultato decimale, usare la funzione todouble() per convertire almeno uno dei valori di conteggio integer in un valore double prima di eseguire la divisione.

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

Output

Calcolare la percentuale in base alle dimensioni della tabella

Per confrontare il numero di tempeste in base al tipo di evento con il numero totale di tempeste nel database, salvare prima il numero totale di tempeste nel database come variabile. Usare le istruzioni Let per definire le variabili all'interno di una query.

Poiché le istruzioni di espressione tabulare restituiscono risultati tabulari , usare la funzione toscalar() per convertire il risultato tabulare della count() funzione in un valore scalare. Usare quindi il valore numerico nel calcolo percentuale.

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

Output

Estrarre valori univoci

Usare make_set() per trasformare una selezione di righe in una tabella in una matrice di valori univoci.

La query seguente usa make_set() per creare una matrice dei tipi di evento che causano decessi in ogni stato. La tabella risultante viene quindi ordinata in base al numero di tipi di tempesta presenti in ciascun array.

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

Output

Dati del bucket per condizione

La funzione case() raggruppa i dati in bucket in base alle condizioni specificate. La funzione restituisce l'espressione di risultato corrispondente per il primo predicato soddisfatto o l'espressione else finale se nessuno dei predicati viene soddisfatto.

Questo esempio raggruppa gli stati in base al numero di lesioni correlate alle tempeste sostenute dai cittadini.

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

Output

Crea un grafico a torta per visualizzare la proporzione di Stati in cui si sono verificate tempeste che hanno causato un numero alto, medio o basso di feriti.

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 

Eseguire aggregazioni su una finestra temporale scorrevole

Nell'esempio seguente viene illustrato come riepilogare le colonne usando una finestra scorrevole.

La query calcola i danni minimi, massimi e medi alle proprietà causati da tornado, inondazioni e incendi boschivi utilizzando una finestra scorrevole di sette giorni. Ogni record nel set di risultati aggrega i sette giorni precedenti e i risultati contengono un record per ogni giorno del periodo di analisi.

Ecco una spiegazione dettagliata della query:

1. Raggruppa ogni record in un unico giorno rispetto a windowStart.
2. Aggiungi sette giorni al valore di bin per impostare la fine dell'intervallo per ogni record. Se il valore non è compreso nell'intervallo di windowStart e windowEnd, modificare il valore di conseguenza.
3. Creare una matrice di sette giorni per ogni record, a partire dal giorno corrente del record.
4. Espandere la matrice dal passaggio 3 usando mv-expand per duplicare ogni record a sette record con intervalli di un giorno tra di essi.
5. Eseguire le aggregazioni per ogni giorno. A causa del passaggio 4, questo passaggio riepiloga effettivamente i sette giorni precedenti.
6. Escludere i primi sette giorni dal risultato finale perché non esiste un periodo di lookback di sette giorni per loro.

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

Output

La tabella dei risultati seguente viene troncata. Per visualizzare l'output completo, eseguire la query.

Passaggio successivo

Ora che si ha familiarità con gli operatori di query e le funzioni di aggregazione comuni, passare all'esercitazione successiva per informazioni su come unire dati da più tabelle.