-- Generic checksum API and FNV-1a 64-bit primitives.
SELECT encode(pg_data_checksum('hello'::bytea, 0, 'fnv32'), 'hex') = '4f9f2cab' AS fnv32_ok;
 fnv32_ok 
----------
 t
(1 row)

SELECT encode(pg_data_checksum('hello'::bytea, 0, 'fnv64'), 'hex') = 'a430d84680aabd0b' AS fnv64_ok;
 fnv64_ok 
----------
 t
(1 row)

SELECT pg_checksum_bigint(pg_data_checksum('hello'::bytea, 0, 'fnv64')) = -6615550055289275125 AS bigint_ok;
 bigint_ok 
-----------
 t
(1 row)

SELECT pg_checksum_bigint(pg_data_checksum('hello'::bytea, 0, 'fnv32')) = pg_data_checksum('hello'::bytea, 0) AS legacy_ok;
 legacy_ok 
-----------
 t
(1 row)

SELECT length(pg_data_checksum('hello'::bytea, 0, 'fnv32')) = 4 AND length(pg_data_checksum('hello'::bytea, 0, 'fnv64')) = 8 AS lengths_ok;
 lengths_ok 
------------
 t
(1 row)

SELECT encode(pg_text_checksum('hello', 0, 'fnv64'), 'hex') = encode(pg_data_checksum('hello'::bytea, 0, 'fnv64'), 'hex') AS text_ok;
 text_ok 
---------
 t
(1 row)

-- Logical table/index digests are selectable and stay compatible with the
-- legacy 32-bit wrappers.
CREATE TABLE fnv64_a (id integer PRIMARY KEY, value text);
INSERT INTO fnv64_a SELECT i, 'v' || i FROM generate_series(1, 20) i;
CREATE TABLE fnv64_b (id integer PRIMARY KEY, value text);
INSERT INTO fnv64_b SELECT i, 'v' || i FROM generate_series(20, 1, -1) i;
SELECT length(pg_table_logical_checksum('fnv64_a'::regclass, 'fnv64')) = 8 AS table64_len;
 table64_len 
-------------
 t
(1 row)

SELECT pg_table_logical_checksum('fnv64_a'::regclass, 'fnv64') = pg_table_logical_checksum('fnv64_b'::regclass, 'fnv64') AS table64_order_ok;
 table64_order_ok 
------------------
 t
(1 row)

SELECT length(pg_index_logical_checksum('fnv64_a_pkey'::regclass, 'fnv64')) = 8 AS index64_len;
 index64_len 
-------------
 t
(1 row)

SELECT length(pg_table_physical_checksum('fnv64_a'::regclass, false, 'fnv64')) = 8 AS table_physical64_len;
 table_physical64_len 
----------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_table_physical_checksum('fnv64_a'::regclass, false, 'fnv32')) = pg_table_physical_checksum('fnv64_a'::regclass, false) AS table_physical32_legacy_ok;
 table_physical32_legacy_ok 
----------------------------
 t
(1 row)

SELECT length(pg_index_physical_checksum('fnv64_a_pkey'::regclass, 'fnv64')) = 8 AS index_physical64_len;
 index_physical64_len 
----------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_index_physical_checksum('fnv64_a_pkey'::regclass, 'fnv32')) = pg_index_physical_checksum('fnv64_a_pkey'::regclass) AS index_physical32_legacy_ok;
 index_physical32_legacy_ok 
----------------------------
 t
(1 row)

SELECT length(pg_database_physical_checksum(false, false, 'fnv64')) = 8 AS database_physical64_len;
 database_physical64_len 
-------------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_database_physical_checksum(false, false, 'fnv32')) = pg_database_physical_checksum(false, false) AS database_physical32_legacy_ok;
 database_physical32_legacy_ok 
-------------------------------
 t
(1 row)

SELECT pg_index_logical_checksum('fnv64_a_pkey'::regclass, 'fnv64') = pg_index_logical_checksum('fnv64_b_pkey'::regclass, 'fnv64') AS index64_order_ok;
 index64_order_ok 
------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_table_logical_checksum('fnv64_a'::regclass, 'fnv32')) = pg_table_logical_checksum('fnv64_a'::regclass) AS table32_legacy_ok;
 table32_legacy_ok 
