shuffle query

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

Zapytanie shuffle jest semantyczną transformacją używaną z zestawem operatorów obsługujących strategię shuffle . W zależności od zaangażowanych danych wykonywanie zapytań za shuffle pomocą strategii może zwiększyć wydajność. Lepiej użyć strategii zapytania mieszania, gdy shuffle klucz ( join klucz, summarize klucz, make-series klucz lub partition klucz) ma wysoką kardynalność, a zapytanie zwykłego operatora osiąga limity zapytań.

Za pomocą polecenia shuffle można użyć następujących operatorów:

• join
• summarize
• make-series
• partition

Aby użyć shuffle strategii zapytania, dodaj wyrażenie hint.strategy = shuffle lub hint.shufflekey = <key>. Gdy używasz hint.strategy=shufflemetody , dane operatora zostaną przetasowane przez wszystkie klucze. Użyj tego wyrażenia, gdy klucz złożony jest unikatowy, ale każdy klucz nie jest wystarczająco unikatowy, więc przetasujesz dane przy użyciu wszystkich kluczy operatora shuffled.

Podczas partycjonowania danych przy użyciu strategii mieszania obciążenie danych jest współużytkowane na wszystkich węzłach klastra. Każdy węzeł przetwarza jedną partycję danych. Domyślna liczba partycji jest równa liczbie węzłów klastra.

Numer partycji można zastąpić przy użyciu składni hint.num_partitions = total_partitions, która będzie kontrolować liczbę partycji. Jest to przydatne, gdy klaster ma niewielką liczbę węzłów klastra, a domyślna liczba partycji będzie mała, a zapytanie kończy się niepowodzeniem lub trwa długo.

Note

Użycie wielu partycji może zużywać więcej zasobów klastra i obniżyć wydajność. Starannie wybierz numer partycji, zaczynając od hint.strategy = shuffle i stopniowo zwiększając partycje.

W niektórych przypadkach element hint.strategy = shuffle jest ignorowany, a zapytanie nie zostanie uruchomione w shuffle strategii. Może się tak zdarzyć, jeśli:

• Operator join ma inny shuffleoperator zgodny (join, summarize, make-series lub partition) po lewej stronie lub po prawej stronie.
• Operator summarize pojawia się po innym shuffleoperatorie zgodnym (join, summarizelub make-seriespartition) w zapytaniu.

Syntax

Z 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	Typ	Required	Description
T	string	✔️	Tabelaryczne źródło, którego dane mają być przetwarzane przez operatora.
DataExpression	string		Niejawne lub jawne wyrażenie przekształcenia tabelarycznego.
Query	string		A transformation expression run on the records of T.
key	string		join Użyj klucza, summarize klucza, make-series klucza lub partition klucza.
SubQuery	string		Wyrażenie przekształcenia.

Note

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

Examples

W przykładzie w tej sekcji pokazano, jak używać składni, aby ułatwić rozpoczęcie pracy.

The examples in this article use publicly available tables, such as the Weather table in the Weather analytics sample gallery. Może być konieczne zmodyfikowanie nazwy tabeli w przykładowym zapytaniu, aby było zgodne z tabelą w obszarze roboczym.

Używanie funkcji summarize z mieszania

shuffle Zapytanie strategii z operatorem summarize współdzieli obciążenie na wszystkich węzłach klastra, gdzie każdy węzeł przetwarza jedną partycję danych.

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

Output

Count
67

Używanie sprzężenia z mieszania

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

Używanie serii make-series z mieszania

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

Używanie partycji z mieszania

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

Output

Count
22345

Porównaj hint.strategy=shuffle i hint.shufflekey=key

Gdy używasz hint.strategy=shufflemetody , operator tasowany zostanie przetasowany przez wszystkie klucze. W poniższym przykładzie zapytanie tasuje dane przy użyciu zarówno kluczy, EpisodeId jak i EventId jako kluczy:

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

