Cách nhanh nhất để chuyển đổi nhiều ints 1: 1 nullable thành chuỗi nhị phân là gì?


14

Một phần khối lượng công việc của tôi sử dụng hàm CLR thực hiện thuật toán băm ma quái để so sánh các hàng để xem có giá trị cột nào thay đổi không. Hàm CLR lấy một chuỗi nhị phân làm đầu vào, vì vậy tôi cần một cách nhanh chóng để chuyển đổi các hàng thành chuỗi nhị phân. Tôi hy vọng sẽ băm khoảng 10 tỷ hàng trong toàn bộ khối lượng công việc vì vậy tôi muốn mã này nhanh nhất có thể.

Tôi có khoảng 300 bảng với các lược đồ khác nhau. Đối với mục đích của câu hỏi này, vui lòng giả sử cấu trúc bảng đơn giản gồm 32 INTcột không thể. Tôi đã cung cấp dữ liệu mẫu cũng như một cách để kết quả điểm chuẩn ở cuối câu hỏi này.

Các hàng phải được chuyển đổi thành cùng một chuỗi nhị phân nếu tất cả các giá trị cột giống nhau. Các hàng phải được chuyển đổi thành các chuỗi nhị phân khác nhau nếu bất kỳ giá trị cột nào khác nhau. Ví dụ, mã đơn giản như sau sẽ không hoạt động:

CAST(COL1 AS BINARY(4)) + CAST(COL2 AS BINARY(4)) + ..

Nó không xử lý NULL chính xác. Nếu COL1là NULL cho hàng 1 và COL2là NULL cho hàng 2 thì cả hai hàng sẽ được chuyển đổi thành chuỗi NULL. Tôi tin rằng việc xử lý chính xác các NULL là phần khó nhất để chuyển đổi toàn bộ hàng một cách chính xác. Tất cả các giá trị được phép cho các cột INT là có thể.

Để tránh một số câu hỏi:

  • Nếu có vấn đề, phần lớn thời gian (90% +) các cột sẽ không phải là NULL.
  • Tôi phải sử dụng CLR.
  • Tôi phải băm nhiều hàng này. Tôi không thể kiên trì băm.
  • Tôi tin rằng tôi không thể sử dụng chế độ hàng loạt cho chuyển đổi do sự hiện diện của chức năng CLR.

Cách nhanh nhất để chuyển đổi 32 INTcột nullable thành một chuỗi BINARY(X)hoặc là VARBINARY(X)gì?

Dữ liệu mẫu và mã như đã hứa:

-- 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;

(Tôi vẫn sẽ sử dụng hàm băm ma quái trên kết quả nhị phân này. Khối lượng công việc sử dụng phép nối băm và giá trị băm được sử dụng cho một trong các bản dựng băm. Tôi không muốn giá trị nhị phân dài trong bản dựng băm vì nó đòi hỏi quá nhiều ký ức.)

Câu trả lời:


6

Điều gì về việc sử dụng BINARY(5)và chuyển đổi NULL thành một cái gì đó ngoài phạm vi cho INTs:

SELECT @dummy =
    ISNULL(CAST(COL1  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL2  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL3  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL4  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL5  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL6  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL7  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL8  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL9  AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL10 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL11 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL12 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL13 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL14 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL15 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL16 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL17 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL18 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL19 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL20 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL21 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL22 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL23 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL24 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL25 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL26 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL27 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL28 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL29 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL30 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL31 AS BINARY(5)), 0x0100000000) + 
    ISNULL(CAST(COL32 AS BINARY(5)), 0x0100000000)
FROM dbo.TABLE_OF_32_INTS
OPTION (MAXDOP 1);

11

Trên máy của tôi (SQL Server 2017), hàm C # SQLCLR sau đây chạy nhanh hơn khoảng 30% so với binary(5)ý tưởng, nhanh hơn 35% so với CONCAT_WSvà trong một nửa thời gian tự trả lời.

Nó đòi hỏi sự UNSAFEcho phép và sử dụng con trỏ. Việc thực hiện rất đặc biệt gắn liền với dữ liệu thử nghiệm.

