Dela via

shuffle-fråga

  • Artikel

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

Den shuffle frågan är en semantisk-bevarande transformering som används med en uppsättning operatorer som stöder shuffle strategi. Beroende på vilka data som ingår kan frågor med shuffle strategi ge bättre prestanda. Det är bättre att använda shuffle-frågestrategin när den shuffle nyckeln (en join nyckel, summarize nyckel, make-series nyckel eller partition nyckel) har hög kardinalitet och den vanliga operatorfrågan når frågegränser.

Du kan använda följande operatorer med kommandot shuffle:

Om du vill använda shuffle frågestrategi lägger du till uttrycket hint.strategy = shuffle eller hint.shufflekey = <key>. När du använder hint.strategy=shuffleblandas operatordata av alla nycklar. Använd det här uttrycket när den sammansatta nyckeln är unik men varje nyckel inte är tillräckligt unik, så du blandar data med alla nycklar i den blandade operatorn.

När du partitionerar data med shuffle-strategin delas databelastningen på alla klusternoder. Varje nod bearbetar en partition av data. Standardantalet partitioner är lika med antalet klusternoder.

Partitionsnumret kan åsidosättas med hjälp av syntaxen hint.num_partitions = total_partitions, som styr antalet partitioner. Detta är användbart när klustret har ett litet antal klusternoder och standardpartitionsnumret är litet, och frågan misslyckas eller tar lång körningstid.

Not

Användning av många partitioner kan förbruka fler klusterresurser och försämra prestanda. Välj partitionsnumret noggrant genom att börja med hint.strategy = shuffle och börja öka partitionerna gradvis.

I vissa fall ignoreras hint.strategy = shuffle och frågan körs inte i shuffle strategi. Detta kan inträffa när:

  • join-operatorn har en annan shuffle-kompatibel operator (join, summarize, make-series eller partition) till vänster eller höger sida.
  • Operatorn summarize visas efter en annan shuffle-kompatibel operator (join, summarize, make-series eller partition) i frågan.

Syntax

Med hint.strategy = shuffle

T|DataExpression|joinhint.strategy = shuffle(DataExpression)

T|summarizehint.strategy = shuffleDataExpression

T|Query| partition hint.strategy = shuffle(SubQuery)

Med hint.shufflekey = nyckel

T|DataExpression|joinhint.shufflekey = nyckel(DataExpression)

T|summarizehint.shufflekey = nyckelDataExpression

T|make-serieshint.shufflekey = nyckelDataExpression

T|Fråga| partition hint.shufflekey = nyckel(SubQuery)

Läs mer om syntaxkonventioner.

Parametrar

Namn Typ Krävs Beskrivning
T string ✔️ Den tabellkälla vars data ska bearbetas av operatorn.
DataExpression string Ett implicit eller explicit tabelltransformeringsuttryck.
Fråga string Ett transformeringsuttryck körs på posterna i T.
nyckel string Använd en join nyckel, summarize nyckel, make-series nyckel eller partition nyckel.
SubQuery string Ett transformeringsuttryck.

Not

Antingen DataExpression eller Query måste anges beroende på den valda syntaxen.

Exempel

Exemplet i det här avsnittet visar hur du använder syntaxen för att komma igång.

Exemplen i den här artikeln använder offentligt tillgängliga tabeller i hjälpkluster, till exempel tabellen StormEvents i databasen Samples.

Exemplen i den här artikeln använder offentligt tillgängliga tabeller, till exempel tabellen StormEvents i Väderanalys exempeldata.

Använda summarize med shuffle

Den shuffle strategifrågan med summarize-operatorn delar belastningen på alla klusternoder, där varje nod bearbetar en partition av data.

StormEvents
| summarize hint.strategy = shuffle count(), avg(InjuriesIndirect) by State
| count

utdata

Räkna
67

Använd koppling med shuffle

