Kueri acak

Berlaku untuk: ✅Microsoft Fabric✅✅

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

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.

Sintaks

Dengan hint.strategy = shuffle

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

T|summarizehint.strategy = shuffle DataExpression

SubKueri partisi|hint.strategy = shuffle()

Dengan hint.shufflekey = kunci

Kunci DataExpression(DataExpression)

Kunci T|summarizehint.shufflekey = DataExpression

Kunci T|make-serieshint.shufflekey = DataExpression

= ( )

Pelajari selengkapnya tentang konvensi sintaksis.

Parameter

Contoh

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

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 

Hasil

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

Hasil

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

Hasil

Gunakan partisi dengan acak

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

Hasil

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

Hasil

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

Hasil

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

Hasil

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

Hasil

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

Hasil

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

Hasil

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