Đối với mục đích thử nghiệm, cách dễ nhất để làm cho tổ hợp không an toàn này hoạt động là đặt cơ sở dữ liệu TRUSTWORTHYvà vô hiệu hóa tùy chọn cấu hình bảo mật nghiêm ngặt clr nếu cần.

Mã biên dịch

Để thuận tiện, các CREATE ASSEMBLYbit được biên dịch có tại https://gist.github.com/SQLKiwi/72d01b661c74485900e7ebcfdc63ab8e

Sơ khai chức năng T-SQL

CREATE FUNCTION dbo.NullableIntsToBinary
(
    @Col01 int, @Col02 int, @Col03 int, @Col04 int, @Col05 int, @Col06 int, @Col07 int, @Col08 int, 
    @Col09 int, @Col10 int, @Col11 int, @Col12 int, @Col13 int, @Col14 int, @Col15 int, @Col16 int, 
    @Col17 int, @Col18 int, @Col19 int, @Col20 int, @Col21 int, @Col22 int, @Col23 int, @Col24 int, 
    @Col25 int, @Col26 int, @Col27 int, @Col28 int, @Col29 int, @Col30 int, @Col31 int, @Col32 int
)
RETURNS binary(132) 
WITH EXECUTE AS CALLER
AS EXTERNAL NAME Obbish.UserDefinedFunctions.NullableIntsToBinary;

Mã nguồn

Nguồn C # có tại https://gist.github.com/SQLKiwi/64f320fe7fd802a68a3a644aa8b8af9f

Nếu bạn tự biên dịch cái này, bạn phải sử dụng Thư viện lớp (đậm) làm loại dự án đích và kiểm tra tùy chọn cho phép xây dựng mã không an toàn .

Giải pháp kết hợp

Vì cuối cùng bạn muốn tính toán SpookyHash của dữ liệu nhị phân được trả về ở trên, bạn có thể gọi SpookyHash trong hàm CLR và trả về hàm băm 16 byte.

Việc triển khai ví dụ dựa trên bảng có hỗn hợp các loại dữ liệu cột là tại https://gist.github.com/QueryKiwi/6f82582a4ad1920c372fac118ec82460 . Điều này bao gồm một phiên bản nội tuyến không an toàn của thuật toán Spooky Hash có nguồn gốc từ SpookilySharp của Jon Hanna và mã nguồn C miền công khai ban đầu của Bob Jenkins.


7

Một INTcột có bốn byte giá trị được phép khớp chính xác với kích thước của a BINARY(4). Nói cách khác, mọi giá trị có thể có của BINary (4) được khớp với giá trị có thể có của một INTcột. Vì vậy, trừ khi có một giá trị không được phép trong INTcột, không có sự thay thế an toàn cho NULL. Có hay không một cột là NULL phải được mã hóa riêng. Nó chỉ đơn giản là không thể phù hợp trong một BINARY(4).

Một cách để làm điều này là với bitmap NULL. Hãy xem xét các mã sau đây:

CAST(       
    CASE WHEN COL1 IS NOT NULL THEN 0 ELSE 1 END | 
    CASE WHEN COL2 IS NOT NULL THEN 0 ELSE 2 END | 
    CASE WHEN COL3 IS NOT NULL THEN 0 ELSE 4 END | 
    CASE WHEN COL4 IS NOT NULL THEN 0 ELSE 8 END | 
    CASE WHEN COL5 IS NOT NULL THEN 0 ELSE 16 END | 
    CASE WHEN COL6 IS NOT NULL THEN 0 ELSE 32 END | 
    CASE WHEN COL7 IS NOT NULL THEN 0 ELSE 64 END | 
    CASE WHEN COL8 IS NOT NULL THEN 0 ELSE 128 END
AS BINARY(1))

Có hay không tám cột là NULL phù hợp trong một byte đơn. Các biểu thức này có thể được so sánh giữa các hàng để kiểm tra xem tất cả các cột giống nhau là NULL hay không NULL. Với thông tin bổ sung đó, nó trở nên an toàn để thay thế giá trị cột NULL bằng bất kỳ giá trị nào không phải là NULL. Tôi thấy CAST(ISNULL(COL1, 0) AS BINARY(4))là nhanh nhất, mặc dù các biến thể khác như ISNULL(CAST(COL1 AS VARBINARY(4)), 0x)có thể.