StormEvents
| where State has "West"
| where EventType has "Flood"
| join hint.strategy=shuffle 
    (
    StormEvents
    | where EventType has "Hail"
    | project EpisodeId, State, DamageProperty
    )
    on State
| count

utdata

Räkna
103

Använda make-series med shuffle

StormEvents
| where State has "North"
| make-series hint.shufflekey = State sum(DamageProperty) default = 0 on StartTime in range(datetime(2007-01-01 00:00:00.0000000), datetime(2007-01-31 23:59:00.0000000), 15d) by State

utdata

Stat sum_DamageProperty StartTime
NORTH DAKOTA [60000,0,0] ["2006-12-31T00:00:00.0000000Z","2007-01-15T00:000:00.0000000Z","2007-01-30T00:00:00.0000000Z"]
NORTH CAROLINA [20000,0,1000] ["2006-12-31T00:00:00.0000000Z","2007-01-15T00:000:00.0000000Z","2007-01-30T00:00:00.0000000Z"]
NORDATLANT [0,0,0] ["2006-12-31T00:00:00.0000000Z","2007-01-15T00:000:00.0000000Z","2007-01-30T00:00:00.0000000Z"]

Använda partition med shuffle

StormEvents
| partition hint.strategy=shuffle by EpisodeId
(
    top 3 by DamageProperty
    | project EpisodeId, State, DamageProperty
)
| count

utdata

Räkna
22345

Jämför hint.strategy=shuffle och hint.shufflekey=key

När du använder hint.strategy=shuffleblandas den blandade operatorn av alla nycklar. I följande exempel blandar frågan data med både EpisodeId och EventId som nycklar:

StormEvents
| where StartTime > datetime(2007-01-01 00:00:00.0000000)
| join kind = inner hint.strategy=shuffle (StormEvents | where DamageCrops > 62000000) on EpisodeId, EventId
| count

utdata

Räkna
14

Följande fråga använder hint.shufflekey = key. Frågan ovan motsvarar den här frågan.

StormEvents
| where StartTime > datetime(2007-01-01 00:00:00.0000000)
| join kind = inner hint.shufflekey = EpisodeId hint.shufflekey = EventId (StormEvents | where DamageCrops > 62000000) on EpisodeId, EventId

utdata

Räkna
14

Blanda data med flera nycklar

I vissa fall ignoreras hint.strategy=shuffle och frågan körs inte i shuffle-strategin. I följande exempel har kopplingen till exempel sammanfattats till vänster, så om du använder hint.strategy=shuffle tillämpas inte shuffle-strategin på frågan:

StormEvents
| where StartTime > datetime(2007-01-01 00:00:00.0000000)
| summarize count() by EpisodeId, EventId
| join kind = inner hint.strategy=shuffle (StormEvents | where DamageCrops > 62000000) on EpisodeId, EventId

utdata

EpisodeId EventId ... EpisodeId1 EventId1 ...
1030 4407 ... 1030 4407 ...
1030 13721 ... 1030 13721 ...
2477 12530 ... 2477 12530 ...
2103 10237 ... 2103 10237 ...
2103 10239 ... 2103 10239 ...
... ... ... ... ... ...

Om du vill lösa det här problemet och köra i shuffle-strategin väljer du den nyckel som är gemensam för summarize och join åtgärder. I det här fallet är den här nyckeln EpisodeId. Använd tipset hint.shufflekey för att ange shuffle-tangenten på join för att hint.shufflekey = EpisodeId:

StormEvents
| where StartTime > datetime(2007-01-01 00:00:00.0000000)
| summarize count() by EpisodeId, EventId
| join kind = inner hint.shufflekey=EpisodeId (StormEvents | where DamageCrops > 62000000) on EpisodeId, EventId

utdata

EpisodeId EventId ... EpisodeId1 EventId1 ...
1030 4407 ... 1030 4407 ...
1030 13721 ... 1030 13721 ...
2477 12530 ... 2477 12530 ...
2103 10237 ... 2103 10237 ...
2103 10239 ... 2103 10239 ...
... ... ... ... ... ...

