shuffle-query

Van toepassing op: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel-

De shuffle-query is een semantische transformatie die wordt gebruikt met een set operators die ondersteuning bieden voor de shuffle strategie. Afhankelijk van de betrokken gegevens kan het uitvoeren van query's met de shuffle-strategie betere prestaties opleveren. Het is beter om de strategie voor willekeurige query's te gebruiken wanneer de shuffle sleutel (een join sleutel, summarize sleutel, make-series sleutel of partition sleutel) een hoge kardinaliteit heeft en de normale operatorquery querylimieten bereikt.

U kunt de volgende operators gebruiken met de opdracht shuffle:

• deelnemen aan
• samenvatten
• partitie

Als u de shuffle-querystrategie wilt gebruiken, voegt u de expressie hint.strategy = shuffle of hint.shufflekey = <key>toe. Wanneer u hint.strategy=shufflegebruikt, worden de operatorgegevens door alle sleutels in willekeurige volgorde gerangschikt. Gebruik deze expressie wanneer de samengestelde sleutel uniek is, maar elke sleutel niet uniek genoeg is, zodat u de gegevens in willekeurige volgorde kunt verplaatsen met behulp van alle sleutels van de operator in willekeurige volgorde.

Wanneer u gegevens partitioneert met de willekeurige strategie, wordt de gegevensbelasting gedeeld op alle clusterknooppunten. Elk knooppunt verwerkt één partitie van de gegevens. Het standaardaantal partities is gelijk aan het aantal clusterknooppunten.

Het partitienummer kan worden overschreven met behulp van de syntaxis hint.num_partitions = total_partitions, waarmee het aantal partities wordt bepaald. Dit is handig wanneer het cluster een klein aantal clusterknooppunten heeft en het standaardpartitienummer klein is en de query mislukt of een lange uitvoeringstijd duurt.

Notitie

Het gebruik van veel partities kan meer clusterresources verbruiken en de prestaties verminderen. Kies het partitienummer zorgvuldig door te beginnen met de hint.strategy = shuffle en de partities geleidelijk te verhogen.

In sommige gevallen wordt de hint.strategy = shuffle genegeerd en wordt de query niet uitgevoerd in shuffle strategie. Dit kan gebeuren wanneer:

• De operator join heeft een andere shuffle-compatibele operator (join, summarize, make-series of partition) aan de linkerkant of de rechterkant.
• De operator summarize wordt weergegeven na een andere operator die compatibel is met shuffle(join, summarize, make-series of partition) in de query.

Syntaxis

Met hint.strategy = shuffle

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

T|summarizehint.strategy = shuffleDataExpression-

T|Query| partitie hint.strategy = shuffle(SubQuery-)

Met hint.shufflekey = sleutel

T|DataExpression|joinhint.shufflekey = sleutel(DataExpression-)

T-|summarizehint.shufflekey = sleutelDataExpression-

T-|make-serieshint.shufflekey = sleutelDataExpression-

T|Query| partitie hint.shufflekey = sleutel(SubQuery-)

Meer informatie over syntaxisconventies.

Parameters

Naam	Type	Vereist	Beschrijving
T-	string	✔️	De tabellaire bron waarvan de gegevens door de operator moeten worden verwerkt.
DataExpression-	string		Een impliciete of expliciete expressie voor tabellaire transformatie.
Query-	string		Een transformatie-expressie wordt uitgevoerd op de records van T.
sleutel	string		Gebruik een join sleutel, summarize sleutel, make-series sleutel of partition sleutel.
SubQuery-	string		Een transformatie-expressie.

Notitie

DataExpression of Query moet worden opgegeven, afhankelijk van de gekozen syntaxis.

Voorbeelden

In het voorbeeld in deze sectie ziet u hoe u de syntaxis gebruikt om aan de slag te gaan.

In de voorbeelden in dit artikel worden openbaar beschikbare tabellen gebruikt, zoals de tabel StormEvents in de weather analytics voorbeeldgegevens.

Samenvatten gebruiken met willekeurige volgorde

De shuffle strategiequery met summarize operator deelt de belasting op alle clusterknooppunten, waarbij elk knooppunt één partitie van de gegevens verwerkt.

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

uitvoer

Tellen
67

Join gebruiken met 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

uitvoer

Tellen
103

Make-series gebruiken met willekeurige volgorde

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

uitvoer

Staat	sum_DamageProperty	StartTime
NORTH DAKOTA	[60000,0,0]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]
NORTH CAROLINA	[20000,0,1000]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]
ATLANTISCHE NOORD	[0,0,0]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]

