Skriva frågor för Azure Data Explorer

I den här artikeln får du lära dig hur du använder frågespråket i Azure Data Explorer för att utföra grundläggande frågor med de vanligaste operatorerna. Du får också information om några av de mer avancerade funktionerna i språket.

Förutsättningar

• En Azure-prenumeration. Skapa ett kostnadsfritt Azure-konto.
• Skapa ett kluster och en databas.

Du kan köra frågorna i den här artikeln på något av två sätt:

• På Azure Data Explorer hjälpkluster som vi har ställt in för att underlätta inlärningen. Logga in på klustret med ett e-postkonto för organisationen som är medlem i Azure Active Directory.

• I ditt eget kluster som innehåller StormEvents-exempeldata. Mer information finns i Snabbstart: Skapa ett Azure Data Explorer kluster och en databas och mata in exempeldata i Azure Data Explorer.

  I exempeldatauppsättningen StormEvents finns väderrelaterade data från National Centers for Environmental Information.

Översikt över frågespråket

En fråga i Azure Data Explorer är en skrivskyddade begäran om att bearbeta data och returnera resultat. Begäran anges i klartext med hjälp av en dataflödesmodell som är utformad för att göra syntaxen lätt att läsa, skriva och automatisera. Frågan använder schemaentiteter som är ordnade i en hierarki som liknar SQL: databaser, tabeller och kolumner.

Frågan består av en sekvens med frågeuttryck avgränsade med semikolon ( ), där minst en instruktion är en tabelluttryckssats, vilket är en instruktion som skapar data ordnade i ett tabellliknande nät med kolumner och ; rader. Frågans tabellbaserade uttrycksinstruktioner producerar resultatet av frågan.

Syntaxen för tabelluttryckssatsen har ett tabelldataflöde från en tabellfrågeoperator till en annan, med början från datakällan (till exempel en tabell i en databas eller en operator som producerar data) och sedan flödar genom en uppsättning operatorer för datatransformering som binds samman med hjälp av avgränsaren pipe ( | ) .

Följande fråga har till exempel en enda -instruktion, som är en tabelluttryckssats. Instruktionen börjar med en referens till en tabell som heter StormEvents (den databas som är värd för den här tabellen är implicit här och ingår i anslutningsinformationen). Data (rader) för tabellen filtreras sedan efter värdet i kolumnen StartTime och filtreras därefter efter värdet i kolumnen State. Frågan returnerar sedan antalet ”kvarvarande” rader.

[ Klickaför att köra frågan]

StormEvents
| where StartTime >= datetime(2007-11-01) and StartTime < datetime(2007-12-01)
| where State == "FLORIDA"  
| count

I det här fallet är resultatet:

Mer information finns i frågespråksreferensen.

De vanligaste operatorerna

Operatorerna som tas upp i det här avsnittet är byggstenarna för att förstå frågor i Azure Data Explorer. De flesta frågor som du skriver innehåller flera av dessa operatorer.

Om du vill köra frågor i hjälpklustret: välj Klicka för att köra frågan ovanför varje fråga.

Så här kör du frågor i ditt eget kluster:

1. Kopiera varje fråga till det webbaserade frågeprogrammet och välj sedan frågan eller placera markören i frågan.

2. Längst upp i programmet väljer du Kör.

count

count: Returnerar antalet rader i tabellen.

Följande fråga returnerar antalet rader i tabellen StormEvents.

[ Klickaför att köra frågan]

StormEvents | count

take

take: returnerar upp till det angivna antalet rader med data.

Följande fråga returnerar fem rader från tabellen StormEvents. Nyckelordsgränsen är ett alias för take.

[ Klickaför att köra frågan]

StormEvents | take 5

projekt

project: Väljer en delmängd av kolumnerna.

Följande fråga returnerar en specifik uppsättning kolumner.

[ Klickaför att köra frågan]

StormEvents
| take 5
| project StartTime, EndTime, State, EventType, DamageProperty, EpisodeNarrative

var

where: Filtrerar en tabell till den delmängd av rader som uppfyller ett predikat.

Följande fråga filtrerar data efter EventType och State .

[ Klickaför att köra frågan]