-------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_index_logical_checksum('fnv64_a_pkey'::regclass, 'fnv32')) = pg_index_logical_checksum('fnv64_a_pkey'::regclass) AS index32_legacy_ok;
 index32_legacy_ok 
-------------------
 t
(1 row)

-- Parallel and serial 64-bit paths must agree.
SET pg_integrity_checksums.workers = 0;
SELECT pg_table_physical_checksum('fnv64_a'::regclass, false, 'fnv64') AS tp64_serial,
       pg_table_logical_checksum('fnv64_a'::regclass, 'fnv64') AS tl64_serial,
       pg_index_physical_checksum('fnv64_a_pkey'::regclass, 'fnv64') AS ip64_serial,
       pg_index_logical_checksum('fnv64_a_pkey'::regclass, 'fnv64') AS il64_serial \gset
SET pg_integrity_checksums.workers = 2;
SELECT pg_table_physical_checksum('fnv64_a'::regclass, false, 'fnv64') = :'tp64_serial'::bytea AS table_physical_parallel64,
       pg_table_logical_checksum('fnv64_a'::regclass, 'fnv64') = :'tl64_serial'::bytea AS table_logical_parallel64,
       pg_index_physical_checksum('fnv64_a_pkey'::regclass, 'fnv64') = :'ip64_serial'::bytea AS index_physical_parallel64,
       pg_index_logical_checksum('fnv64_a_pkey'::regclass, 'fnv64') = :'il64_serial'::bytea AS index_logical_parallel64;
 table_physical_parallel64 | table_logical_parallel64 | index_physical_parallel64 | index_logical_parallel64 
---------------------------+--------------------------+---------------------------+--------------------------
 t                         | t                        | t                         | t
(1 row)

SET pg_integrity_checksums.workers = 0;
SELECT pg_database_physical_checksum(false, false, 'fnv64') AS dp64_serial,
       pg_database_logical_checksum(false, true, 'fnv64') AS dl64_serial \gset
SET pg_integrity_checksums.workers = 2;
SELECT pg_database_physical_checksum(false, false, 'fnv64') = :'dp64_serial'::bytea AS database_physical_parallel64,
       pg_database_logical_checksum(false, true, 'fnv64') = :'dl64_serial'::bytea AS database_logical_parallel64;
 database_physical_parallel64 | database_logical_parallel64 
------------------------------+-----------------------------
 t                            | t
(1 row)

SET pg_integrity_checksums.workers = 0;
SET pg_integrity_checksums.workers = 0;
SELECT length(pg_cell_checksum('fnv64_a'::regclass, '(0,1)', 2, 'fnv64')) = 8 AS cell64_len;
 cell64_len 
------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_cell_checksum('fnv64_a'::regclass, '(0,1)', 2, 'fnv32')) = pg_cell_checksum('fnv64_a'::regclass, '(0,1)', 2) AS cell32_legacy_ok;
 cell32_legacy_ok 
------------------
 t
(1 row)

SELECT length(pg_tuple_logical_checksum('fnv64_a'::regclass, '(0,1)', 'fnv64')) = 8 AS tuple64_len;
 tuple64_len 
-------------
 t
(1 row)

SELECT length(pg_tuple_physical_checksum('fnv64_a'::regclass, '(0,1)', false, 'fnv64')) = 8 AS tuple_physical64_len;
 tuple_physical64_len 
----------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_tuple_physical_checksum('fnv64_a'::regclass, '(0,1)', false, 'fnv32')) = pg_tuple_physical_checksum('fnv64_a'::regclass, '(0,1)', false) AS tuple_physical32_legacy_ok;
 tuple_physical32_legacy_ok 
----------------------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_tuple_logical_checksum('fnv64_a'::regclass, '(0,1)', 'fnv32')) = pg_tuple_logical_checksum('fnv64_a'::regclass, '(0,1)') AS tuple32_legacy_ok;
 tuple32_legacy_ok 
-------------------
 t
(1 row)

SELECT length(pg_database_logical_checksum(false, true, 'fnv64')) = 8 AS database64_len;
 database64_len 
----------------
 t
(1 row)

SELECT pg_checksum_bigint(pg_database_logical_checksum(false, true, 'fnv32'), true) = pg_database_logical_checksum(false, true) AS database32_legacy_ok;
 database32_legacy_ok 
----------------------
 t
(1 row)

DROP TABLE fnv64_a, fnv64_b;