Przykład kwerendy równoległe

Następująca kwerenda oblicza liczbę zamówień złożonych w określonym kwartale, począwszy od 1 kwietnia 2000 i w której co najmniej jeden element wiersza zamówienia zostało odebrane przez klienta później niż data w polu zatwierdzone.Ta kwerenda wyświetla liczbę takich zamówienia pogrupowane według priorytetu każdej kolejności i sortowane rosnąco priorytet.

W tym przykładzie użyto teoretyczne tabela i nazw kolumn.

SELECT o_orderpriority, COUNT(*) AS Order_Count
FROM orders
WHERE o_orderdate >= '2000/04/01'
   AND o_orderdate < DATEADD (mm, 3, '2000/04/01')
   AND EXISTS
         (
          SELECT *
            FROM    lineitem
            WHERE l_orderkey = o_orderkey
               AND l_commitdate < l_receiptdate
         )
   GROUP BY o_orderpriority
   ORDER BY o_orderpriority

Przyjęto następujące indeksy są definiowane na lineitem and zamówienia tables:

CREATE INDEX l_order_dates_idx 
   ON lineitem
      (l_orderkey, l_receiptdate, l_commitdate, l_shipdate)

CREATE UNIQUE INDEX o_datkeyopr_idx
   ON ORDERS
      (o_orderdate, o_orderkey, o_custkey, o_orderpriority)

Oto jeden możliwe równoległych wygenerowany plan dla kwerendy, uprzednio wyświetlane:

|--Stream Aggregate(GROUP BY:([ORDERS].[o_orderpriority])
                  DEFINE:([Expr1005]=COUNT(*)))
    |--Parallelism(Gather Streams, ORDER BY:
                  ([ORDERS].[o_orderpriority] ASC))
         |--Stream Aggregate(GROUP BY:
                  ([ORDERS].[o_orderpriority])
                  DEFINE:([Expr1005]=Count(*)))
              |--Sort(ORDER BY:([ORDERS].[o_orderpriority] ASC))
                   |--Merge Join(Left Semi Join, MERGE:
                  ([ORDERS].[o_orderkey])=
                        ([LINEITEM].[l_orderkey]),
                  RESIDUAL:([ORDERS].[o_orderkey]=
                        [LINEITEM].[l_orderkey]))
                        |--Sort(ORDER BY:([ORDERS].[o_orderkey] ASC))
                        |    |--Parallelism(Repartition Streams,
                           PARTITION COLUMNS:
                           ([ORDERS].[o_orderkey]))
                        |         |--Index Seek(OBJECT:
                     ([tpcd1G].[dbo].[ORDERS].[O_DATKEYOPR_IDX]),
                     SEEK:([ORDERS].[o_orderdate] >=
                           Apr  1 2000 12:00AM AND
                           [ORDERS].[o_orderdate] <
                           Jul  1 2000 12:00AM) ORDERED)
                        |--Parallelism(Repartition Streams,
                     PARTITION COLUMNS:
                     ([LINEITEM].[l_orderkey]),
                     ORDER BY:([LINEITEM].[l_orderkey] ASC))
                             |--Filter(WHERE:
                           ([LINEITEM].[l_commitdate]<
                           [LINEITEM].[l_receiptdate]))
                                  |--Index Scan(OBJECT:
         ([tpcd1G].[dbo].[LINEITEM].[L_ORDER_DATES_IDX]), ORDERED)

Na ilustracji pokazano plan optymalizator kwerendy wykonane z pewną proste równa 4 i obejmujących łączyć dwóch tabel.

Plan równoległych zawiera trzy proste podmiotów gospodarczych.Oba Szukaj indeksu operator o_datkey_ptr i indeksów Skanowanie indeksu operator l_order_dates_idx indeksu są wykonywane równolegle.Daje to kilka wyłącznych strumieni.Można to ustalić od najbliższego operatorów proste powyżej Skanowanie indeksu and Szukaj indeksu operatorów, odpowiednio.Konieczności ponownego dzielenia dysku na obu się partycje typu wymiany.Oznacza to są one po prostu reshuffling danych między strumieni i produkcji taką samą liczbę strumieni dla swoich danych wyjściowych, ponieważ mają one na ich dane wejściowe.Ta liczba strumieni, jest równa stopień proste.

The Parallelism operator above the l_order_dates_idxIndex Scan operator is repartitioning its input streams using the value of L_ORDERKEY as a key.W ten sposób takich samych wartościach L_ORDERKEY kończy w tym samym strumień wyjściowy.W tym samym czas, strumienie danych wyjściowych zachować kolejność na kolumnie L_ORDERKEY spełniać wymóg wejściowy Scalanie łączyć operator.

The Parallelism operator above the Index Seek operator is repartitioning its input streams using the value of O_ORDERKEY.Ponieważ jego dane wejściowe nie jest posortowana według wartości kolumny O_ORDERKEY i jest to kolumna dołączania dołączania dołączania w Scalanie łączyć operatoraSortowanie operator między Proste and Scalanie łączyć operatorów upewnij się, że dane wejściowe są posortowane w Scalanie łączyć operator w kolumnach łączyć.The Sort operator, like the Merge łączyć operator, is performed in parallel.

Najwyższego poziomu Proste operator zbiera wyniki z wielu strumieni w jeden strumień.Częściowe agregacja wykonywane przez Agregat strumienia operator poniżej Proste operator następnie są kumulowane w pojedynczej wartości SUM dla każdej innej wartości O_ORDERPRIORITY w Agregat strumienia operator powyżej Proste operator.Ponieważ ten plan ma dwa segmenty wymiany stopnia proste równa 4, używa osiem wątków.