StormEvents
| where EventType == 'Flood' and State == 'WASHINGTON'
| take 5
| project StartTime, EndTime, State, EventType, DamageProperty, EpisodeNarrative

sortera

sort: Sortera raderna i indatatabellen i ordning efter en eller flera kolumner.

Följande fråga sorterar data i fallande ordning efter DamageProperty .

[ Klickaför att köra frågan]

StormEvents
| where EventType == 'Flood' and State == 'WASHINGTON'
| sort by DamageProperty desc
| take 5
| project StartTime, EndTime, State, EventType, DamageProperty, EpisodeNarrative

top

top: returnerar de första N posterna sorterade efter de angivna kolumnerna.

Följande fråga returnerar samma resultat som ovan med en mindre operator.

[ Klickaför att köra frågan]

StormEvents
| where EventType == 'Flood' and State == 'WASHINGTON'
| top 5 by DamageProperty desc
| project StartTime, EndTime, State, EventType, DamageProperty, EpisodeNarrative

Utöka

extend: Beräknar härledda kolumner.

Följande fråga skapar en ny kolumn genom att beräkna ett värde på varje rad.

[ Klickaför att köra frågan]

StormEvents
| where EventType == 'Flood' and State == 'WASHINGTON'
| top 5 by DamageProperty desc
| extend Duration = EndTime - StartTime
| project StartTime, EndTime, Duration, State, EventType, DamageProperty, EpisodeNarrative

Uttryck kan innehålla alla vanliga operatorer (+, -, *, /, %) och det finns en mängd användbara funktioner som du kan anropa.

Sammanfatta

summarize: Aggregerar grupper med rader.

Följande fråga returnerar antalet händelser med State .

[ Klickaför att köra frågan]

StormEvents
| summarize event_count = count() by State

Operatorn summarize grupperar rader som har samma värden i by-satsen och använder sedan aggregeringsfunktionen (till exempel count) för att kombinera varje grupp till en enda rad. I det här fallet finns det alltså en rad för varje tillstånd och en kolumn för antalet rader i det tillståndet.

Det finns en mängd olika aggregeringsfunktioner, och du kan använda flera av dem i en sammanfattningsoperator för att skapa flera beräknade kolumner. Du kan till exempel hämta antalet stormar i varje tillstånd och det unika antalet stormar per tillstånd och sedan använda top för att få de mest storm-påverkade tillstånden.

[ Klickaför att köra frågan]

StormEvents
| summarize StormCount = count(), TypeOfStorms = dcount(EventType) by State
| top 5 by StormCount desc

Resultatet av en sammanfattningsåtgärd har:

• Varje kolumn med namnet i efter

• En kolumn för varje beräknat uttryck

• En rad för varje kombination av efter värden

Göra

render: Renderar resultat som grafiska utdata.

Följande fråga visar ett stapeldiagram.

[ Klickaför att köra frågan]

StormEvents
| summarize event_count=count(), mid = avg(BeginLat) by State
| sort by mid
| where event_count > 1800
| project State, event_count
| render columnchart

Följande fråga visar ett enkelt tidsdiagram.

[ Klickaför att köra frågan]

StormEvents
| summarize event_count=count() by bin(StartTime, 1d)
| render timechart

Följande fråga räknar händelser efter tidsmodulo en dag, indelt i timmar och visar ett tidsdiagram.

[ Klickaför att köra frågan]

StormEvents
| extend hour = floor(StartTime % 1d , 1h)
| summarize event_count=count() by hour
| sort by hour asc
| render timechart

Följande fråga jämför flera dagliga serier i ett tidsdiagram.

[ Klickaför att köra frågan]

StormEvents
| extend hour= floor( StartTime % 1d , 1h)
| where State in ("GULF OF MEXICO","MAINE","VIRGINIA","WISCONSIN","NORTH DAKOTA","NEW JERSEY","OREGON")
| summarize event_count=count() by hour, State
| render timechart

Skaläroperatorer

Det här avsnittet beskriver några av de viktigaste skalära operatorerna.

bin()

bin(): Avrundar värden nedåt till en heltals multipel av en viss lagerplatsstorlek.

Följande fråga beräknar antalet med en bucketstorlek på en dag.

[ Klickaför att köra frågan]

