elosztási lekérdezés

Cikk
01/18/2024

A shuffle lekérdezés egy szemantikai-megőrző átalakítás, amelyet a stratégiát támogató shuffle operátorok készletével használnak. Az érintett adatoktól függően a shuffle stratégiával végzett lekérdezés jobb teljesítményt eredményezhet. Érdemesebb az elosztási lekérdezési stratégiát használni, ha a shuffle kulcs (joinkulcs, kulcs, summarize kulcs vagy partition kulcs) nagy számossággal rendelkezik, make-series és a reguláris operátori lekérdezés eléri a lekérdezési korlátokat.

A shuffle paranccsal a következő operátorokat használhatja:

A lekérdezési shuffle stratégia használatához adja hozzá a kifejezést vagy hint.shufflekey = <key>a kifejezésthint.strategy = shuffle. A használatakor hint.strategy=shuffleaz operátor adatait az összes kulcs elkeveri. Ezt a kifejezést akkor használja, ha az összetett kulcs egyedi, de az egyes kulcsok nem elég egyediek, ezért az elosztási operátor összes kulcsával el kell keverni az adatokat.

Ha az adatokat az elosztási stratégiával particionálja, az adatbetöltés az összes fürtcsomóponton meg lesz osztva. Minden csomópont feldolgozza az adatok egy partícióját. A partíciók alapértelmezett száma megegyezik a fürtcsomópontok számával.

A partíciószám felülbírálásához használja a szintaxist hint.num_partitions = total_partitions, amely a partíciók számát szabályozza. Ez akkor hasznos, ha a fürt kevés fürtcsomóponttal rendelkezik, és az alapértelmezett partíciószám kicsi lesz, és a lekérdezés meghiúsul vagy hosszú végrehajtási időt vesz igénybe.

Megjegyzés

Sok partíció használata több fürterőforrást használhat, és csökkentheti a teljesítményt. Gondosan válassza ki a partíciószámot a kezdetével hint.strategy = shuffle , és kezdje el fokozatosan növelni a partíciókat.

Bizonyos esetekben a függvény figyelmen kívül hagyja a hint.strategy = shuffle függvényt, és a lekérdezés nem fut a stratégiában shuffle . Ez akkor fordulhat elő, ha:

Az join operátornak van egy másik shuffle-kompatibilis operátora (join, summarizevagy make-seriespartition) a bal oldalon vagy a jobb oldalon.
Az summarize operátor egy másik shuffle-kompatibilis operátor (join, summarizevagy make-seriespartition) után jelenik meg a lekérdezésben.

Syntax

A `hint.strategy` = `shuffle`

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

T|summarizehint.strategy = shuffleDataExpression

T|Lekérdezés| partition hint.strategy( = shuffleSubQuery)

Kulccsal`hint.shufflekey` =

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

T|summarizehint.shufflekey = keyDataExpression

T|make-serieshint.shufflekey = keyDataExpression

T|Lekérdezés|partíciókulcs(hint.shufflekey = – SubQuery)

További információ a szintaxis konvenciókról.

Paraméterek

Név	Típus	Kötelező	Leírás
T	`string`	✔️	Az a táblázatos forrás, amelynek adatait az operátornak kell feldolgoznia.
DataExpression	`string`		Implicit vagy explicit táblázatos átalakítási kifejezés.
Lekérdezés	`string`		A T rekordjain egy átalakítási kifejezés fut.
Kulcs	`string`		`join` Használjon kulcsot, `summarize` kulcsot, `make-series` kulcsot vagy `partition` kulcsot.
Allekérdezés	`string`		Egy átalakítási kifejezés.

Megjegyzés

A DataExpression vagy a Query paramétert a választott szintaxistól függően kell megadni.

Példák

Összegzés használata az elosztással

Az shuffle operátorral végzett summarize stratégiai lekérdezés az összes fürtcsomópont terhelését osztja meg, ahol minden csomópont feldolgozza az adatok egy partícióját.

A lekérdezés futtatása

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

Kimenet

Darabszám
67

Illesztés használata elosztással

A lekérdezés futtatása

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

Kimenet

Darabszám
103

Make-series használata elosztással

A lekérdezés futtatása

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

Kimenet

Állapot	sum_DamageProperty	StartTime
ÉSZAK-DAKOTA	[60000,0,0]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]
ÉSZAK-KAROLINA	[20000,0,1000]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]
ATLANTI-ÓCEÁN ÉSZAKI RÉGIÓJA	[0,0,0]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:100:00.0000000Z","2007-01-30T00:00:00.00000000Z"]

Partíció használata elosztással

A lekérdezés futtatása

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

Kimenet

Darabszám
22345

Compare hint.strategy=shuffle and hint.shufflekey=key

A használatakor hint.strategy=shuffleaz összes billentyű elkeveri az elosztási operátort. A következő példában a lekérdezés a és EventId a kulcs használatával elosztást alkalmaz EpisodeId az adatokra:

A lekérdezés futtatása

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

Kimenet

Darabszám
14

A következő lekérdezés a következőt használja hint.shufflekey = key: . A fenti lekérdezés egyenértékű ezzel a lekérdezésrel.

A lekérdezés futtatása

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

Kimenet

Darabszám
14

