shuffle query

Applies to: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Kueri shuffle adalah transformasi pelestarian semantik yang digunakan dengan seperangkat operator yang mendukung strategi shuffle. Bergantung pada data yang terlibat, kueri dengan strategi shuffle dapat menghasilkan performa yang lebih baik. Lebih baik menggunakan strategi kueri acak ketika shuffle kunci ( join kunci, kunci, summarize kunci, make-series atau partition kunci) memiliki kardinalitas tinggi dan kueri operator reguler mencapai batas kueri.

Anda dapat menggunakan operator berikut dengan perintah acak:

• join
• summarize
• make-series
• partition

Untuk menggunakan strategi kueri shuffle tambahkan ekspresi hint.strategy = shuffle atau hint.shufflekey = <key>. Saat Anda menggunakan hint.strategy=shuffle, data operator akan diacak oleh semua kunci. Gunakan ekspresi ini saat kunci gabungan unik tetapi setiap kunci tidak cukup unik, jadi Anda akan mengacak data menggunakan semua kunci operator yang diacak.

Saat mempartisi data dengan strategi acak, beban data dibagikan di semua node kluster. Setiap simpul memproses satu partisi data. Jumlah default partisi sama dengan jumlah node kluster.

Nomor partisi dapat diganti dengan menggunakan sintaks hint.num_partitions = total_partitions, yang akan mengontrol jumlah partisi. Ini berguna ketika kluster memiliki sejumlah kecil node kluster dan nomor partisi default akan kecil, dan kueri gagal atau membutuhkan waktu eksekusi yang lama.

Note

Menggunakan banyak partisi dapat mengkonsumsi lebih banyak sumber daya kluster dan menurunkan performa. Pilih nomor partisi dengan hati-hati dengan memulai dengan hint.strategy = shuffle dan mulai meningkatkan partisi secara bertahap.

Dalam beberapa kasus, hint.strategy = shuffle diabaikan, dan kueri tidak akan berjalan dalam shuffle strategi. Hal ini dapat terjadi jika:

• Operator join memiliki operator shuffle- lain yang kompatibel (join, summarize, make-series atau partition) di sisi kiri atau sisi kanan.
• Operator summarize muncul setelah operator lain shuffleyang kompatibel (join, summarize, make-series atau partition) dalam kueri.

Syntax

Dengan 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	✔️	Sumber tabular yang datanya akan diproses oleh operator.
DataExpression	string		Ekspresi transformasi tabular implisit atau eksplisit.
Query	string		A transformation expression run on the records of T.
key	string		join Gunakan kunci, summarize kunci, kunci, make-series atau partition kunci.
SubQuery	string		Ekspresi transformasi.

Note

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

Examples

Contoh di bagian ini memperlihatkan cara menggunakan sintaks untuk membantu Anda memulai.

The examples in this article use publicly available tables, such as the Weather table in the Weather analytics sample gallery. Anda mungkin perlu mengubah nama tabel dalam contoh kueri agar sesuai dengan tabel di ruang kerja Anda.

Gunakan ringkasan dengan acak

Kueri shuffle strategi dengan summarize operator berbagi beban pada semua node kluster, di mana setiap node memproses satu partisi data.

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

Output

Count
67

Gunakan bergabung dengan acak

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

Gunakan make-series dengan acak

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"]

Gunakan partisi dengan acak

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

Output

Count
22345

Bandingkan hint.strategy=shuffle dan hint.shufflekey=key

Saat Anda menggunakan hint.strategy=shuffle, operator yang diacak akan diacak oleh semua kunci. Dalam contoh berikut, kueri mengacak data menggunakan kedua EpisodeId dan EventId sebagai kunci:

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

Kueri berikut menggunakan hint.shufflekey = key. Kueri di atas setara dengan kueri ini.

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

Mengocok data dengan beberapa kunci

Dalam beberapa kasus, hint.strategy=shuffle kueri akan diabaikan, dan kueri tidak akan berjalan dalam strategi acak. Misalnya, dalam contoh berikut, gabungan telah meringkas di sisi kirinya, jadi menggunakan hint.strategy=shuffle tidak akan menerapkan strategi acak ke kueri:

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	...
...	...	...	...	...	...

Untuk mengatasi masalah ini dan menjalankan strategi acak, pilih kunci yang umum untuk summarize operasi dan join . Dalam hal ini, kunci ini adalah EpisodeId. Gunakan petunjuk hint.shufflekey untuk menentukan kunci acak pada join ke 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

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	...
...	...	...	...	...	...

Gunakan ringkasan dengan acak untuk meningkatkan performa

Dalam contoh ini, menggunakan operator summarize dengan strategi shuffle meningkatkan performa. Tabel sumber memiliki baris 150M dan kardinalitas grup berdasarkan kunci adalah 10M, yang tersebar di 10 node kluster.

Menggunakan operator summarize tanpa strategi shuffle, kueri berakhir setelah 1:08 dan puncak penggunaan memori adalah ~ 3 GB:

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

Output

Count
1086

Saat menggunakan strategi shuffle dengan summarize, kueri berakhir setelah ~ 7 detik dan puncak penggunaan memori adalah 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

Contoh berikut menunjukkan performa pada kluster yang memiliki dua node kluster, dengan tabel yang memiliki baris 60M, di mana kardinalitas grup dengan kunci adalah 2M.

Menjalankan kueri tanpa hint.num_partitions akan menggunakan hanya dua partisi (sebagai nomor node kluster) dan kueri berikut akan memakan waktu ~ 1:10 menit:

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

Jika mengatur nomor partisi menjadi 10, kueri akan berakhir setelah 23 detik:

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

Gunakan bergabung dengan acak untuk meningkatkan performa

Contoh berikut menunjukkan bagaimana menggunakan strategi shuffle dengan operator join meningkatkan performa.

Contoh-contoh diambil sampelnya pada kluster dengan 10 simpul tempat data tersebar di semua simpul ini.

Tabel sumber sisi kiri kueri memiliki baris 15M di mana kardinalitas kunci join adalah ~14M. Sumber sisi kanan kueri memiliki baris 150M dan kardinalitas kuncinya join adalah 10M. Kueri berakhir setelah ~28 detik dan puncak penggunaan memori adalah 1,43 GB:

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

Saat menggunakan strategi shuffle dengan operator join, kueri berakhir setelah ~4 detik dan puncak penggunaan memori adalah 0,3 GB:

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

Dalam contoh lain, kami mencoba kueri yang sama pada himpunan data yang lebih besar dengan kondisi berikut:

• Sumber sisi kiri join adalah 150M dan kardinalitas kuncinya adalah 148M.
• Sumber sisi kanan join adalah 1.5B, dan kardinalitas kuncinya adalah ~ 100M.

Kueri hanya join dengan operator mencapai batas dan waktu habis setelah 4 menit. Namun, saat menggunakan strategi shuffle dengan operator join, kueri berakhir setelah ~ 34 detik dan puncak penggunaan memori adalah 1,23 GB.

Contoh berikut menunjukkan peningkatan pada kluster yang memiliki dua node kluster, dengan tabel baris 60M, di mana kardinalitas kunci join adalah 2M. Menjalankan kueri tanpa hint.num_partitions akan menggunakan hanya dua partisi (sebagai nomor node kluster) dan kueri berikut akan memakan waktu ~ 1:10 menit:

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

Saat mengatur nomor partisi menjadi 10, kueri akan berakhir setelah 23 detik:

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