shuffle query

Applies to: ✅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.

Note

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)

With `hint.shufflekey` = key

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

T|summarizehint.shufflekey = keyDataExpression

T|make-serieshint.shufflekey = keyDataExpression

T|Query| partition hint.shufflekey = key(SubQuery)

Learn more about syntax conventions.

Parameters

Name	Type	Required	Description
T	`string`	✔️	Den tabellkälla vars data ska bearbetas av operatorn.
DataExpression	`string`		Ett implicit eller explicit tabelltransformeringsuttryck.
Query	`string`		A transformation expression run on the records of T.
key	`string`		Använd en `join` nyckel, `summarize` nyckel, `make-series` nyckel eller `partition` nyckel.
SubQuery	`string`		Ett transformeringsuttryck.

Note

Either DataExpression or Query must be specified depending on the chosen syntax.

Examples

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

The examples in this article use publicly available tables in the help cluster, such as the StormEvents table in the Samples database.

The examples in this article use publicly available tables, such as the Weather table in the Weather analytics sample gallery. Du kan behöva ändra tabellnamnet i exempelfrågan för att matcha tabellen på din arbetsyta.

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.

Kör frågan

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

Output

Count
67

Använd koppling med shuffle

Kör frågan

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

Output

Count
103

Använda make-series med shuffle

Kör frågan

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

Output

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

Använda partition med shuffle

Kör frågan

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

Output

Count
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:

Kör frågan

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

Output

Count
14

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

Kö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

Output

Count
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:

Kör 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

Output

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:

Kör frågan

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

Output

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

Output

Count
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

Output

Count
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

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-07-20

Dela via

shuffle query

Syntax

Med hint.strategy = shuffle

With hint.shufflekey = key

Parameters

Examples

Använda summarize med shuffle

Använd koppling med shuffle

Använda make-series med shuffle

Använda partition med shuffle

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

Blanda data med flera nycklar

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

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

Feedback

Ytterligare resurser

Med `hint.strategy` = `shuffle`

With `hint.shufflekey` = key