Thật khó để chứng minh bất cứ điều gì chắc chắn, nhưng tôi thấy các chi tiết sau đây là nhanh nhất:

  • Sử dụng 0 cho KHÔNG NULL trong bitmap vì tôi biết hầu hết các giá trị cột sẽ không phải là NULL
  • Sử dụng bitwise hoặc thay vì bổ sung cho bitmap
  • Kiểm tra xem giá trị cột có phải là NULL trái ngược với giá trị nhị phân được chuyển đổi không

Trên máy của tôi, điểm chuẩn mất khoảng 27,5 giây CPU. Thật không may, bước bitmap NULL mất khoảng một phần ba thời gian đó. Sẽ thật tốt nếu có một cách nhanh hơn để làm điều này.

Đây là giải pháp đầy đủ:

SELECT
    CAST(ISNULL(COL1, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL2, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL3, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL4, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL5, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL6, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL7, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL8, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL9, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL10, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL11, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL12, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL13, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL14, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL15, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL16, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL17, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL18, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL19, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL20, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL21, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL22, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL23, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL24, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL25, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL26, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL27, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL28, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL29, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL30, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL31, 0) AS BINARY(4)) + 
    CAST(ISNULL(COL32, 0) AS BINARY(4)) + 
    CAST(       
        CASE WHEN COL1 IS NOT NULL THEN 0 ELSE 1 END | 
        CASE WHEN COL2 IS NOT NULL THEN 0 ELSE 2 END | 
        CASE WHEN COL3 IS NOT NULL THEN 0 ELSE 4 END | 
        CASE WHEN COL4 IS NOT NULL THEN 0 ELSE 8 END | 
        CASE WHEN COL5 IS NOT NULL THEN 0 ELSE 16 END | 
        CASE WHEN COL6 IS NOT NULL THEN 0 ELSE 32 END | 
        CASE WHEN COL7 IS NOT NULL THEN 0 ELSE 64 END | 
        CASE WHEN COL8 IS NOT NULL THEN 0 ELSE 128 END
    AS BINARY(1)) + 
    CAST(   
        CASE WHEN COL9  IS NOT NULL THEN 0 ELSE 1 END | 
        CASE WHEN COL10 IS NOT NULL THEN 0 ELSE 2 END | 
        CASE WHEN COL11 IS NOT NULL THEN 0 ELSE 4 END | 
        CASE WHEN COL12 IS NOT NULL THEN 0 ELSE 8 END | 
        CASE WHEN COL13 IS NOT NULL THEN 0 ELSE 16 END | 
        CASE WHEN COL14 IS NOT NULL THEN 0 ELSE 32 END | 
        CASE WHEN COL15 IS NOT NULL THEN 0 ELSE 64 END | 
        CASE WHEN COL16 IS NOT NULL THEN 0 ELSE 128 END
    AS BINARY(1)) + 
    CAST(   
        CASE WHEN COL17 IS NOT NULL THEN 0 ELSE 1 END | 
        CASE WHEN COL18 IS NOT NULL THEN 0 ELSE 2 END | 
        CASE WHEN COL19 IS NOT NULL THEN 0 ELSE 4 END | 
        CASE WHEN COL20 IS NOT NULL THEN 0 ELSE 8 END | 
        CASE WHEN COL21 IS NOT NULL THEN 0 ELSE 16 END | 
        CASE WHEN COL22 IS NOT NULL THEN 0 ELSE 32 END | 
        CASE WHEN COL23 IS NOT NULL THEN 0 ELSE 64 END | 
        CASE WHEN COL24 IS NOT NULL THEN 0 ELSE 128 END
    AS BINARY(1)) + 
    CAST(   
        CASE WHEN COL25 IS NOT NULL THEN 0 ELSE 1 END | 
        CASE WHEN COL26 IS NOT NULL THEN 0 ELSE 2 END | 
        CASE WHEN COL27 IS NOT NULL THEN 0 ELSE 4 END | 
        CASE WHEN COL28 IS NOT NULL THEN 0 ELSE 8 END | 
        CASE WHEN COL29 IS NOT NULL THEN 0 ELSE 16 END | 
        CASE WHEN COL30 IS NOT NULL THEN 0 ELSE 32 END | 
        CASE WHEN COL31 IS NOT NULL THEN 0 ELSE 64 END | 
        CASE WHEN COL32 IS NOT NULL THEN 0 ELSE 128 END
    AS BINARY(1))