StormEvents
| where StartTime > datetime(2007-02-14) and StartTime < datetime(2007-02-21)
| summarize event_count = count() by bin(StartTime, 1d)

case()

case(): Utvärderar en lista med predikat och returnerar det första resultatuttrycket vars predikat är uppfyllt, eller det sista else-uttrycket. Du kan använda den här operatorn för att kategorisera eller gruppera data:

Följande fråga returnerar en ny kolumn deaths_bucket och grupperar dödsfallen efter tal.

[ Klickaför att köra frågan]

StormEvents
| summarize deaths = sum(DeathsDirect) by State
| extend deaths_bucket = case (
    deaths > 50, "large",
    deaths > 10, "medium",
    deaths > 0, "small",
    "N/A")
| sort by State asc

extract()

extract(): Hämtar en matchning för ett reguljärt uttryck från en textsträng.

Följande fråga extraherar specifika attributvärden från en spårning.

[ Klickaför att köra frågan]

let MyData = datatable (Trace: string) ["A=1, B=2, Duration=123.45,...", "A=1, B=5, Duration=55.256, ..."];
MyData
| extend Duration = extract("Duration=([0-9.]+)", 1, Trace, typeof(real)) * time(1s)

Den här frågan använder en let-instruktion som binder ett namn (i det här fallet ) till ett uttryck. För resten av omfånget, där let-instruktionen visas (globalt omfång eller i ett funktionstextomfång), kan namnet användas för att referera till dess bundna värde.

parse_json()

parse_json(): Tolkar en sträng som ett JSON-värde och returnerar värdet som dynamiskt. Det är överlägset att använda funktionen extractjson() när du behöver extrahera mer än ett element i ett sammansatt JSON-objekt.

Följande fråga extraherar JSON-elementen från en matris.

[ Klickaför att köra frågan]

let MyData = datatable (Trace: string)
['{"duration":[{"value":118.0,"valcount":5.0,"min":100.0,"max":150.0,"stdDev":0.0}]}'];
MyData
| extend NewCol = parse_json(Trace)
| project NewCol.duration[0].value, NewCol.duration[0].valcount, NewCol.duration[0].min, NewCol.duration[0].max, NewCol.duration[0].stdDev

Följande fråga extraherar JSON-elementen.

[ Klickaför att köra frågan]

let MyData = datatable (Trace: string) ['{"value":118.0,"valcount":5.0,"min":100.0,"max":150.0,"stdDev":0.0}'];
MyData
| extend NewCol = parse_json(Trace)
| project NewCol.value, NewCol.valcount, NewCol.min, NewCol.max, NewCol.stdDev

Följande fråga extraherar JSON-elementen med en dynamisk datatyp.

[ Klickaför att köra frågan]

let MyData = datatable (Trace: dynamic)
[dynamic({"value":118.0,"counter":5.0,"min":100.0,"max":150.0,"stdDev":0.0})];
MyData
| project Trace.value, Trace.counter, Trace.min, Trace.max, Trace.stdDev

ago()

ago(): Subtraherar det angivna tidsspann från den aktuella UTC-klocktiden.

Följande fråga returnerar data för de senaste 12 timmarna.

[ Klickaför att köra frågan]

//The first two lines generate sample data, and the last line uses
//the ago() operator to get records for last 12 hours.
print TimeStamp= range(now(-5d), now(), 1h), SomeCounter = range(1,121)
| mv-expand TimeStamp, SomeCounter
| where TimeStamp > ago(12h)

startofweek()

startofweek(): Returnerar början av veckan som innehåller datumet, skiftat med en förskjutning, om det anges

Följande fråga returnerar början av veckan med olika förskjutningar.

[ Klickaför att köra frågan]

range offset from -1 to 1 step 1
| project weekStart = startofweek(now(), offset),offset

Den här frågan använder intervalloperatorn, som genererar en tabell med en kolumn med värden. Se även: startofday(), startofweek(), startofyear()), startofmonth(), endofday(), endofweek(), endofmonth()och endofyear().

between()

between(): Matchar de indata som finns i det inkluderande intervallet.

Följande fråga filtrerar data efter ett visst datumintervall.

[ Klickaför att köra frågan]

StormEvents
| where StartTime between (datetime(2007-07-27) .. datetime(2007-07-30))
| count

