SQL Server tidak mengoptimalkan gabungan paralel pada dua tabel yang dipartisi secara setara

Permintaan maaf sebelumnya untuk pertanyaan yang sangat rinci. Saya telah memasukkan pertanyaan untuk menghasilkan set data lengkap untuk mereproduksi masalah, dan saya menjalankan SQL Server 2012 pada mesin 32-core. Namun, saya tidak berpikir ini khusus untuk SQL Server 2012, dan saya telah memaksa MAXDOP 10 untuk contoh khusus ini.

Saya memiliki dua tabel yang dipartisi menggunakan skema partisi yang sama. Ketika bergabung bersama mereka pada kolom yang digunakan untuk mempartisi, saya perhatikan bahwa SQL Server tidak dapat mengoptimalkan gabungan paralel sebanyak yang diharapkan dan dengan demikian memilih untuk menggunakan HASH JOIN. Dalam kasus khusus ini, saya dapat secara manual mensimulasikan paralel GABUNG paralel yang jauh lebih optimal dengan memecah kueri menjadi 10 rentang terpisah berdasarkan fungsi partisi dan menjalankan masing-masing kueri secara bersamaan di SSMS. Menggunakan WAITFOR untuk menjalankan semuanya pada waktu yang bersamaan, hasilnya adalah semua kueri selesai dalam ~ 40% dari total waktu yang digunakan oleh paralel asli HASH JOIN.

Apakah ada cara untuk mendapatkan SQL Server untuk membuat optimasi ini sendiri dalam kasus tabel yang dipartisi secara setara? Saya mengerti bahwa SQL Server umumnya dapat mengeluarkan banyak overhead untuk membuat paralel GABUNG GABUNGAN, tetapi sepertinya ada metode sharding yang sangat alami dengan overhead minimal dalam kasus ini. Mungkin ini hanya kasus khusus bahwa pengoptimal belum cukup pintar untuk mengenali?

Berikut adalah SQL untuk mengatur kumpulan data yang disederhanakan untuk mereproduksi masalah ini:

/* Create the first test data table */
CREATE TABLE test_transaction_properties 
    ( transactionID INT NOT NULL IDENTITY(1,1)
    , prop1 INT NULL
    , prop2 FLOAT NULL
    )

/* Populate table with pseudo-random data (the specific data doesn't matter too much for this example) */
;WITH E1(N) AS (
    SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 
    UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1
)
, E2(N) AS (SELECT 1 FROM E1 a CROSS JOIN E1 b)
, E4(N) AS (SELECT 1 FROM E2 a CROSS JOIN E2 b)
, E8(N) AS (SELECT 1 FROM E4 a CROSS JOIN E4 b)
INSERT INTO test_transaction_properties WITH (TABLOCK) (prop1, prop2)
SELECT TOP 10000000 (ABS(CAST(CAST(NEWID() AS VARBINARY) AS INT)) % 5) + 1 AS prop1
                , ABS(CAST(CAST(NEWID() AS VARBINARY) AS INT)) * rand() AS prop2
FROM E8

/* Create the second test data table */
CREATE TABLE test_transaction_item_detail
    ( transactionID INT NOT NULL
    , productID INT NOT NULL
    , sales FLOAT NULL
    , units INT NULL
    )

 /* Populate the second table such that each transaction has one or more items
     (again, the specific data doesn't matter too much for this example) */
INSERT INTO test_transaction_item_detail WITH (TABLOCK) (transactionID, productID, sales, units)
SELECT t.transactionID, p.productID, 100 AS sales, 1 AS units
FROM test_transaction_properties t
JOIN (
    SELECT 1 as productRank, 1 as productId
    UNION ALL SELECT 2 as productRank, 12 as productId
    UNION ALL SELECT 3 as productRank, 123 as productId
    UNION ALL SELECT 4 as productRank, 1234 as productId
    UNION ALL SELECT 5 as productRank, 12345 as productId
) p
    ON p.productRank <= t.prop1

/* Divides the transactions evenly into 10 partitions */
CREATE PARTITION FUNCTION [pf_test_transactionId] (INT)
AS RANGE RIGHT
FOR VALUES
(1,1000001,2000001,3000001,4000001,5000001,6000001,7000001,8000001,9000001)

