Disculpas de antemano por la pregunta muy detallada. He incluido consultas para generar un conjunto de datos completo para reproducir el problema, y estoy ejecutando SQL Server 2012 en una máquina de 32 núcleos. Sin embargo, no creo que esto sea específico de SQL Server 2012, y he forzado un MAXDOP de 10 para este ejemplo en particular.
Tengo dos tablas que están particionadas usando el mismo esquema de partición. Al unirlos en la columna utilizada para la partición, noté que SQL Server no puede optimizar una combinación de fusión paralela tanto como uno podría esperar y, por lo tanto, elige usar una UNIÓN HASH. En este caso particular, puedo simular manualmente una MERGE JOIN paralela mucho más óptima dividiendo la consulta en 10 rangos disjuntos basados en la función de partición y ejecutando cada una de esas consultas simultáneamente en SSMS. Usando WAITFOR para ejecutarlos todos al mismo tiempo, el resultado es que todas las consultas se completan en ~ 40% del tiempo total utilizado por la HASH JOIN paralela original.
¿Hay alguna manera de hacer que SQL Server haga esta optimización por sí solo en el caso de tablas con particiones equivalentes? Entiendo que SQL Server generalmente puede incurrir en una sobrecarga para hacer que MERGE JOIN sea paralelo, pero parece que hay un método de fragmentación muy natural con una sobrecarga mínima en este caso. ¿Quizás es solo un caso especializado que el optimizador aún no es lo suficientemente inteligente como para reconocerlo?
Aquí está el SQL para configurar un conjunto de datos simplificado para reproducir este problema:
/* 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)
¡Ahora finalmente estamos listos para reproducir la consulta subóptima!
/* 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)
Sin embargo, el uso de un solo hilo para procesar cada partición (ejemplo para la primera partición a continuación) conduciría a un plan mucho más eficiente. Probé esto ejecutando una consulta como la siguiente para cada una de las 10 particiones exactamente en el mismo momento, y las 10 terminaron en poco más de 1 segundo:
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)