Udostępnij za pośrednictwem

zapytanie shuffle

  • Artykuł

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:

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.

Uwaga

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-series partition) w zapytaniu.

Składnia

Z hint.strategy = shuffle

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

T = | summarize hint.strategyshuffle DataExpression

Podzapytywanie | partycji T | hint.strategy = shuffle( )

Z kluczem hint.shufflekey =

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

T hint.shufflekeysummarize = | key DataExpression

T hint.shufflekeymake-series = | key DataExpression

Podzapytywanie | klucza ( partycji T | hint.shufflekey = )

Dowiedz się więcej na temat konwencji składni.

Parametry

Nazwisko Type Wymagania opis
T string ✔️ Tabelaryczne źródło, którego dane mają być przetwarzane przez operatora.
DataExpression string Niejawne lub jawne wyrażenie przekształcenia tabelarycznego.
Zapytanie string Wyrażenie przekształcenia jest uruchamiane na rekordach języka T.
key string join Użyj klucza, summarize klucza, make-series klucza lub partition klucza.
Podzapytywanie string Wyrażenie przekształcenia.

Uwaga

W zależności od wybranej składni należy określić wartość DataExpression lub Query .

Przykłady

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.

Uruchamianie zapytania

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

Wyjście

Count
67

Używanie sprzężenia z mieszania

Uruchamianie zapytania

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

Wyjście

Count
103

Używanie serii make-series z mieszania

Uruchamianie zapytania

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

Wyjście

Stan sum_DamageProperty StartTime
DAKOTA PÓŁNOCNA [60000,0,0] ["2006-12-31T00:00:00.000000Z","2007-01-15T00:00:00.0000000Z","2007-01-30T00:00:00.000000Z"]
NORTH CAROLINA [20000,0,1000] ["2006-12-31T00:00:00.000000Z","2007-01-15T00:00:00.0000000Z","2007-01-30T00:00:00.000000Z"]
PÓŁNOC ATLANTYCKIA [0,0,0] ["2006-12-31T00:00:00.000000Z","2007-01-15T00:00:00.0000000Z","2007-01-30T00:00:00.000000Z"]

Używanie partycji z mieszania

Uruchamianie zapytania

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

Wyjście

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:

Uruchamianie zapytania

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

Wyjście

Count
14

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

Uruchamianie zapytania

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

Wyjście

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:

Uruchamianie 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

Wyjście

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:

Uruchamianie zapytania

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

Wyjście

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

Wyjście

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

Wyjście

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