materialize()

Samlar in värdet för ett tabelluttryck under frågekörningens varaktighet så att det kan refereras flera gånger av frågan utan omberäkning.

Syntax

materialize(Uttryck)

Läs mer om syntaxkonventioner.

Parametrar

Namn	Typ	Obligatorisk	Beskrivning
expression	string	✔️	Det tabelluttryck som ska utvärderas och cachelagras under frågekörningen.

Kommentarer

Funktionen materialize() är användbar i följande scenarier:

• För att påskynda frågor som utför tunga beräkningar vars resultat används flera gånger i frågan.
• Om du bara vill utvärdera ett tabelluttryck en gång och använda det många gånger i en fråga. Detta krävs vanligtvis om tabelluttrycket är icke-deterministiskt. Om uttrycket till exempel använder rand() - eller dcount() -funktionerna.

Anteckning

Materialize har en storleksgräns för cacheminnet på 5 GB. Den här gränsen är per klusternod och är ömsesidig för alla frågor som körs samtidigt. Om en fråga använder materialize() och cacheminnet inte kan innehålla fler data avbryts frågan med ett fel.

Tips

Ett annat sätt att utföra materialisering av tabelluttryck är att använda hint.materialized flaggan för operatorn som operator och partitionsoperator. De delar alla en enda materialiseringscache.

Tips

• Push-överför alla möjliga operatorer som minskar den materialiserade datamängden och behåller frågans semantik. Använd till exempel vanliga filter ovanpå samma materialiserade uttryck.
• Använd materialisera med koppling eller union när deras operander har ömsesidiga underfrågor som kan köras en gång. Till exempel join/union fork legs. Se exempel på hur du använder kopplingsoperatorn.
• Materialize kan endast användas i let-instruktioner om du ger det cachelagrade resultatet ett namn. Se exempel på användning av let-instruktioner).

Exempel på förbättring av frågeprestanda

I följande exempel visas hur materialize() du kan använda för att förbättra frågans prestanda. Uttrycket _detailed_data definieras med hjälp av materialize() funktionen och beräknas därför bara en gång.

Köra frågan

let _detailed_data = materialize(StormEvents | summarize Events=count() by State, EventType);
_detailed_data
| summarize TotalStateEvents=sum(Events) by State
| join (_detailed_data) on State
| extend EventPercentage = Events*100.0 / TotalStateEvents
| project State, EventType, EventPercentage, Events
| top 10 by EventPercentage

Resultat

Tillstånd	Eventtype	EventPercentage	Händelser
HAWAII VATTEN	Vattenspout	100	2
LAKE ONTARIO	Havs åskväder	100	8
ALASKABUKTEN	Vattenspout	100	4
ATLANTIC NORTH	Havs åskväder	95.2127659574468	179
LAKE ERIE	Havs åskväder	92.5925925925926	25
E PACIFIC	Vattenspout	90	9
LAKE MICHIGAN	Havs åskväder	85.1648351648352	155
LAKE HURON	Havs åskväder	79.3650793650794	50
MEXIKANSKA GOLFEN	Havs åskväder	71.7504332755633	414
HAWAII	Hög surfning	70.0218818380744	320

I följande exempel genereras en uppsättning slumpmässiga tal och beräknas:

• Hur många distinkta värden i uppsättningen (Dcount)
• De tre översta värdena i uppsättningen
• Summan av alla dessa värden i uppsättningen

Den här åtgärden kan utföras med batchar och materialisera:

Köra frågan

let randomSet = 
    materialize(
        range x from 1 to 3000000 step 1
        | project value = rand(10000000));
randomSet | summarize Dcount=dcount(value);
randomSet | top 3 by value;
randomSet | summarize Sum=sum(value)

Resultatuppsättning 1:

Dantal
2578351

Resultatuppsättning 2:

värde
9999998
9999998
9999997

Resultatuppsättning 3:

Sum
15002960543563

Exempel på att använda materialize()

Tips

Materialisera kolumnen vid inmatningstillfället om de flesta av dina frågor extraherar fält från dynamiska objekt över flera miljoner rader.

Om du vill använda -instruktionen let med ett värde som du använder mer än en gång använder du funktionen materialize(). Försök att push-överföra alla möjliga operatorer som minskar den materialiserade datamängden och fortfarande behåller frågans semantik. Du kan till exempel använda filter eller projekt som endast krävs kolumner.

    let materializedData = materialize(Table
    | where Timestamp > ago(1d));
    union (materializedData
    | where Text !has "somestring"
    | summarize dcount(Resource1)), (materializedData
    | where Text !has "somestring"
    | summarize dcount(Resource2))

Filtret på Text är ömsesidigt och kan push-överföras till materialiseringsuttrycket. Frågan behöver bara kolumnerna Timestamp, Text, Resource1och Resource2. Projicera dessa kolumner inuti det materialiserade uttrycket.

    let materializedData = materialize(Table
    | where Timestamp > ago(1d)
    | where Text !has "somestring"
    | project Timestamp, Resource1, Resource2, Text);
    union (materializedData
    | summarize dcount(Resource1)), (materializedData
    | summarize dcount(Resource2))

Om filtren inte är identiska, som i följande fråga:

    let materializedData = materialize(Table
    | where Timestamp > ago(1d));
    union (materializedData
    | where Text has "String1"
    | summarize dcount(Resource1)), (materializedData
    | where Text has "String2"
    | summarize dcount(Resource2))

När det kombinerade filtret minskar det materialiserade resultatet drastiskt kombinerar du båda filtren på det materialiserade resultatet med ett logiskt or uttryck som i följande fråga. Behåll dock filtren i varje union för att bevara frågans semantik.

    let materializedData = materialize(Table
    | where Timestamp > ago(1d)
    | where Text has "String1" or Text has "String2"
    | project Timestamp, Resource1, Resource2, Text);
    union (materializedData
    | where Text has "String1"
    | summarize dcount(Resource1)), (materializedData
    | where Text has "String2"
    | summarize dcount(Resource2))