CREATE PARTITION SCHEME [ps_test_transactionId]
AS PARTITION [pf_test_transactionId]
ALL TO ( [PRIMARY] )

/* Apply the same partition scheme to both test data tables */
ALTER TABLE test_transaction_properties
ADD CONSTRAINT PK_test_transaction_properties
PRIMARY KEY (transactionID)
ON ps_test_transactionId (transactionID)

ALTER TABLE test_transaction_item_detail
ADD CONSTRAINT PK_test_transaction_item_detail
PRIMARY KEY (transactionID, productID)
ON ps_test_transactionId (transactionID)

Sekarang kami akhirnya siap mereproduksi kueri yang tidak optimal!

/* This query produces a HASH JOIN using 20 threads without the MAXDOP hint,
    and the same behavior holds in that case.
    For simplicity here, I have limited it to 10 threads. */
SELECT COUNT(*)
FROM test_transaction_item_detail i
JOIN test_transaction_properties t
    ON t.transactionID = i.transactionID
OPTION (MAXDOP 10)

Namun, menggunakan satu utas untuk memproses setiap partisi (contoh untuk partisi pertama di bawah) akan menghasilkan rencana yang jauh lebih efisien. Saya menguji ini dengan menjalankan kueri seperti di bawah ini untuk masing-masing dari 10 partisi tepat pada saat yang sama, dan semua 10 selesai hanya dalam 1 detik:

SELECT COUNT(*)
FROM test_transaction_item_detail i
INNER MERGE JOIN test_transaction_properties t
    ON t.transactionID = i.transactionID
WHERE t.transactionID BETWEEN 1 AND 1000000
OPTION (MAXDOP 1)

Anda benar bahwa pengoptimal SQL Server lebih suka untuk tidak menghasilkan paket MERGEbergabung paralel (harganya alternatif ini cukup tinggi). Paralel MERGEselalu membutuhkan pertukaran partisi ulang pada kedua input gabungan, dan yang lebih penting, mengharuskan urutan baris dipertahankan di seluruh pertukaran itu.

Paralelisme paling efisien ketika setiap utas dapat berjalan secara independen; pemeliharaan pesanan sering menyebabkan sinkronisasi sering menunggu, dan pada akhirnya dapat menyebabkan pertukaran tumpah ketempdb untuk menyelesaikan kondisi kebuntuan intra-kueri.

Masalah-masalah ini dapat diatasi dengan menjalankan beberapa contoh dari seluruh kueri pada masing-masing utas, dengan setiap utas memproses rentang data eksklusif. Namun ini bukan strategi yang dipertimbangkan oleh pengoptimal. Seperti itu, model SQL Server asli untuk paralelisme memecah permintaan di bursa, dan menjalankan segmen rencana yang dibentuk oleh mereka yang terbagi pada beberapa utas.

Ada beberapa cara untuk mencapai menjalankan seluruh rencana kueri pada beberapa utas di atas rentang set data eksklusif, tetapi mereka memerlukan tipu daya yang tidak semua orang akan senang dengan (dan tidak akan didukung oleh Microsoft atau dijamin untuk bekerja di masa depan). Salah satu pendekatan tersebut adalah untuk beralih ke partisi tabel dipartisi dan memberikan tugas masing-masing thread menghasilkan subtotal. Hasilnya adalahSUM jumlah baris yang dikembalikan oleh setiap utas independen:

Mendapatkan nomor partisi cukup mudah dari metadata:

DECLARE @P AS TABLE
(
    partition_number integer PRIMARY KEY
);

INSERT @P (partition_number)
SELECT
    p.partition_number
FROM sys.partitions AS p 
WHERE 
    p.[object_id] = OBJECT_ID(N'test_transaction_properties', N'U')
    AND p.index_id = 1;

Kami kemudian menggunakan angka-angka ini untuk mendorong gabungan berkorelasi ( APPLY), dan $PARTITIONfungsi untuk membatasi setiap utas ke nomor partisi saat ini:

SELECT
    row_count = SUM(Subtotals.cnt)
FROM @P AS p
CROSS APPLY
(
    SELECT
        cnt = COUNT_BIG(*)
    FROM dbo.test_transaction_item_detail AS i
    JOIN dbo.test_transaction_properties AS t ON
        t.transactionID = i.transactionID
    WHERE 
        $PARTITION.pf_test_transactionId(t.transactionID) = p.partition_number
        AND $PARTITION.pf_test_transactionId(i.transactionID) = p.partition_number
) AS SubTotals;

