Parte de mi carga de trabajo utiliza una función CLR que implementa el algoritmo hash espeluznante para comparar filas para ver si algún valor de columna ha cambiado. La función CLR toma una cadena binaria como entrada, por lo que necesito una forma rápida de convertir filas en una cadena binaria. Espero dividir alrededor de 10 mil millones de filas durante la carga de trabajo completa, así que me gustaría que este código sea lo más rápido posible.
Tengo alrededor de 300 tablas con diferentes esquemas. Para los fines de esta pregunta, suponga una estructura de tabla simple de 32 INTcolumnas anulables . He proporcionado datos de muestra, así como una forma de comparar los resultados al final de esta pregunta.
Las filas deben convertirse a la misma cadena binaria si todos los valores de columna son iguales. Las filas deben convertirse a cadenas binarias diferentes si cualquier valor de columna es diferente. Por ejemplo, un código tan simple como el siguiente no funcionará:
CAST(COL1 AS BINARY(4)) + CAST(COL2 AS BINARY(4)) + ..No maneja los NULL correctamente. Si COL1es NULL para la fila 1 y COL2NULL para la fila 2, ambas filas se convertirán en una cadena NULL. Creo que el manejo correcto de NULL es la parte más difícil de convertir toda la fila correctamente. Todos los valores permitidos para las columnas INT son posibles.
Para evitar algunas preguntas:
- Si es importante, la mayoría de las veces (90% +) las columnas no serán NULL.
- Tengo que usar el CLR.
- Tengo que cortar tantas filas. No puedo persistir los hashes.
- Creo que no puedo usar el modo por lotes para la conversión debido a la presencia de la función CLR.
¿Cuál es la forma más rápida de convertir 32 INTcolumnas anulables a una BINARY(X)oVARBINARY(X) cadena ?
Datos de muestra y código según lo prometido:
-- create sample data
DROP TABLE IF EXISTS dbo.TABLE_OF_32_INTS;
CREATE TABLE dbo.TABLE_OF_32_INTS (
COL1 INT NULL,
COL2 INT NULL,
COL3 INT NULL,
COL4 INT NULL,
COL5 INT NULL,
COL6 INT NULL,
COL7 INT NULL,
COL8 INT NULL,
COL9 INT NULL,
COL10 INT NULL,
COL11 INT NULL,
COL12 INT NULL,
COL13 INT NULL,
COL14 INT NULL,
COL15 INT NULL,
COL16 INT NULL,
COL17 INT NULL,
COL18 INT NULL,
COL19 INT NULL,
COL20 INT NULL,
COL21 INT NULL,
COL22 INT NULL,
COL23 INT NULL,
COL24 INT NULL,
COL25 INT NULL,
COL26 INT NULL,
COL27 INT NULL,
COL28 INT NULL,
COL29 INT NULL,
COL30 INT NULL,
COL31 INT NULL,
COL32 INT NULL
);
INSERT INTO dbo.TABLE_OF_32_INTS WITH (TABLOCK)
SELECT 0, 123, 12345, 1234567, 123456789
, 0, 123, 12345, 1234567, 123456789
, 0, 123, 12345, 1234567, 123456789
, 0, 123, 12345, 1234567, 123456789
, 0, 123, 12345, 1234567, 123456789
, 0, 123, 12345, 1234567, 123456789
, NULL, -876545321
FROM
(
SELECT TOP (1000000) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) RN
FROM master..spt_values t1
CROSS JOIN master..spt_values t2
) q
OPTION (MAXDOP 1);
GO
-- procedure to test performance
CREATE OR ALTER PROCEDURE #p AS
BEGIN
SET NOCOUNT ON;
DECLARE
@counter INT = 0,
@dummy VARBINARY(8000);
WHILE @counter < 10
BEGIN
SELECT @dummy = -- this code is clearly incomplete as it does not handle NULLs
CAST(COL1 AS BINARY(4)) +
CAST(COL2 AS BINARY(4)) +
CAST(COL3 AS BINARY(4)) +
CAST(COL4 AS BINARY(4)) +
CAST(COL5 AS BINARY(4)) +
CAST(COL6 AS BINARY(4)) +
CAST(COL7 AS BINARY(4)) +
CAST(COL8 AS BINARY(4)) +
CAST(COL9 AS BINARY(4)) +
CAST(COL10 AS BINARY(4)) +
CAST(COL11 AS BINARY(4)) +
CAST(COL12 AS BINARY(4)) +
CAST(COL13 AS BINARY(4)) +
CAST(COL14 AS BINARY(4)) +
CAST(COL15 AS BINARY(4)) +
CAST(COL16 AS BINARY(4)) +
CAST(COL17 AS BINARY(4)) +
CAST(COL18 AS BINARY(4)) +
CAST(COL19 AS BINARY(4)) +
CAST(COL20 AS BINARY(4)) +
CAST(COL21 AS BINARY(4)) +
CAST(COL22 AS BINARY(4)) +
CAST(COL23 AS BINARY(4)) +
CAST(COL24 AS BINARY(4)) +
CAST(COL25 AS BINARY(4)) +
CAST(COL26 AS BINARY(4)) +
CAST(COL27 AS BINARY(4)) +
CAST(COL28 AS BINARY(4)) +
CAST(COL29 AS BINARY(4)) +
CAST(COL30 AS BINARY(4)) +
CAST(COL31 AS BINARY(4)) +
CAST(COL32 AS BINARY(4))
FROM dbo.TABLE_OF_32_INTS
OPTION (MAXDOP 1);
SET @counter = @counter + 1;
END;
SELECT cpu_time
FROM sys.dm_exec_requests
WHERE session_id = @@SPID;
END;
GO
-- run procedure
EXEC #p;(Seguiré usando el hash espeluznante en este resultado binario. La carga de trabajo usa combinaciones hash y el valor hash se usa para una de las compilaciones hash. No quiero un valor binario largo en la compilación hash porque requiere demasiado memoria.)