FROM dbo.TABLE_OF_32_INTS
OPTION (MAXDOP 1);

5

Trong các thử nghiệm của tôi concat_ws nhanh hơn một chút (18 giây) so với giải pháp bitmap null của bạn (26 giây). Sẽ có nhiều dữ liệu để xáo trộn xung quanh để bạn có thể thấy một số sự suy giảm hiệu suất ở nơi khác và nếu bạn muốn kết hợp điều này với các cột ký tự, bạn phải chọn dấu phân cách một cách khôn ngoan.

select @dummy = cast(concat_ws('|',
         isnull(cast(T.COL1  as varchar(11)), ''),
         isnull(cast(T.COL2  as varchar(11)), ''),
         isnull(cast(T.COL3  as varchar(11)), ''),
         isnull(cast(T.COL4  as varchar(11)), ''),
         isnull(cast(T.COL5  as varchar(11)), ''),
         isnull(cast(T.COL6  as varchar(11)), ''),
         isnull(cast(T.COL7  as varchar(11)), ''),
         isnull(cast(T.COL8  as varchar(11)), ''),
         isnull(cast(T.COL9  as varchar(11)), ''),
         isnull(cast(T.COL10 as varchar(11)), ''),
         isnull(cast(T.COL11 as varchar(11)), ''),
         isnull(cast(T.COL12 as varchar(11)), ''),
         isnull(cast(T.COL13 as varchar(11)), ''),
         isnull(cast(T.COL14 as varchar(11)), ''),
         isnull(cast(T.COL15 as varchar(11)), ''),
         isnull(cast(T.COL16 as varchar(11)), ''),
         isnull(cast(T.COL17 as varchar(11)), ''),
         isnull(cast(T.COL18 as varchar(11)), ''),
         isnull(cast(T.COL19 as varchar(11)), ''),
         isnull(cast(T.COL20 as varchar(11)), ''),
         isnull(cast(T.COL21 as varchar(11)), ''),
         isnull(cast(T.COL22 as varchar(11)), ''),
         isnull(cast(T.COL23 as varchar(11)), ''),
         isnull(cast(T.COL24 as varchar(11)), ''),
         isnull(cast(T.COL25 as varchar(11)), ''),
         isnull(cast(T.COL26 as varchar(11)), ''),
         isnull(cast(T.COL27 as varchar(11)), ''),
         isnull(cast(T.COL28 as varchar(11)), ''),
         isnull(cast(T.COL29 as varchar(11)), ''),
         isnull(cast(T.COL30 as varchar(11)), ''),
         isnull(cast(T.COL31 as varchar(11)), ''),
         isnull(cast(T.COL32 as varchar(11)), ''))
       as varbinary(8000))
from dbo.TABLE_OF_32_INTS as T
option (maxdop 1)

2
Cảm ơn vì điều đó. Nó cũng nhanh hơn đối với tôi, nhưng nó có một nhược điểm là nó tạo ra chuỗi nhị phân dài hơn (191 ký tự so với 132 cho dữ liệu mẫu). Chúng tôi chắc chắn sẽ xem xét nó mặc dù.
Joe Obbish

-1

Nếu bạn có thể đảm bảo trước thời hạn rằng bạn không lưu trữ một số int cụ thể, -2,147,483,648thì bạn có thể làm một cái gì đó như:

 SELECT @dummy = 
        coalesce(CAST(COL1 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL2 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL3 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL4 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL5 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL6 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL7 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL8 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL9 AS BINARY(4)),  0x80000000) + 
        coalesce(CAST(COL10 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL11 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL12 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL13 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL14 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL15 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL16 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL17 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL18 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL19 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL20 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL21 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL22 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL23 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL24 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL25 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL26 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL27 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL28 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL29 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL30 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL31 AS BINARY(4)), 0x80000000) + 
        coalesce(CAST(COL32 AS BINARY(4)), 0x80000000) 
    FROM dbo.TABLE_OF_32_INTS

Cảm ơn bạn đã trả lời. Tất cả các giá trị được phép cho các cột INT là có thể.
Joe Obbish
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.