Följande fråga filtrerar data efter ett visst datumintervall, med en liten variation på tre dagar ( 3d ) från startdatumet.

[ Klickaför att köra frågan]

StormEvents
| where StartTime between (datetime(2007-07-27) .. 3d)
| count

Tabelloperatorer

Kusto har många tabelloperatorer, varav vissa beskrivs i andra avsnitt i den här artikeln. Här fokuserar vi på att parsa.

parse

parsa:Utvärderar ett stränguttryck och parsar dess värde till en eller flera beräknade kolumner. Det finns tre sätt att parsa: enkelt (standard), regex och avslappnad.

Följande fråga parsar en spårning och extraherar relevanta värden med standardvärdet enkel parsning. Uttrycket (kallas StringConstant) är ett vanligt strängvärde och matchningen är strikt: utökade kolumner måste matcha de obligatoriska typerna.

[ Klickaför att köra frågan]

let MyTrace = datatable (EventTrace:string)
[
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=23, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=15, lockTime=02/17/2016 08:40:00Z, releaseTime=02/17/2016 08:40:00Z, previousLockTime=02/17/2016 08:39:00Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=20, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=22, lockTime=02/17/2016 08:41:01Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=16, lockTime=02/17/2016 08:41:00Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:00Z)'
];
MyTrace
| parse EventTrace with * "resourceName=" resourceName ", totalSlices=" totalSlices:long * "sliceNumber=" sliceNumber:long * "lockTime=" lockTime ", releaseTime=" releaseTime:date "," * "previousLockTime=" previouLockTime:date ")" *  
| project resourceName ,totalSlices , sliceNumber , lockTime , releaseTime , previouLockTime

Följande fråga parsar en spårning och extraherar relevanta värden med hjälp av kind = regex . StringConstant kan vara ett reguljärt uttryck.

[ Klickaför att köra frågan]

let MyTrace = datatable (EventTrace:string)
[
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=23, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=15, lockTime=02/17/2016 08:40:00Z, releaseTime=02/17/2016 08:40:00Z, previousLockTime=02/17/2016 08:39:00Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=20, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=22, lockTime=02/17/2016 08:41:01Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=16, lockTime=02/17/2016 08:41:00Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:00Z)'
];
MyTrace
| parse kind = regex EventTrace with "(.*?)[a-zA-Z]*=" resourceName @", totalSlices=\s*\d+\s*.*?sliceNumber=" sliceNumber:long  ".*?(previous)?lockTime=" lockTime ".*?releaseTime=" releaseTime ".*?previousLockTime=" previousLockTime:date "\\)"  
| project resourceName , sliceNumber , lockTime , releaseTime , previousLockTime

Följande fråga parsar en spårning och extraherar relevanta värden med hjälp av kind = relaxed . StringConstant är ett vanligt strängvärde och matchningen är avslappnad: utökade kolumner kan delvis matcha de obligatoriska typerna.

[ Klickaför att köra frågan]

let MyTrace = datatable (EventTrace:string)
[
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=23, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=15, lockTime=02/17/2016 08:40:00Z, releaseTime=02/17/2016 08:40:00Z, previousLockTime=02/17/2016 08:39:00Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=20, lockTime=02/17/2016 08:40:01Z, releaseTime=02/17/2016 08:40:01Z, previousLockTime=02/17/2016 08:39:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=22, lockTime=02/17/2016 08:41:01Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:01Z)',
'Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=27, sliceNumber=16, lockTime=02/17/2016 08:41:00Z, releaseTime=02/17/2016 08:41:00Z, previousLockTime=02/17/2016 08:40:00Z)'
];
MyTrace
| parse kind=relaxed "Event: NotifySliceRelease (resourceName=PipelineScheduler, totalSlices=NULL, sliceNumber=23, lockTime=02/17/2016 08:40:01, releaseTime=NULL, previousLockTime=02/17/2016 08:39:01)" with * "resourceName=" resourceName ", totalSlices=" totalSlices:long * "sliceNumber=" sliceNumber:long * "lockTime=" lockTime ", releaseTime=" releaseTime:date "," * "previousLockTime=" previousLockTime:date ")" *  
| project resourceName ,totalSlices , sliceNumber , lockTime , releaseTime , previousLockTime