Paket kueri menunjukkan MERGEgabungan yang dilakukan untuk setiap baris dalam tabel @P. Properti pemindaian indeks berkelompok mengonfirmasi bahwa hanya satu partisi yang diproses pada setiap iterasi:

Sayangnya, ini hanya menghasilkan pemrosesan serial partisi. Pada set data yang Anda berikan, laptop 4-core (hyperthreaded to 8) saya mengembalikan hasil yang benar dalam 7 detik dengan semua data dalam memori.

Untuk membuat MERGEsub-rencana berjalan secara bersamaan, kita memerlukan rencana paralel di mana id partisi didistribusikan di atas utas yang tersedia ( MAXDOP) dan setiap MERGEsub-rencana berjalan pada satu utas menggunakan data dalam satu partisi. Sayangnya, pengoptimal sering memutuskan paralel MERGEdengan alasan biaya, dan tidak ada cara yang terdokumentasi untuk memaksakan rencana paralel. Ada cara yang tidak berdokumen (dan tidak didukung), menggunakan jejak flag 8649 :

SELECT
    row_count = SUM(Subtotals.cnt)
FROM @P AS p
CROSS APPLY
(
    SELECT
        cnt = COUNT_BIG(*)
    FROM dbo.test_transaction_item_detail AS i
    JOIN dbo.test_transaction_properties AS t ON
        t.transactionID = i.transactionID
    WHERE 
        $PARTITION.pf_test_transactionId(t.transactionID) = p.partition_number
        AND $PARTITION.pf_test_transactionId(i.transactionID) = p.partition_number
) AS SubTotals
OPTION (QUERYTRACEON 8649);

Sekarang rencana kueri menunjukkan nomor partisi agar @Ptidak didistribusikan di antara utas secara round-robin. Setiap utas menjalankan sisi dalam loop bersarang bergabung untuk satu partisi, mencapai tujuan kami memproses data terpisah secara bersamaan. Hasil yang sama sekarang dikembalikan dalam 3 detik pada 8 hyper-core saya, dengan semua delapan pada pemanfaatan 100%.

Saya tidak menyarankan Anda menggunakan teknik ini - lihat peringatan saya sebelumnya - tetapi ini menjawab pertanyaan Anda.

Lihat artikel saya Meningkatkan Tabel Partisi Gabung Kinerja untuk detail lebih lanjut.

Kolom toko

Melihat Anda menggunakan SQL Server 2012 (dan menganggap itu Enterprise), Anda juga memiliki opsi untuk menggunakan indeks columnstore. Ini menunjukkan potensi hash mode batch bergabung di mana memori yang cukup tersedia:

CREATE NONCLUSTERED COLUMNSTORE INDEX cs 
ON dbo.test_transaction_properties (transactionID);

CREATE NONCLUSTERED COLUMNSTORE INDEX cs 
ON dbo.test_transaction_item_detail (transactionID);

Dengan indeks ini di tempat kueri ...

SELECT
    COUNT_BIG(*)
FROM dbo.test_transaction_properties AS ttp
JOIN dbo.test_transaction_item_detail AS ttid ON
    ttid.transactionID = ttp.transactionID;

... menghasilkan rencana eksekusi berikut dari pengoptimal tanpa tipu daya:

Hasil yang benar dalam 2 detik , tetapi menghilangkan pemrosesan mode baris untuk agregat skalar bahkan lebih membantu:

SELECT
    COUNT_BIG(*)
FROM dbo.test_transaction_properties AS ttp
JOIN dbo.test_transaction_item_detail AS ttid ON
    ttid.transactionID = ttp.transactionID
GROUP BY
    ttp.transactionID % 1;

Permintaan kolom-toko yang dioptimalkan berjalan dalam 851 ms .

Geoff Patterson membuat laporan bug Partition Wise Joins tetapi ditutup sebagai Won't Fix.

Cara untuk membuat pengoptimal bekerja dengan cara yang Anda pikir lebih baik adalah melalui petunjuk kueri.

Pada kasus ini, OPTION (MERGE JOIN)

Atau Anda bisa menggunakan seluruh babi dan menggunakannya USE PLAN