Använd sammanfatta med shuffle för att förbättra prestanda

I det här exemplet förbättrar användningen av operatorn summarize med shuffle prestanda. Källtabellen har 150 M poster och kardinaliteten för gruppen efter nyckel är 10M, som är spridda över 10 klusternoder.

Med summarize operator utan shuffle strategi slutar frågan efter 1:08 och minnesanvändningens topp är ~3 GB:

orders
| summarize arg_max(o_orderdate, o_totalprice) by o_custkey 
| where o_totalprice < 1000
| count

utdata

Räkna
1086

När du använder shuffle strategi med summarizeslutar frågan efter ~7 sekunder och minnesanvändningens topp är 0,43 GB:

orders
| summarize hint.strategy = shuffle arg_max(o_orderdate, o_totalprice) by o_custkey 
| where o_totalprice < 1000
| count

utdata

Räkna
1086

I följande exempel visas prestanda för ett kluster som har två klusternoder, med en tabell som har 60 M poster, där kardinaliteten för gruppen efter nyckel är 2 M.

Om du kör frågan utan hint.num_partitions används endast två partitioner (som klusternodnummer) och följande fråga tar ~1:10 minuter:

lineitem 
| summarize hint.strategy = shuffle dcount(l_comment), dcount(l_shipdate) by l_partkey 
| consume

Om du anger partitionsnumret till 10 slutar frågan efter 23 sekunder:

lineitem 
| summarize hint.strategy = shuffle hint.num_partitions = 10 dcount(l_comment), dcount(l_shipdate) by l_partkey 
| consume

Använda koppling med shuffle för att förbättra prestanda

I följande exempel visas hur användningen av shuffle strategi med join-operatorn förbättrar prestandan.

Exemplen samplades i ett kluster med 10 noder där data sprids över alla dessa noder.

Frågans källtabell till vänster har 15 miljoner poster där kardinaliteten för den join nyckeln är ~14 M. Frågans högra källa har 150 M poster och kardinaliteten för den join nyckeln är 10 M. Frågan slutar efter ~28 sekunder och minnesanvändningen är högst 1,43 GB:

customer
| join
    orders
on $left.c_custkey == $right.o_custkey
| summarize sum(c_acctbal) by c_nationkey

När du använder shuffle strategi med en join-operator slutar frågan efter ~4 sekunder och minnesanvändningens topp är 0,3 GB:

customer
| join
    hint.strategy = shuffle orders
on $left.c_custkey == $right.o_custkey
| summarize sum(c_acctbal) by c_nationkey

I ett annat exempel provar vi samma frågor på en större datauppsättning med följande villkor:

  • Vänster källa för join är 150M och kardinaliteten för nyckeln är 148M.
  • Höger källa för join är 1,5B och nyckelns kardinalitet är ~100M.

Frågan med bara join-operatorn når gränser och tidsgränser efter 4 minuter. Men när du använder shuffle strategi med operatorn join slutar frågan efter ~34 sekunder och minnesanvändningens topp är 1,23 GB.

I följande exempel visas förbättringen av ett kluster som har två klusternoder, med en tabell med 60 M poster, där kardinaliteten för den join nyckeln är 2 M. Om du kör frågan utan hint.num_partitions används endast två partitioner (som klusternodnummer) och följande fråga tar ~1:10 minuter:

lineitem
| summarize dcount(l_comment), dcount(l_shipdate) by l_partkey
| join
    hint.shufflekey = l_partkey   part
on $left.l_partkey == $right.p_partkey
| consume

När partitionsnumret anges till 10 avslutas frågan efter 23 sekunder:

lineitem
| summarize dcount(l_comment), dcount(l_shipdate) by l_partkey
| join
    hint.shufflekey = l_partkey  hint.num_partitions = 10    part
on $left.l_partkey == $right.p_partkey
| consume