Självstudie: Använda sammansättningsfunktioner

Gäller för: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Med sammansättningsfunktioner kan du gruppera och kombinera data från flera rader till ett sammanfattningsvärde. Sammanfattningsvärdet beror på den valda funktionen, till exempel ett antal, maximalt eller genomsnittligt värde.

I den här självstudien får du lära dig att:

Den här självstudien bygger på grunden från den första självstudiekursen, Learn common operators(Lär dig vanliga operatorer).

Förutsättningar

Om du vill köra följande frågor behöver du en frågemiljö med åtkomst till exempeldata. Du kan använda något av följande:

Använda sammanfattningsoperatorn

Sammanfattningsoperatorn är viktig för att utföra aggregeringar över dina data. Operatorn summarize grupperar rader baserat på by -satsen och använder sedan den angivna aggregeringsfunktionen för att kombinera varje grupp i en enda rad.

Hitta antalet händelser efter tillstånd med hjälp summarize av funktionen count aggregation.

StormEvents
| summarize TotalStorms = count() by State

Resultat

Visualisera frågeresultat

Genom att visualisera sökfrågeresultat i ett diagram eller en graf kan du identifiera mönster, trender och extremvärden i din datauppsättning. Du kan göra detta med återgivningsoperatorn .

Under hela självstudien kommer du att se exempel på hur du använder render för att visa dina resultat. Nu ska vi använda render för att se resultatet från föregående fråga i ett stapeldiagram.

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

Villkorligt antal rader

När du analyserar dina data använder du countif() för att räkna rader baserat på ett specifikt villkor för att förstå hur många rader som uppfyller de angivna kriterierna.

Följande fråga använder countif() för att räkna stormar som orsakat skador. Frågan använder sedan operatorn top för att filtrera resultaten och visa de staterna med den största mängden skador på grödor som orsakas av stormar.

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

Resultat

Gruppera data i lagerplatser

Om du vill aggregera efter numeriska värden eller tidsvärden ska du först gruppera data med hjälp av funktionen bin(). Med hjälp av bin() kan du förstå hur värden distribueras inom ett visst intervall och göra jämförelser mellan olika perioder.

Följande fråga räknar antalet stormar som orsakade skördeskador för varje vecka under 2007. Argumentet 7d representerar en vecka, eftersom funktionen kräver ett giltigt tidsintervallvärde .

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

Resultat

Lägg till | render timechart i slutet av frågan för att visualisera resultatet.

Beräkna min, max, genomsnitt och summa

Om du vill veta mer om typer av stormar som orsakar skador på grödor, beräkna min(), max(), och avg() skador på grödor för varje händelsetyp och sortera sedan resultatet efter den genomsnittliga skadan.

Observera att du kan använda flera aggregeringsfunktioner i en enda summarize operator för att skapa flera beräknade kolumner.

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

Resultat

Resultatet av föregående fråga visar att frost-/fryshändelser resulterade i de största grödeskadorna i genomsnitt. Frågan bin() visade dock att händelser med växtskador mestadels ägde rum under sommarmånaderna.

Använd sum() för att kontrollera det totala antalet skadade grödor i stället för mängden händelser som orsakade viss skada, som i count() föregående bin()-fråga.

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

Nu kan du se en topp i växtskadorna i januari, vilket förmodligen berodde på frost.

Beräkna procentsatser

Genom att beräkna procentandelar kan du förstå fördelningen och andelen av olika värden i dina data. Det här avsnittet beskriver två vanliga metoder för att beräkna procentandelar med Kusto Query Language (KQL).

Beräkna procent baserat på två kolumner

Använd count() och countif för att hitta procentandelen stormhändelser som orsakade skador på grödor i varje delstat. Först, räkna det sammanlagda antalet stormar i varje delstat. Räkna sedan antalet stormar som orsakade skördeskador i varje delstat.

Använd sedan extend för att beräkna procentandelen mellan de två kolumnerna genom att dividera antalet stormar med grödskador med det totala antalet stormar och sedan multiplicera med 100.

För att säkerställa att du får ett decimalresultat använder du funktionen todouble() för att konvertera minst ett av heltalsvärdena till en dubbel innan du utför divisionen.

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

Resultat

Beräkna procent baserat på tabellstorlek

Om du vill jämföra antalet stormar efter händelsetyp med det totala antalet stormar i databasen sparar du först det totala antalet stormar i databasen som en variabel. Let-instruktioner används för att definiera variabler i en fråga.

Eftersom tabelluttrycksinstruktioner returnerar tabellresultat använder du funktionen toscalar() för att konvertera funktionens tabellresultat count() till ett skalärt värde. Sedan kan det numeriska värdet användas i procentberäkningen.

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

Resultat

Extrahera unika värden

Använd make_set() för att omvandla ett urval av rader i en tabell till en matris med unika värden.

Följande fråga används make_set() för att skapa en matris med de händelsetyper som orsakar dödsfall i varje tillstånd. Den resulterande tabellen sorteras sedan efter antalet stormtyper i varje matris.

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

Resultat

Gruppera data efter villkor

Funktionen case() grupperar data i bucketar baserat på angivna villkor. Funktionen returnerar motsvarande resultatuttryck för det första uppfyllda predikatet, eller det sista uttrycket annars om inget av predikaten är uppfyllt.

Det här exemplet grupperar tillstånd baserat på antalet stormrelaterade skador som deras medborgare lidit.

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

Resultat

Skapa ett cirkeldiagram för att visualisera andelen tillstånd som drabbats av stormar som resulterar i ett stort, medelstort eller litet antal skador.

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 

Utför aggregeringar över ett glidande fönster

I följande exempel visas hur du sammanfattar kolumner med hjälp av ett skjutfönster.

Frågan beräknar den lägsta, högsta och genomsnittliga egendomsskadan för tornados, översvämningar och skogsbränder genom att använda ett rullande tidsfönster på sju dagar. Varje post i resultatuppsättningen aggregerar de föregående sju dagarna och resultaten innehåller en post per dag under analysperioden.

Här är en stegvis förklaring av frågan:

1. Gruppera varje post till en enda dag i förhållande till windowStart.
2. Lägg till sju dagar i bin-värdet för att ange slutet av intervallet för varje post. Om värdet ligger utom intervallet windowStart för och windowEndjusterar du värdet därefter.
3. Skapa en array med sju dagar för varje postering, med början från den nuvarande dagen för posteringen.
4. Expandera matrisen från steg 3 med mv-expand för att duplicera varje post till sju poster med endagsintervall mellan dem.
5. Utför aggregeringarna för varje dag. På grund av steg 4 sammanfattar det här steget faktiskt de föregående sju dagarna.
6. Exkludera de första sju dagarna från slutresultatet eftersom det inte finns någon sjudagars lookback-period för dem.

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

Resultat

Den följande resultattabellen är förkortad. Kör frågan för att se hela resultaten.

Nästa steg

Nu när du är bekant med vanliga frågeoperatorer och aggregeringsfunktioner går du vidare till nästa handledning för att lära dig hur du kombinerar data från flera tabeller.