Kueri acak

Artikel
01/10/2024

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

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.

Catatan

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.

Sintaks

Dengan `hint.strategy` = `shuffle`

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

T|summarizehint.strategy = shuffleDataExpression

T|Kueri| partisi hint.strategy = shuffle(SubQuery)

Dengan `hint.shufflekey` = kunci

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

T|summarizehint.shufflekey = kunciDataExpression

T|make-serieshint.shufflekey = kunciDataExpression

T|Kueri| partisi hint.shufflekey = kunci(SubQuery)

Pelajari selengkapnya tentang konvensi sintaksis.

Parameter

Nama	Jenis	Diperlukan	Deskripsi
T	`string`	✔️	Sumber tabular yang datanya akan diproses oleh operator.
DataExpression	`string`		Ekspresi transformasi tabular implisit atau eksplisit.
Kueri	`string`		Ekspresi transformasi berjalan pada rekaman T.
kunci	`string`		`join` Gunakan kunci, `summarize` kunci, kunci, `make-series` atau `partition` kunci.
SubKueri	`string`		Ekspresi transformasi.

Catatan

DataExpression atau Query harus ditentukan tergantung pada sintaks yang dipilih.

Contoh

Gunakan ringkasan dengan acak

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

Menjalankan kueri

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

Output

Menghitung
67

Gunakan bergabung dengan acak

Menjalankan kueri

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

Menghitung
103

Gunakan make-series dengan acak

Menjalankan kueri

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

Provinsi	sum_DamageProperty	StartTime
DAKOTA UTARA	[60000,0,0]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:00:00.0000000Z","2007-01-30T00:00:00.0000000Z"]
CAROLINA UTARA	[20000,0,1000]	["2006-12-31T00:00:00.0000000Z","2007-01-15T00:00:00.0000000Z","2007-01-30T00:00:00.0000000Z"]
ATLANTIK UTARA	[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

Menjalankan kueri

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:

Menjalankan kueri

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

Hitungan
14

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

Menjalankan kueri

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

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

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

Menjalankan kueri

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

Kueri acak

Sintaks

Dengan `hint.strategy` = `shuffle`

Dengan `hint.shufflekey` = kunci

Parameter

Contoh

Gunakan ringkasan dengan acak

Gunakan bergabung dengan acak

Gunakan make-series dengan acak

Gunakan partisi dengan acak

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

Mengocok data dengan beberapa kunci

Gunakan ringkasan dengan acak untuk meningkatkan performa

Gunakan bergabung dengan acak untuk meningkatkan performa

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

Kueri acak

Sintaks

Dengan hint.strategy = shuffle

Dengan hint.shufflekey = kunci

Parameter

Contoh

Gunakan ringkasan dengan acak

Gunakan bergabung dengan acak

Gunakan make-series dengan acak

Gunakan partisi dengan acak

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

Mengocok data dengan beberapa kunci

Gunakan ringkasan dengan acak untuk meningkatkan performa

Gunakan bergabung dengan acak untuk meningkatkan performa

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

Dengan `hint.strategy` = `shuffle`

Dengan `hint.shufflekey` = kunci