Aggregate sql resultset into HashBytes value - sql

Question

Is there an equivalent of
CHECKSUM_AGG(CHECKSUM(*))
for HashBytes?
I know you can do
SELECT
HashBytes('MD5',
CONVERT(VARCHAR,Field1) + '|'
+ CONVERT(VARCHAR,Field2) + '|'
+ CONVERT(VARCHAR,field3) + '|'
)
FROM MyTable
But I am not sure how to aggregate all calculated hashbyte records into a single value inside of SQL.
One reason I would want to do this is to determine if data has changed in the source table since the previous load before moving the data into my system.

Answer 1

You can loop through all records and combine hashes to one
declare #c cursor;
declare #data varchar(max);
declare #hash varchar(400) = '';
set #c = cursor fast_forward for
select cast(SomeINTData as varchar(50)) + SomeTextData
from TFact
where Year = #year
and Month = #month;
open #c
fetch next from #c into #data
while ##FETCH_STATUS = 0 begin
set #hash = HASHBYTES('sha1', #hash + #data)
fetch next from #c into #data
end
select #hash Ha

Answer 2

If you want to check if a given row has changed I strongly recomend you to use a "timestamp" column.
The value is automatically updated by Sql Server in every row modification.
Then if a row is changed, the value will be diferent after modification and you could notice it without implementing logic or querying the whole table.
But if you want to know if at least one row has been updated I recomend you to use:
DECLARE #Tablename sysname = 'MyTable';
SELECT modify_date FROM sys.tables WHERE name = #Tablename;
(If you are using .Net in your business layer it might be interesting for you to take a look on SqlDependency)

Answer 3

You can nest hashbytes, using a varbinary variable to accrue each row's inner hash results for the final outer hash.
My example below takes ~24 seconds against 870k rows on a mid-range Xeon. More columns and lots of null values will increase crunch time.
The Order by clause is essential to guaranteeing repeatable results.
Declare #TableHash varbinary(max) = 0x00;
Select #TableHash =
hashbytes('MD5', #TableHash +
hashbytes('MD5',
isnull(convert(nvarchar(max),Col1_int),'null') +
isnull(convert(nvarchar(max),Col2_int),'null') +
isnull(convert(nvarchar(max),Col3_int),'null') +
isnull(convert(nvarchar(max),Col4_int),'null') +
isnull(convert(nvarchar(max),Col5_nvmax),'null'))
)
From MyTable
Order by Col2_int,Col1_int;
Print convert(varchar(max), #TableHash, 1) +
Case #TableHash When 0x00 Then ' (Table has no data)' Else '' End;
Output:
0x2AF0A66411F23B67D3819AC407D3B8BD

Answer 4

With newer versions of SQL Server, you can use a combination of CONCAT and STRING_AGG to bung everything together, then hash the whole result.
SELECT
HASHBYTES('SHA2_512',
STRING_AGG(
CONCAT(
CAST(Field1 AS varchar(max)), -- at least one max
Field2,
field3
), ''
)
)
FROM MyTable;
Note that MD5 is deprecated, and would probably be at risk of hash collisions even in this case. You should use SHA2_512 or SHA2_256 instead.