Time Series-analys

make-series

make-series:aggregerar grupper av rader som summarize, men genererar en (tid) serievektor per varje kombination av av värden.

Följande fråga returnerar en uppsättning tidsserier för antalet stormhändelser per dag. Frågan omfattar en period på tre månader för varje tillstånd och fyller saknade lagerplatser med konstanten 0:

[ Klickaför att köra frågan]

StormEvents
| make-series n=count() default=0 on StartTime in range(datetime(2007-01-01), datetime(2007-03-31), 1d) by State

När du har skapat en uppsättning (tidsserier) kan du använda seriefunktioner för att identifiera avvikande former, säsongsmönster och mycket mer.

Följande fråga extraherar de tre främsta tillstånden som hade flest händelser under en viss dag:

[ Klickaför att köra frågan]

StormEvents
| make-series n=count() default=0 on StartTime in range(datetime(2007-01-01), datetime(2007-03-31), 1d) by State
| extend series_stats(n)
| top 3 by series_stats_n_max desc
| render timechart

Mer information finns i den fullständiga listan över seriefunktioner.

Avancerade aggregeringar

Vi har gåt in på grundläggande aggregeringar, som countoch summarize, tidigare i den här artikeln. I det här avsnittet beskrivs mer avancerade alternativ.

top-nested

top-nested: Ger hierarkiska toppresultat, där varje nivå är en detaljnivå som baseras på tidigare nivåvärden.

Den här operatorn är användbar för scenarier med visualisering av instrumentpaneler, eller när det är nödvändigt att besvara en fråga som följande: "Hitta de översta N-värdena för K1 (med viss aggregering); för var och en av dem hittar du de översta M-värdena för K2 (med en annan aggregering); ..."

Följande fråga returnerar en hierarkisk tabell med State på den översta nivån, följt av Sources .

[ Klickaför att köra frågan]

StormEvents
| top-nested 2 of State by sum(BeginLat),
top-nested 3 of Source by sum(BeginLat),
top-nested 1 of EndLocation by sum(BeginLat)

pivot() plugin-program

pivot() plugin-program:Roterar en tabell genom att omvandla de unika värdena från en kolumn i indatatabellen till flera kolumner i utdatatabellen. Operatorn utför sammansättningar där de krävs på eventuella återstående kolumnvärden i de slutliga utdata.

Följande fråga tillämpar ett filter och pivoter raderna i kolumner.

[ Klickaför att köra frågan]

StormEvents
| project State, EventType
| where State startswith "AL"
| where EventType has "Wind"
| evaluate pivot(State)

dcount()

dcount(): Returnerar en uppskattning av antalet distinkta värden för ett uttryck i gruppen. Använd count() för att räkna alla värden.

Följande fråga räknar Source distinkta med State .

[ Klickaför att köra frågan]

StormEvents
| summarize Sources = dcount(Source) by State

dcountif()

dcountif(): Returnerar en uppskattning av antalet distinkta värden i uttrycket för rader som predikatet utvärderas till sant.

Följande fråga räknar de distinkta värdena för Source där DamageProperty < 5000 .

[ Klickaför att köra frågan]

StormEvents 
| take 100
| summarize Sources = dcountif(Source, DamageProperty < 5000) by State

dcount_hll()