Partitie gebruiken met willekeurige volgorde

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

uitvoer

Tellen
22345

Hint.strategy=shuffle en hint.shufflekey=key vergelijken

Wanneer u hint.strategy=shufflegebruikt, wordt de operator in willekeurige volgorde door alle sleutels geschoven. In het volgende voorbeeld worden de gegevens met behulp van zowel EpisodeId als EventId als sleutels in de query in willekeurige volgorde weergegeven:

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

uitvoer

Tellen
14

De volgende query maakt gebruik van hint.shufflekey = key. De bovenstaande query is gelijk aan deze query.

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

uitvoer

Tellen
14

De gegevens in willekeurige volgorde verplaatsen met meerdere sleutels

In sommige gevallen wordt de hint.strategy=shuffle genegeerd en wordt de query niet uitgevoerd in een willekeurige volgordestrategie. In het volgende voorbeeld heeft de join bijvoorbeeld een samenvatting aan de linkerkant, dus als u hint.strategy=shuffle gebruikt, past u de willekeurige strategie niet toe op de query:

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

uitvoer

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

Als u dit probleem wilt oplossen en in willekeurige volgorde wilt uitvoeren, kiest u de sleutel die gebruikelijk is voor de summarize- en join-bewerkingen. In dit geval is deze sleutel EpisodeId. Gebruik de hint hint.shufflekey om de willekeurige toets op de join op te geven om 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

uitvoer

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

Samenvatten met willekeurige volgorde gebruiken om de prestaties te verbeteren

In dit voorbeeld verbetert het gebruik van de operator summarize met shuffle strategie de prestaties. De brontabel heeft 150M-records en de kardinaliteit van de groep op sleutel is 10M, die is verdeeld over 10 clusterknooppunten.

Als u summarize operator zonder shuffle strategie gebruikt, eindigt de query na 1:08 en is de piek in het geheugengebruik ongeveer 3 GB:

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

uitvoer

Tellen
1086

Tijdens het gebruik van shuffle strategie met summarizeeindigt de query na ongeveer 7 seconden en is de piek in het geheugengebruik 0,43 GB:

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

uitvoer

Tellen
1086

In het volgende voorbeeld ziet u de prestaties van een cluster met twee clusterknooppunten, met een tabel met 60M-records, waarbij de kardinaliteit van de groep per sleutel 2M is.

Het uitvoeren van de query zonder hint.num_partitions gebruikt slechts twee partities (als clusterknooppuntnummer) en de volgende query duurt ongeveer 1:10 minuten:

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

Als u het partitienummer instelt op 10, eindigt de query na 23 seconden:

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

Join gebruiken met shuffle om de prestaties te verbeteren

In het volgende voorbeeld ziet u hoe het gebruik van shuffle strategie met de join-operator de prestaties verbetert.

De voorbeelden zijn gesampleerd op een cluster met 10 knooppunten waar de gegevens over al deze knooppunten worden verdeeld.

De brontabel aan de linkerkant van de query bevat 15 miljoen records waarbij de kardinaliteit van de join sleutel ongeveer 14 miljoen is. De rechterbron van de query heeft 150 miljoen records en de kardinaliteit van de join sleutel is 10 miljoen. De query eindigt na ongeveer 28 seconden en de piek in het geheugengebruik is 1,43 GB:

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

Wanneer u shuffle strategie gebruikt met een join-operator, eindigt de query na ongeveer 4 seconden en is de piek in het geheugengebruik 0,3 GB:

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

In een ander voorbeeld proberen we dezelfde query's uit te voeren op een grotere gegevensset met de volgende voorwaarden:

• De bron aan de linkerkant van de join is 150M en de kardinaliteit van de sleutel is 148M.
• De rechterkant van de join is 1,5B en de kardinaliteit van de sleutel is ~100M.

De query met alleen de operator join bereikt limieten en time-out na 4 minuten. Wanneer u echter shuffle strategie gebruikt met de operator join, eindigt de query na ongeveer 34 seconden en is de piek in het geheugengebruik 1,23 GB.

In het volgende voorbeeld ziet u de verbetering van een cluster met twee clusterknooppunten, met een tabel van 60M-records, waarbij de kardinaliteit van de join sleutel 2M is. Het uitvoeren van de query zonder hint.num_partitions gebruikt slechts twee partities (als clusterknooppuntnummer) en de volgende query duurt ongeveer 1:10 minuten:

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

Wanneer u het partitienummer instelt op 10, eindigt de query na 23 seconden:

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