Poniższe zapytanie używa metody hint.shufflekey = key. Powyższe zapytanie jest równoważne temu zapytaniu.

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

Przetasuj dane przy użyciu wielu kluczy

W niektórych przypadkach hint.strategy=shuffle element zostanie zignorowany, a zapytanie nie zostanie uruchomione w strategii mieszania. Na przykład w poniższym przykładzie sprzężenie zawiera podsumowanie po lewej stronie, więc użycie hint.strategy=shuffle nie zastosuje strategii mieszania do zapytania:

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

Aby rozwiązać ten problem i uruchomić strategię mieszania, wybierz klucz wspólny dla summarize operacji i join . W tym przypadku kluczem jest EpisodeId. Użyj wskazówki hint.shufflekey , aby określić klucz mieszania dla join elementu do 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	...
...	...	...	...	...	...

Używanie funkcji sumowania z mieszania w celu zwiększenia wydajności

W tym przykładzie summarize użycie operatora ze strategią shuffle zwiększa wydajność. Tabela źródłowa zawiera rekordy 150M, a kardynalność grupy według klucza to 10M, który jest rozłożony na 10 węzłów klastra.

Użycie summarize operatora bez shuffle strategii kończy się po 1:08, a szczyt użycia pamięci wynosi ok. 3 GB:

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

Output

Count
1086

Podczas korzystania ze shuffle strategii z usługą summarizezapytanie kończy się po około 7 sekundach, a szczyt użycia pamięci wynosi 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

W poniższym przykładzie pokazano wydajność klastra z dwoma węzłami klastra z tabelą zawierającą rekordy 60M, gdzie kardynalność grupy według klucza wynosi 2 mln.

Uruchomienie zapytania bez hint.num_partitions będzie używać tylko dwóch partycji (jako numer węzłów klastra), a następujące zapytanie zajmie około 1:10 minut:

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

Jeśli ustawienie liczby partycji na 10, zapytanie zakończy się po 23 sekundach:

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

Używanie sprzężenia z mieszania w celu zwiększenia wydajności

W poniższym przykładzie pokazano, jak użycie shuffle strategii z operatorem join zwiększa wydajność.

Przykłady zostały próbkowane w klastrze z 10 węzłami, w których dane są rozłożone na wszystkie te węzły.

Tabela źródłowa po lewej stronie zapytania zawiera 15 rekordów, w których kardynalność join klucza wynosi ok. 14 mln. Źródło po prawej stronie zapytania ma rekordy 150M, a kardynalność join klucza to 10 mln. Zapytanie kończy się po około 28 sekundach, a szczyt użycia pamięci wynosi 1,43 GB:

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

W przypadku korzystania ze shuffle strategii z operatorem join zapytanie kończy się po ok. 4 sekundach, a szczyt użycia pamięci wynosi 0,3 GB:

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

W innym przykładzie spróbujemy wykonać te same zapytania dla większego zestawu danych z następującymi warunkami:

• Lewe źródło wartości join to 150M, a kardynalność klucza to 148M.
• Źródło po prawej stronie join obiektu wynosi 1,5B, a kardynalność klucza wynosi ok. 100 mln.

Zapytanie z tylko join operatorem osiąga limity i limity czasu po 4 minutach. Jednak w przypadku korzystania ze shuffle strategii z operatorem join zapytanie kończy się po około 34 sekundach, a szczyt użycia pamięci wynosi 1,23 GB.

W poniższym przykładzie pokazano poprawę klastra, który ma dwa węzły klastra z tabelą 60M rekordów, gdzie kardynalność join klucza wynosi 2 mln. Uruchomienie zapytania bez hint.num_partitions będzie używać tylko dwóch partycji (jako numer węzłów klastra), a następujące zapytanie zajmie około 1:10 minut:

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

Podczas ustawiania liczby partycji na 10 zapytanie zakończy się po 23 sekundach:

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