Az adatok elosztása több billentyűvel

Bizonyos esetekben a rendszer figyelmen kívül hagyja a hint.strategy=shuffle lekérdezést, és a lekérdezés nem fut a elosztási stratégiában. Az alábbi példában például az illesztés a bal oldalán található összegzéssel rendelkezik, így a használatával hint.strategy=shuffle nem alkalmazható az elosztási stratégia a lekérdezésre:

A lekérdezés futtatása

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

Kimenet

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

A probléma megoldásához és az elosztási stratégiában való futtatáshoz válassza ki a és join a műveletek közös kulcsátsummarize. Ebben az esetben ez a kulcs.EpisodeId A tipp hint.shufflekey használatával adja meg az elosztási kulcsot a join következőhöz hint.shufflekey = EpisodeId:

A lekérdezés futtatása

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

Kimenet

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

Az összegzés és a shuffle használata a teljesítmény javításához

Ebben a példában az summarize operátor stratégiával való shuffle használata javítja a teljesítményt. A forrástábla 150 M rekordot tartalmaz, a csoport kulcsonkénti számossága pedig 10 M, amely 10 fürtcsomóponton oszlik el.

A stratégia nélküli shuffle operátor használatával summarize a lekérdezés 1:08 után ér véget, és a memóriahasználati csúcs ~3 GB:

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

Kimenet

Darabszám
1086

A stratégia summarizehasználata shuffle esetén a lekérdezés ~7 másodperc után befejeződik, a memóriahasználati csúcs pedig 0,43 GB:

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

Kimenet

Darabszám
1086

Az alábbi példa egy két fürtcsomóponttal rendelkező fürt teljesítményét mutatja be egy 60 M rekordot tartalmazó táblával, ahol a csoport kulcsonkénti számossága 2 M.

A lekérdezés hint.num_partitions anélkül történő futtatása csak két partíciót használ (fürtcsomópontok számaként), és a következő lekérdezés körülbelül 1:10 percet vesz igénybe:

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

Ha a partíciók számát 10-esre állítja, a lekérdezés 23 másodperc után befejeződik:

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

Az illesztés és az elosztás használata a teljesítmény javításához

Az alábbi példa bemutatja, hogyan javítja a teljesítményt a join stratégia operátorral való használatashuffle.

A példákat egy 10 csomóponttal rendelkező fürtön vettük mintául, ahol az adatok az összes csomóponton el vannak osztva.

A lekérdezés bal oldali forrástáblája 15 M rekordokat tartalmaz, ahol a join kulcs számossága ~14 M. A lekérdezés jobb oldali forrása 150 M rekordokkal rendelkezik, a join kulcs számossága pedig 10 M. A lekérdezés körülbelül 28 másodperc után befejeződik, a memóriahasználati csúcs pedig 1,43 GB:

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

Ha operátorral join használ shuffle stratégiát, a lekérdezés ~4 másodperc után befejeződik, a memóriahasználati csúcs pedig 0,3 GB:

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

Egy másik példában ugyanazokat a lekérdezéseket kíséreljük meg egy nagyobb adathalmazon a következő feltételekkel:

A bal oldali forrása join 150 M, a kulcs számossága pedig 148 M.
A jobb oldali forrása join 1,5B, a kulcs számossága pedig ~100M.

A csak operátorral rendelkező lekérdezés 4 perc után eléri a join korlátokat és időtúllépést. Ha azonban stratégiát használ shuffle az join operátorral, a lekérdezés ~34 másodperc után befejeződik, a memóriahasználati csúcs pedig 1,23 GB.

Az alábbi példa egy olyan fürt fejlesztését mutatja be, amely két fürtcsomóponttal rendelkezik, egy 60 M rekordból álló táblával, ahol a join kulcs számossága 2M. A lekérdezés hint.num_partitions anélkül történő futtatása csak két partíciót használ (fürtcsomópontok számaként), és a következő lekérdezés körülbelül 1:10 percet vesz igénybe:

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

Amikor a partíciók számát 10-esre állítja, a lekérdezés 23 másodperc után befejeződik:

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

elosztási lekérdezés

Syntax

A `hint.strategy` = `shuffle`

Kulccsal`hint.shufflekey` =

Paraméterek

Példák

Összegzés használata az elosztással

Illesztés használata elosztással

Make-series használata elosztással

Partíció használata elosztással

Compare hint.strategy=shuffle and hint.shufflekey=key

Az adatok elosztása több billentyűvel

Az összegzés és a shuffle használata a teljesítmény javításához

Az illesztés és az elosztás használata a teljesítmény javításához

Visszajelzés

Visszajelzés

További források

elosztási lekérdezés

Syntax

A hint.strategy = shuffle

Kulccsalhint.shufflekey =

Paraméterek

Példák

Összegzés használata az elosztással

Illesztés használata elosztással

Make-series használata elosztással

Partíció használata elosztással

Compare hint.strategy=shuffle and hint.shufflekey=key

Az adatok elosztása több billentyűvel

Az összegzés és a shuffle használata a teljesítmény javításához

Az illesztés és az elosztás használata a teljesítmény javításához

Visszajelzés

Visszajelzés

További források

A `hint.strategy` = `shuffle`

Kulccsal`hint.shufflekey` =