dcount_hll():Beräknar dcount från HyperLogLog-resultat (genereras av hll eller hll_merge.

Följande fråga använder HLL-algoritmen för att generera antalet.

[ Klickaför att köra frågan]

StormEvents
| summarize hllRes = hll(DamageProperty) by bin(StartTime,10m)
| summarize hllMerged = hll_merge(hllRes)
| project dcount_hll(hllMerged)

arg_max()

arg_max(): Söker efter en rad i gruppen som maximerar ett uttryck och returnerar värdet för ett annat uttryck (eller * för att returnera hela raden).

Följande fråga returnerar tiden för den senaste flood-rapporten i varje tillstånd.

[ Klickaför att köra frågan]

StormEvents
| where EventType == "Flood"
| summarize arg_max(StartTime, *) by State
| project State, StartTime, EndTime, EventType

makeset()

makeset(): Returnerar en dynamisk (JSON)-matris med uppsättningen distinkta värden som ett uttryck tar i gruppen.

Följande fråga returnerar alla gånger när en flood rapporterades av varje tillstånd och skapar en matris från uppsättningen distinkta värden.

[ Klickaför att köra frågan]

StormEvents
| where EventType == "Flood"
| summarize FloodReports = makeset(StartTime) by State
| project State, FloodReports

mv-expand

mv-expand:Expanderar samlingar med flera värden från en kolumn med dynamisk typ så att varje värde i samlingen får en separat rad. Alla andra kolumner i en expanderad rad dupliceras. Det är motsatsen till makelist.

Följande fråga genererar exempeldata genom att skapa en uppsättning och sedan använda den för att demonstrera mv-expand-funktionerna.

[ Klickaför att köra frågan]

let FloodDataSet = StormEvents
| where EventType == "Flood"
| summarize FloodReports = makeset(StartTime) by State
| project State, FloodReports;
FloodDataSet
| mv-expand FloodReports

percentiles()

percentiles(): Returnerar en uppskattning för den angivna percentilen närmaste rangordning för populationen som definieras av ett uttryck. Noggrannheten beror på densiteten för populationen i regionen för percentilen. Kan endast användas i kontexten för aggregering inuti summarize.

Följande fråga beräknar percentiler för stormvaraktighet.

[ Klickaför att köra frågan]

StormEvents
| extend duration = EndTime - StartTime
| where duration > 0s
| where duration < 3h
| summarize percentiles(duration, 5, 20, 50, 80, 95)

Följande fråga beräknar percentiler för stormvaraktighet efter tillstånd och normaliserar data med femminuters lagerplatser ( 5m ).

[ Klickaför att köra frågan]

StormEvents
| extend duration = EndTime - StartTime
| where duration > 0s
| where duration < 3h
| summarize event_count = count() by bin(duration, 5m), State
| summarize percentiles(duration, 5, 20, 50, 80, 95) by State

Korsdatauppsättning

Det här avsnittet beskriver element som gör att du kan skapa mer komplexa frågor, koppla data mellan tabeller och fråga mellan databaser och kluster.

Låt

let: Förbättrar modulariteten och återanvändningen. Med let-instruktionen kan du dela upp ett potentiellt komplext uttryck i flera delar, där var och en är bunden till ett namn och skapa dessa delar tillsammans. En let-instruktion kan också användas för att skapa användardefinierade funktioner och vyer (uttryck över tabeller vars resultat ser ut som en ny tabell). Uttryck som är bundna av en let-instruktion kan vara av skalärtyp, tabelltyp eller användardefinierad funktion (lambdas).

I följande exempel skapas en variabel av tabelltyp som används i ett efterföljande uttryck.

[ Klickaför att köra frågan]

let LightningStorms =
StormEvents
| where EventType == "Lightning";
let AvalancheStorms =
StormEvents
| where EventType == "Avalanche";
LightningStorms
| join (AvalancheStorms) on State
| distinct State

join

join: Sammanfoga raderna i två tabeller för att skapa en ny tabell genom att matcha värdena för de angivna kolumnerna från varje tabell. Kusto stöder en fullständig mängd kopplingstyper: fullouter, inner, innerunique, leftanti, leftantisemi, leftouter, leftsemi, rightanti, rightantisemi, rightouter, rightsemi.

I följande exempel sammanfogas två tabeller med en inre koppling.

[ Klickaför att köra frågan]

let X = datatable(Key:string, Value1:long)
[
    'a',1,
    'b',2,
    'b',3,
    'c',4
];
let Y = datatable(Key:string, Value2:long)
[
    'b',10,
    'c',20,
    'c',30,
    'd',40
];
X 
| join kind=inner Y on Key

Serialisera

serialiserar: Serialiserar raduppsättningen så att du kan använda funktioner som kräver serialiserade data, till exempel row_number().

Följande fråga lyckas eftersom data serialiseras.

[ Klickaför att köra frågan]

StormEvents
| summarize count() by State
| serialize
| extend row_number = row_number()

Raduppsättningen betraktas också som serialiserad om den är ett resultat av:sortera operatorerna ,översta eller intervall, eventuellt följt av projekt ,projekt-bort, utöka,där , parsa, mv-expanderaeller ta operatorer.

[ Klickaför att köra frågan]

StormEvents
| summarize count() by State
| sort by State asc
| extend row_number = row_number()

Frågor mellan databaser och mellan kluster

Frågor mellan databaser och mellan kluster:Du kan fråga en databas i samma kluster genom att referera till den som . Du kan fråga en databas i ett fjärrkluster genom att referera till den som cluster("MyCluster").database("MyDatabase").MyTable .

Följande fråga anropas från ett kluster och frågar efter data från MyCluster klustret. Om du vill köra den här frågan använder du ditt eget klusternamn och databasnamn.

cluster("MyCluster").database("Wiki").PageViews
| where Views < 2000
| take 1000;

Användaranalys

Det här avsnittet innehåller element och frågor som visar hur enkelt det är att utföra analyser av användarbeteenden i Kusto.

activity_counts_metrics-plugin-program

activity_counts_metricsplugin-program: Beräknar användbara aktivitetsmått (totalt antalsvärden, distinkta antalsvärden, distinkt antal nya värden och aggregerat distinkt antal). Mått beräknas för varje tidsfönster, sedan jämförs de och aggregeras till och med alla tidigare tidsfönster.

Följande fråga analyserar användaranpassning genom att beräkna antalet dagliga aktiviteter.

[ Klickaför att köra frågan]

let start=datetime(2017-08-01);
let end=datetime(2017-08-04);
let window=1d;
let T = datatable(UserId:string, Timestamp:datetime)
[
'A', datetime(2017-08-01),
'D', datetime(2017-08-01),
'J', datetime(2017-08-01),
'B', datetime(2017-08-01),
'C', datetime(2017-08-02),
'T', datetime(2017-08-02),
'J', datetime(2017-08-02),
'H', datetime(2017-08-03),
'T', datetime(2017-08-03),
'T', datetime(2017-08-03),
'J', datetime(2017-08-03),
'B', datetime(2017-08-03),
'S', datetime(2017-08-03),
'S', datetime(2017-08-04),
];
T
| evaluate activity_counts_metrics(UserId, Timestamp, start, end,
window)

activity_engagement-plugin-program

activity_engagement plugin-program:Beräknar förhållandet mellan aktivitetsinteragemang baserat på ID-kolumn över ett glidande tidslinjefönster. activity_engagement plugin-program kan användas för beräkning av DAU, WAU och MAU (aktiva användare varje dag, varje vecka och varje månad).

Följande fråga returnerar förhållandet mellan totalt antal distinkta användare som använder ett program varje dag jämfört med totalt antal distinkta användare som använder programmet varje vecka, i ett glidande sjudagarsfönster.

[ Klickaför att köra frågan]

// Generate random data of user activities
let _start = datetime(2017-01-01);
let _end = datetime(2017-01-31);
range _day from _start to _end step 1d
| extend d = tolong((_day - _start)/1d)
| extend r = rand()+1
| extend _users=range(tolong(d*50*r), tolong(d*50*r+100*r-1), 1)
| mv-expand id=_users to typeof(long) limit 1000000
// Calculate DAU/WAU ratio
| evaluate activity_engagement(['id'], _day, _start, _end, 1d, 7d)
| project _day, Dau_Wau=activity_ratio*100
| render timechart

activity_metrics-plugin-program

activity_metricsplugin-program: Beräknar användbara aktivitetsmått (distinkta antalsvärden, distinkt antal nya värden, kvarhållningsfrekvens och omsättningshastighet) baserat på det aktuella periodfönstret jämfört med föregående periodfönster.

Följande fråga beräknar omsättnings- och kvarhållningsfrekvensen för en viss datauppsättning.

[ Klickaför att köra frågan]

// Generate random data of user activities
let _start = datetime(2017-01-02);
let _end = datetime(2017-05-31);
range _day from _start to _end step 1d
| extend d = tolong((_day - _start)/1d)
| extend r = rand()+1
| extend _users=range(tolong(d*50*r), tolong(d*50*r+200*r-1), 1)
| mv-expand id=_users to typeof(long) limit 1000000
| where _day > datetime(2017-01-02)
| project _day, id
// Calculate weekly retention rate
| evaluate activity_metrics(['id'], _day, _start, _end, 7d)
| project _day, retention_rate*100, churn_rate*100
| render timechart

new_activity_metrics-plugin-program

new_activity_metricsplugin-program: Beräknar användbara aktivitetsmått (distinkta antalsvärden, distinkt antal nya värden, kvarhållningsfrekvens och omsättningshastighet) för de nya användarnas kohort. Konceptet med det här plugin-programmet liknar activity_metrics plugin-program,men fokuserar på nya användare.

Följande fråga beräknar kvarhållnings- och omsättningsfrekvensen med ett veckofönster för den nya användarnas kohort (användare som ankom den första veckan).

[ Klickaför att köra frågan]

// Generate random data of user activities
let _start = datetime(2017-05-01);
let _end = datetime(2017-05-31);
range Day from _start to _end step 1d
| extend d = tolong((Day - _start)/1d)
| extend r = rand()+1
| extend _users=range(tolong(d*50*r), tolong(d*50*r+200*r-1), 1)
| mv-expand id=_users to typeof(long) limit 1000000
// Take only the first week cohort (last parameter)
| evaluate new_activity_metrics(['id'], Day, _start, _end, 7d, _start)
| project from_Day, to_Day, retention_rate, churn_rate

session_count-plugin-program

session_count plugin-program:Beräknar antalet sessioner baserat på ID-kolumn över en tidslinje.

Följande fråga returnerar antalet sessioner. En session anses vara aktiv om ett användar-ID visas minst en gång vid en tidsram på 100 tider, medan sessionens look back-fönster är 41-tider.

[ Klickaför att köra frågan]

let _data = range Timeline from 1 to 9999 step 1
| extend __key = 1
| join kind=inner (range Id from 1 to 50 step 1 | extend __key=1) on __key
| where Timeline % Id == 0
| project Timeline, Id;
// End of data definition
_data
| evaluate session_count(Id, Timeline, 1, 10000, 100, 41)
| render linechart

funnel_sequence-plugin-program

funnel_sequenceplugin-program: Beräknar det distinkta antalet användare som har tagit en sekvens med tillstånd; visar fördelningen av föregående och nästa tillstånd som har lett till eller följts av sekvensen.

Följande fråga visar vilken händelse som inträffar före och efter alla Storm-händelser 2007.

[ Klickaför att köra frågan]

// Looking on StormEvents statistics:
// Q1: What happens before Tornado event?
// Q2: What happens after Tornado event?
StormEvents
| evaluate funnel_sequence(EpisodeId, StartTime, datetime(2007-01-01), datetime(2008-01-01), 1d,365d, EventType, dynamic(['Tornado']))

funnel_sequence_completion-plugin-program

funnel_sequence_completionplugin-program: Beräknar tratten för slutförda sekvenssteg inom olika tidsperioder.

Följande fråga kontrollerar slutförandetratten för sekvensen: Hail -> Tornado -> Thunderstorm -> Wind i "övergripande" tider på en timme, fyra timmar och en dag ( [1h, 4h, 1d] ).

[ Klickaför att köra frågan]

let _start = datetime(2007-01-01);
let _end = datetime(2008-01-01);
let _windowSize = 365d;
let _sequence = dynamic(['Hail', 'Tornado', 'Thunderstorm', 'Wind']);
let _periods = dynamic([1h, 4h, 1d]);
StormEvents
| evaluate funnel_sequence_completion(EpisodeId, StartTime, _start, _end, _windowSize, EventType, _sequence, _periods)

Functions

Det här avsnittet beskriverfunktioner: återanvändbara frågor som lagras på servern. Funktioner kan anropas av frågor och andra funktioner (rekursiva funktioner stöds inte).

I följande exempel skapas en funktion som tar ett tillståndsnamn ( MyState ) som argument.

.create function with (folder="Demo")
MyFunction (MyState: string)
{
StormEvents
| where State =~ MyState
}

I följande exempel anropas en funktion som hämtar data för delstaten Texas.

MyFunction ("Texas")
| summarize count()

I följande exempel tas funktionen som skapades i det första steget bort.

.drop function MyFunction

Nästa steg

Referens för Kusto Query Language