From bac93feb9dddfabd8ea23241188ff4d5b5f3ee92 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:43:54 -0800 Subject: [PATCH 01/49] test: failing tests for ordered and nested-validity hashing options (ITL-898) Byte-level tests for spec Section 9 worked examples T1-T5, Phase 1 JSON for every flags value, invariants I1-I8, node-path rejection, streaming batch checks and keyword-only options. Adds the option table only. Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 9 + tests/test_ordered_hashing.py | 679 ++++++++++++++++++++++++++++++++++ 2 files changed, 688 insertions(+) create mode 100644 tests/test_ordered_hashing.py diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 5110c17..609c272 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -25,6 +25,15 @@ def update(self, data: bytes | bytearray, /) -> None: ... VERSION_BYTES = b"\x00\x00\x01" DELIMITER = "/" +# Hashing options (spec Section 9.1): keyword name -> bit of the flags byte. +# This table is the single place that names the options; the keyword arguments of +# the public API must use exactly these names. +_OPTION_FLAGS: dict[str, int] = { + "ordered_columns": 0x01, + "ordered_struct_fields": 0x02, + "nested_validity": 0x04, +} + # --------------------------------------------------------------------------- # Bit-vector helper (LSB-first packing, matching bitvec) diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py new file mode 100644 index 0000000..c06c85f --- /dev/null +++ b/tests/test_ordered_hashing.py @@ -0,0 +1,679 @@ +"""Tests for the v0.5 hashing options (ITL-898). + +Spec: ``nauticalab/starfix docs/byte-layout-spec.md`` Section 9. + +* ``ordered_columns`` (flag 0x01): top-level column order is part of the hash. +* ``ordered_struct_fields`` (flag 0x02): struct field order is part of the hash, at every depth. +* ``nested_validity`` (flag 0x04): nullable nested values record their own validity. + +The worked examples (spec Section 9.9) are checked byte for byte: the expected value is built +here from the exact SHA-256 inputs the spec lists, never from the implementation under test. +Cross-language values are pinned separately by ``tests/test_golden_parity_ordered.py``. +""" + +from __future__ import annotations + +import hashlib +import itertools +import struct + +import pyarrow as pa +import pytest + +from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester + +# Option keyword names. A rename of an option is a one-line change here. +OC = "ordered_columns" +OSF = "ordered_struct_fields" +NV = "nested_validity" + +ALL_FLAGS = range(8) + + +def opts(flags: int) -> dict[str, bool]: + """Keyword arguments for a flags byte (spec Section 9.1).""" + return {name: bool(flags & bit) for name, bit in _OPTION_FLAGS.items()} + + +def tag(flags: int) -> bytes: + """Options tag of spec Section 9.2, written out literally.""" + return bytes.fromhex("0073746172666978 2d6f7074696f6e73 2d7631".replace(" ", "")) + bytes([flags]) + + +def sha(*parts: bytes) -> bytes: + h = hashlib.sha256() + for p in parts: + h.update(p) + return h.digest() + + +def u64(n: int) -> bytes: + return struct.pack(" bytes: + return b"".join(struct.pack(" bytes: + return ArrowDigester.hash_record_batch(batch, **opts(flags), **kw) + + +# ── Spec Section 9.1 / 9.2: option table, tag ───────────────────────── + + +class TestOptionTable: + def test_option_names_and_bits(self): + assert _OPTION_FLAGS == {OC: 0x01, OSF: 0x02, NV: 0x04} + + def test_tag_is_twenty_bytes(self): + t = tag(0x05) + assert len(t) == 20 + assert t[0] == 0x00 + assert t[1:19] == b"starfix-options-v1" + assert t[19] == 0x05 + + +# ── Spec Section 9.9: worked examples, byte level ───────────────────── + + +class TestWorkedExamples: + def test_t1_hash_schema_ordered_columns(self): + schema = pa.schema([ + pa.field("b", pa.int32(), nullable=False), + pa.field("a", pa.utf8(), nullable=True), + ]) + json_ = ( + b'[{"data_type":"Int32","name":"b","nullable":false},' + b'{"data_type":"LargeUtf8","name":"a","nullable":true}]' + ) + expected = V + sha(tag(0x01), json_) + assert ArrowDigester.hash_schema(schema, ordered_columns=True) == expected + + def test_t2_record_batch_ordered_columns(self): + schema = pa.schema([ + pa.field("b", pa.int32(), nullable=False), + pa.field("a", pa.int32(), nullable=False), + ]) + batch = pa.record_batch( + [pa.array([5], pa.int32()), pa.array([6], pa.int32())], schema=schema + ) + schema_digest = sha( + tag(0x01), + b'[{"data_type":"Int32","name":"b","nullable":false},' + b'{"data_type":"Int32","name":"a","nullable":false}]', + ) + expected = V + sha(schema_digest, sha(i32(6)), sha(i32(5))) + assert ArrowDigester.hash_record_batch(batch, ordered_columns=True) == expected + + def test_t3_hash_array_ordered_struct_fields(self): + arr = pa.StructArray.from_arrays( + [pa.array([1], pa.int32()), pa.array([2], pa.int32())], + fields=[pa.field("z", pa.int32(), nullable=False), pa.field("a", pa.int32(), nullable=False)], + ) + expected = V + sha( + tag(0x02), + b'{"Struct":[{"data_type":"Int32","name":"z","nullable":false},' + b'{"data_type":"Int32","name":"a","nullable":false}]}', + sha(i32(2)), + sha(i32(1)), + ) + assert ArrowDigester.hash_array(arr, ordered_struct_fields=True) == expected + + def test_t4_nested_validity_nullable_struct(self): + s = pa.StructArray.from_arrays( + [pa.array([5, None, 1], pa.int32())], + fields=[pa.field("a", pa.int32(), nullable=True)], + mask=pa.array([True, False, False]), # True = null: struct validity [0, 1, 1] + ) + schema = pa.schema([pa.field("s", s.type, nullable=True)]) + batch = pa.record_batch([s], schema=schema) + schema_digest = sha( + tag(0x04), + b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":true}]},' + b'"nullable":true}}', + ) + expected = V + sha( + schema_digest, + u64(3) + b"\x06", # entry "s": validity-only, bits [0,1,1] + u64(3) + b"\x04", # entry "s/a": [1,0,1] AND [0,1,1] = [0,0,1] + sha(i32(1)), # data: only row 2 + ) + assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + + def test_t5_nested_validity_list_of_nullable_list(self): + inner = pa.field("item", pa.int32(), nullable=True) + outer_elem = pa.field("item", pa.list_(inner), nullable=True) + col_type = pa.list_(outer_elem) + schema = pa.schema([pa.field("c", col_type, nullable=False)]) + batch = pa.record_batch([pa.array([[[1], [2]]], type=col_type)], schema=schema) + schema_digest = sha( + tag(0x04), + b'{"c":{"data_type":{"LargeList":{"data_type":{"LargeList":' + b'{"data_type":"Int32","nullable":true}},"nullable":true}},"nullable":false}}', + ) + expected = V + sha( + schema_digest, + # entry "c/": structural entry kept, null_bits = inner-list validity [1,1] + u64(2) + b"\x03", + sha(u64(2)), # outer lengths [2] + # entry "c//": list-leaf, item validity [1,1], inner lengths [1,1], data [1,2] + u64(2) + b"\x03", + sha(u64(1) + u64(1)), + sha(i32(1, 2)), + ) + assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + + +# ── Spec Section 9.3: Phase 1 JSON for every flags value ────────────── + + +_STRUCT_SORTED = ( + b'{"Struct":[{"data_type":"Int32","name":"x","nullable":false},' + b'{"data_type":"Boolean","name":"y","nullable":false}]}' +) +_STRUCT_DECLARED = ( + b'{"Struct":[{"data_type":"Boolean","name":"y","nullable":false},' + b'{"data_type":"Int32","name":"x","nullable":false}]}' +) + + +class TestPhase1Json: + """Spec 9.3 examples, checked as the exact bytes behind ``hash_schema``.""" + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_struct_example_every_flags_value(self, flags): + schema = pa.schema([ + pa.field("s", pa.struct([ + pa.field("y", pa.bool_(), nullable=False), + pa.field("x", pa.int32(), nullable=False), + ]), nullable=False), + ]) + dt = _STRUCT_DECLARED if flags & 0x02 else _STRUCT_SORTED + if flags & 0x01: + json_ = b'[{"data_type":' + dt + b',"name":"s","nullable":false}]' + else: + json_ = b'{"s":{"data_type":' + dt + b',"nullable":false}}' + assert ArrowDigester.hash_schema(schema, **opts(flags)) == V + sha(tag(flags), json_) + + def test_unordered_columns_with_flags_uses_object(self): + schema = pa.schema([ + pa.field("b", pa.int32(), nullable=False), + pa.field("a", pa.utf8(), nullable=True), + ]) + json_ = ( + b'{"a":{"data_type":"LargeUtf8","nullable":true},' + b'"b":{"data_type":"Int32","nullable":false}}' + ) + assert ArrowDigester.hash_schema(schema, nested_validity=True) == V + sha(tag(0x04), json_) + + def test_ordered_struct_fields_inside_list_fixed_size_list_and_dictionary(self): + st = pa.struct([pa.field("z", pa.int8(), nullable=False), pa.field("a", pa.int8(), nullable=False)]) + schema = pa.schema([ + pa.field("d", pa.dictionary(pa.int32(), pa.utf8()), nullable=True), + pa.field("f", pa.list_(pa.field("item", st, nullable=True), 2), nullable=True), + pa.field("l", pa.list_(pa.field("item", st, nullable=False)), nullable=False), + ]) + za = ( + b'{"Struct":[{"data_type":"Int8","name":"z","nullable":false},' + b'{"data_type":"Int8","name":"a","nullable":false}]}' + ) + json_ = ( + b'{"d":{"data_type":"LargeUtf8","nullable":true},' + b'"f":{"data_type":{"FixedSizeList":[{"data_type":' + za + b',"nullable":true},2]},"nullable":true},' + b'"l":{"data_type":{"LargeList":{"data_type":' + za + b',"nullable":false}},"nullable":false}}' + ) + assert ArrowDigester.hash_schema(schema, ordered_struct_fields=True) == V + sha(tag(0x02), json_) + + def test_non_ascii_names_are_raw_utf8(self): + """serde_json writes non-ASCII as raw UTF-8 (no \\u escapes).""" + st = pa.struct([pa.field("é", pa.int8(), nullable=False)]) + schema = pa.schema([pa.field("ü", st, nullable=False)]) + json_ = '[{"data_type":{"Struct":[{"data_type":"Int8","name":"é","nullable":false}]},"name":"ü","nullable":false}]' + assert ArrowDigester.hash_schema(schema, ordered_columns=True) == V + sha(tag(0x01), json_.encode()) + + def test_hash_array_type_json_non_ascii_raw_utf8(self): + arr = pa.StructArray.from_arrays( + [pa.array([1], pa.int8())], fields=[pa.field("é", pa.int8(), nullable=False)] + ) + json_ = '{"Struct":[{"data_type":"Int8","name":"é","nullable":false}]}'.encode() + expected = V + sha(tag(0x02), json_, sha(b"\x01")) + assert ArrowDigester.hash_array(arr, ordered_struct_fields=True) == expected + + def test_metadata_phase2_appended_after_tagged_phase1(self): + schema = pa.schema( + [pa.field("b", pa.int32(), nullable=False, metadata={"unit": "kg"})], + metadata={"version": "2"}, + ) + phase1 = b'[{"data_type":"Int32","name":"b","nullable":false}]' + phase2 = b'{"fields":{"b":{"unit":"kg"}},"schema":{"version":"2"}}' + got = ArrowDigester.hash_schema(schema, ordered_columns=True, include_metadata=True) + assert got == V + sha(tag(0x01), phase1, phase2) + + +# ── Spec Section 9.8: invariants ─────────────────────────────────────── + + +def _struct_xy(order: str, nullable_struct: bool = False) -> pa.StructArray: + vals = {"x": pa.array([1, 2], pa.int32()), "y": pa.array([True, False])} + return pa.StructArray.from_arrays( + [vals[n] for n in order], + fields=[pa.field(n, vals[n].type, nullable=False) for n in order], + ) + + +def _batch(cols: dict[str, pa.Array], nullable: bool = False) -> pa.RecordBatch: + schema = pa.schema([pa.field(n, a.type, nullable=nullable) for n, a in cols.items()]) + return pa.record_batch(list(cols.values()), schema=schema) + + +class TestInvariants: + def test_i1_all_off_equals_default(self): + b = _batch({"b": pa.array([1, None], pa.int32()), "s": _struct_xy("yx")}, nullable=True) + assert ArrowDigester.hash_record_batch(b, **opts(0)) == ArrowDigester.hash_record_batch(b) + assert ArrowDigester.hash_schema(b.schema, **opts(0)) == ArrowDigester.hash_schema(b.schema) + assert ArrowDigester.hash_array(b.column(1), **opts(0)) == ArrowDigester.hash_array(b.column(1)) + t = pa.Table.from_batches([b, b]) + assert ArrowDigester.hash_table(t, **opts(0)) == ArrowDigester.hash_table(t) + + @pytest.mark.parametrize("kind", ["schema", "batch", "array", "one_column_table"]) + def test_i2_all_flags_values_distinct(self, kind): + b = _batch({"b": pa.array([1, None], pa.int32()), "s": _struct_xy("yx")}, nullable=True) + if kind == "schema": + hashes = [ArrowDigester.hash_schema(b.schema, **opts(f)) for f in ALL_FLAGS] + elif kind == "batch": + hashes = [batch_hash(b, f) for f in ALL_FLAGS] + elif kind == "array": + hashes = [ArrowDigester.hash_array(b.column(1), **opts(f)) for f in ALL_FLAGS] + else: + t = pa.table({"a": pa.array([1, 2], pa.int64())}) + hashes = [ArrowDigester.hash_table(t, **opts(f)) for f in ALL_FLAGS] + assert len(set(hashes)) == 8 + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i3_column_permutation(self, flags): + a, b = pa.array([1, 2], pa.int32()), pa.array(["x", None]) + h_ab = batch_hash(_batch({"a": a, "b": b}, nullable=True), flags) + h_ba = batch_hash(_batch({"b": b, "a": a}, nullable=True), flags) + s_ab = ArrowDigester.hash_schema(_batch({"a": a, "b": b}).schema, **opts(flags)) + s_ba = ArrowDigester.hash_schema(_batch({"b": b, "a": a}).schema, **opts(flags)) + if flags & 0x01: + assert h_ab != h_ba and s_ab != s_ba + else: + assert h_ab == h_ba and s_ab == s_ba + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i4_struct_field_permutation_depth_1(self, flags): + h_xy = batch_hash(_batch({"s": _struct_xy("xy")}), flags) + h_yx = batch_hash(_batch({"s": _struct_xy("yx")}), flags) + a_xy = ArrowDigester.hash_array(_struct_xy("xy"), **opts(flags)) + a_yx = ArrowDigester.hash_array(_struct_xy("yx"), **opts(flags)) + if flags & 0x02: + assert h_xy != h_yx and a_xy != a_yx + else: + assert h_xy == h_yx and a_xy == a_yx + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i4_struct_field_permutation_nested_and_in_list(self, flags): + def nested(order): + inner = _struct_xy(order) + return pa.StructArray.from_arrays( + [pa.array([7, 8], pa.int64()), inner], + fields=[pa.field("k", pa.int64(), nullable=False), pa.field("p", inner.type, nullable=False)], + ) + + def in_list(order): + inner = _struct_xy(order) + return pa.LargeListArray.from_arrays(pa.array([0, 1, 2], pa.int64()), inner) + + for make in (nested, in_list): + h1 = batch_hash(_batch({"c": make("xy")}), flags) + h2 = batch_hash(_batch({"c": make("yx")}), flags) + assert (h1 != h2) == bool(flags & 0x02), make.__name__ + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i5_physical_equivalence(self, flags): + pairs = [ + (pa.array(["a", None, "c"], pa.utf8()), pa.array(["a", None, "c"], pa.large_utf8())), + (pa.array([b"a", None], pa.binary()), pa.array([b"a", None], pa.large_binary())), + (pa.array([[1], None, [2, 3]], pa.list_(pa.int32())), pa.array([[1], None, [2, 3]], pa.large_list(pa.int32()))), + (pa.array(["a", "b", "a"]).dictionary_encode(), pa.array(["a", "b", "a"], pa.large_utf8())), + ] + for small, large in pairs: + assert ArrowDigester.hash_array(small, **opts(flags)) == ArrowDigester.hash_array(large, **opts(flags)) + assert batch_hash(_batch({"c": small}, nullable=True), flags) == batch_hash( + _batch({"c": large}, nullable=True), flags + ) + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i6_batch_split_independence(self, flags): + s = pa.StructArray.from_arrays( + [pa.array([1, None, 3, 4], pa.int32()), pa.array(["a", "b", None, "d"])], + fields=[pa.field("z", pa.int32(), nullable=True), pa.field("a", pa.utf8(), nullable=True)], + mask=pa.array([False, True, False, False]), + ) + lst = pa.array([[[1], None], None, [[2, None]], []], pa.list_(pa.list_(pa.int32()))) + whole = _batch({"s": s, "l": lst}, nullable=True) + d = ArrowDigester(whole.schema, **opts(flags)) + d.update(whole.slice(0, 1)) + d.update(whole.slice(1, 2)) + d.update(whole.slice(3, 1)) + assert d.finalize() == batch_hash(whole, flags) + table = pa.Table.from_batches([whole.slice(0, 3), whole.slice(3, 1)]) + assert ArrowDigester.hash_table(table, **opts(flags)) == batch_hash(whole, flags) + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i7_empty_metadata_invariant(self, flags): + b = _batch({"b": pa.array([1], pa.int32()), "s": _struct_xy("yx").slice(0, 1)}) + assert ArrowDigester.hash_schema(b.schema, include_metadata=True, **opts(flags)) == ( + ArrowDigester.hash_schema(b.schema, include_metadata=False, **opts(flags)) + ) + assert batch_hash(b, flags, include_metadata=True) == batch_hash(b, flags, include_metadata=False) + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_metadata_still_counts_with_flags(self, flags): + plain = pa.schema([pa.field("a", pa.int32())]) + meta = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) + assert ArrowDigester.hash_schema(plain, include_metadata=True, **opts(flags)) != ( + ArrowDigester.hash_schema(meta, include_metadata=True, **opts(flags)) + ) + + +# ── Spec Section 9.5: the four losses closed by nested_validity (I8) ── + + +def _nv_pairs(): + """Pairs of record batches that collide in the default layout (spec 9.5).""" + a_null = pa.field("a", pa.int32(), nullable=True) + + def s_col(child, mask, field=a_null): + return pa.StructArray.from_arrays([child], fields=[field], mask=pa.array(mask)) + + # 1. null struct vs struct whose fields are all null + p1 = ( + _batch({"s": s_col(pa.array([None, None], pa.int32()), [True, False])}, nullable=True), + _batch({"s": s_col(pa.array([None, None], pa.int32()), [False, False])}, nullable=True), + ) + # 2. nullable struct, non-nullable descendant: null rows vanish (3 rows vs 2 rows) + a_req = pa.field("a", pa.int32(), nullable=False) + p2 = ( + _batch({"s": s_col(pa.array([1, 9, 3], pa.int32()), [False, True, False], a_req)}, nullable=True), + _batch({"s": s_col(pa.array([1, 3], pa.int32()), [False, False], a_req)}, nullable=True), + ) + # 3. List>: outer list lengths lost + lt = pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=True)) + p3 = ( + _batch({"c": pa.array([[[1], [2]]], type=lt)}), + _batch({"c": pa.array([[[1]], [[2]]], type=lt)}), + ) + # 4. List: null element vs element with all-null fields + st = pa.struct([a_null]) + ls = pa.list_(pa.field("item", st, nullable=True)) + p4 = ( + _batch({"c": pa.array([[None]], type=ls)}), + _batch({"c": pa.array([[{"a": None}]], type=ls)}), + ) + return {"null_struct": p1, "vanishing_rows": p2, "list_of_nullable_list": p3, "list_of_nullable_struct": p4} + + +class TestNestedValidity: + @pytest.mark.parametrize("case", list(_nv_pairs())) + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_i8_losses(self, case, flags): + left, right = _nv_pairs()[case] + equal = batch_hash(left, flags) == batch_hash(right, flags) + assert equal == (not flags & 0x04) + + def test_hash_array_nullable_struct_root_entry(self): + """A nullable struct array passed to hash_array gets a validity-only entry at "".""" + arr = pa.StructArray.from_arrays( + [pa.array([1, 2], pa.int32())], + fields=[pa.field("a", pa.int32(), nullable=False)], + mask=pa.array([False, True]), + ) + type_json = b'{"Struct":[{"data_type":"Int32","name":"a","nullable":false}]}' + expected = V + sha( + tag(0x04), + type_json, + u64(2) + b"\x01", # entry "": struct validity [1,0] + sha(i32(1)), # entry "a": non-nullable child, only the valid row + ) + assert ArrowDigester.hash_array(arr, nested_validity=True) == expected + + def test_nested_nullable_structs_record_combined_validity(self): + """Inner nullable struct bits = own AND ancestor (spec 9.5 traversal).""" + inner = pa.StructArray.from_arrays( + [pa.array([1, 2, 3], pa.int32())], + fields=[pa.field("a", pa.int32(), nullable=False)], + mask=pa.array([False, False, True]), # inner validity [1,1,0] + ) + outer = pa.StructArray.from_arrays( + [inner], + fields=[pa.field("t", inner.type, nullable=True)], + mask=pa.array([True, False, False]), # outer validity [0,1,1] + ) + batch = _batch({"s": outer}, nullable=True) + schema_digest = sha( + tag(0x04), + b'{"s":{"data_type":{"Struct":[{"data_type":{"Struct":[{"data_type":"Int32","name":"a",' + b'"nullable":false}]},"name":"t","nullable":true}]},"nullable":true}}', + ) + expected = V + sha( + schema_digest, + u64(3) + b"\x06", # "s": [0,1,1] + u64(3) + b"\x02", # "s/t": [1,1,0] AND [0,1,1] = [0,1,0] + sha(i32(2)), # "s/t/a": only row 1 + ) + assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + + def test_non_nullable_struct_gets_no_entry(self): + s = pa.StructArray.from_arrays( + [pa.array([1, 2], pa.int32()), pa.array([3, 4], pa.int32())], + fields=[pa.field("x", pa.int32(), nullable=False), pa.field("z", pa.int32(), nullable=False)], + ) + batch = _batch({"s": s}, nullable=False) + schema_digest = sha( + tag(0x04), + b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"x","nullable":false},' + b'{"data_type":"Int32","name":"z","nullable":false}]},"nullable":false}}', + ) + # no "s" entry: only "s/x" and "s/z" + expected = V + sha(schema_digest, sha(i32(1, 2)), sha(i32(3, 4))) + assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + + +# ── Spec Section 9.6: rejected schemas (ValueError) ─────────────────── + + +def _rejected_schemas(): + i32_ = pa.int32() + return { + "duplicate_columns": pa.schema([pa.field("a", i32_), pa.field("a", pa.utf8())]), + "duplicate_struct_children": pa.schema([ + pa.field("s", pa.struct([pa.field("x", i32_), pa.field("x", i32_)])), + ]), + "duplicate_children_nested_in_list": pa.schema([ + pa.field("l", pa.list_(pa.struct([pa.field("p", pa.struct([pa.field("q", i32_), pa.field("q", i32_)]))]))), + ]), + "slash_aliases_struct_child": pa.schema([ + pa.field("a/b", i32_), + pa.field("a", pa.struct([pa.field("b", i32_)])), + ]), + "slash_aliases_list_element": pa.schema([ + pa.field("x", pa.list_(i32_)), + pa.field("x/", i32_), + ]), + "slash_aliases_fixed_size_list_element": pa.schema([ + pa.field("x", pa.list_(i32_, 2)), + pa.field("x/", i32_), + ]), + "duplicate_children_in_large_list_struct": pa.schema([ + pa.field("l", pa.large_list(pa.struct([pa.field("x", i32_), pa.field("x", i32_)]))), + ]), + } + + +class TestRejection: + @pytest.mark.parametrize("case", list(_rejected_schemas())) + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_hash_schema_rejects(self, case, flags): + schema = _rejected_schemas()[case] + with pytest.raises(ValueError): + ArrowDigester.hash_schema(schema, **opts(flags)) + with pytest.raises(ValueError): + ArrowDigester(schema, **opts(flags)) + + @pytest.mark.parametrize("case", list(_rejected_schemas())) + def test_default_mode_does_not_reject_schema(self, case): + ArrowDigester.hash_schema(_rejected_schemas()[case]) + ArrowDigester(_rejected_schemas()[case]) + + def test_hash_record_batch_rejects_duplicate_columns(self): + batch = pa.record_batch([pa.array([1]), pa.array([2])], names=["a", "a"]) + ArrowDigester.hash_record_batch(batch) # default: accepted + with pytest.raises(ValueError): + ArrowDigester.hash_record_batch(batch, ordered_columns=True) + + def test_hash_table_rejects_duplicate_columns(self): + table = pa.table([pa.array([1]), pa.array([2])], names=["a", "a"]) + with pytest.raises(ValueError): + ArrowDigester.hash_table(table, nested_validity=True) + + def test_hash_array_rejects_duplicate_children(self): + arr = pa.StructArray.from_arrays( + [pa.array([1]), pa.array([2])], + fields=[pa.field("x", pa.int64()), pa.field("x", pa.int64())], + ) + ArrowDigester.hash_array(arr) # default: accepted + with pytest.raises(ValueError): + ArrowDigester.hash_array(arr, ordered_struct_fields=True) + + def test_hash_array_rejects_child_named_empty_string(self): + """claim("") for the root, then join("", "") == "" for the child (spec 9.6).""" + arr = pa.StructArray.from_arrays([pa.array([1])], fields=[pa.field("", pa.int64())]) + with pytest.raises(ValueError): + ArrowDigester.hash_array(arr, nested_validity=True) + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_slash_that_aliases_nothing_is_accepted(self, flags): + schema = pa.schema([pa.field("km/h", pa.float64()), pa.field("km", pa.int32())]) + ArrowDigester.hash_schema(schema, **opts(flags)) + batch = pa.record_batch([pa.array([1.5]), pa.array([1], pa.int32())], schema=schema) + ArrowDigester.hash_record_batch(batch, **opts(flags)) + + def test_update_rejects_batch_with_rejected_schema(self): + good = pa.schema([pa.field("a", pa.int64())]) + d = ArrowDigester(good, ordered_columns=True) + bad = pa.record_batch([pa.array([1]), pa.array([2])], names=["a", "a"]) + with pytest.raises(ValueError): + d.update(bad) + + +# ── Spec Section 9.7: streaming ─────────────────────────────────────── + + +class TestStreaming: + def _schemas(self): + ab = pa.schema([pa.field("a", pa.int32()), pa.field("b", pa.utf8())]) + ba = pa.schema([pa.field("b", pa.utf8()), pa.field("a", pa.int32())]) + return ab, ba + + def _batch(self, schema): + cols = {"a": pa.array([1, 2], pa.int32()), "b": pa.array(["x", None])} + return pa.record_batch([cols[f.name] for f in schema], schema=schema) + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f & 0x01]) + def test_reordered_columns_rejected_with_ordered_columns(self, flags): + ab, ba = self._schemas() + d = ArrowDigester(ab, **opts(flags)) + d.update(self._batch(ab)) + with pytest.raises(ValueError, match="does not match"): + d.update(self._batch(ba)) + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if not f & 0x01]) + def test_reordered_columns_accepted_without_ordered_columns(self, flags): + ab, ba = self._schemas() + d = ArrowDigester(ab, **opts(flags)) + d.update(self._batch(ab)) + d.update(self._batch(ba)) + ref = ArrowDigester(ab, **opts(flags)) + ref.update(self._batch(ab)) + ref.update(self._batch(ab)) + assert d.finalize() == ref.finalize() + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_reordered_struct_fields(self, flags): + xy, yx = _batch({"s": _struct_xy("xy")}), _batch({"s": _struct_xy("yx")}) + d = ArrowDigester(xy.schema, **opts(flags)) + d.update(xy) + if flags & 0x02: + with pytest.raises(ValueError, match="does not match"): + d.update(yx) + else: + d.update(yx) + ref = ArrowDigester(xy.schema, **opts(flags)) + ref.update(xy) + ref.update(xy) + assert d.finalize() == ref.finalize() + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_different_type_rejected(self, flags): + ab, _ = self._schemas() + d = ArrowDigester(ab, **opts(flags)) + other = pa.record_batch([pa.array([1, 2], pa.int64()), pa.array(["x", None])], names=["a", "b"]) + with pytest.raises(ValueError, match="does not match"): + d.update(other) + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_equivalent_physical_types_accepted(self, flags): + ab, _ = self._schemas() + d = ArrowDigester(ab, **opts(flags)) + large = pa.record_batch( + [pa.array([1, 2], pa.int32()), pa.array(["x", None], pa.large_utf8())], + schema=pa.schema([pa.field("a", pa.int32()), pa.field("b", pa.large_utf8())]), + ) + d.update(large) + assert d.finalize() == batch_hash(self._batch(ab), flags) + + +# ── API shape: keyword-only options with the Rust names ─────────────── + + +class TestKeywordOnly: + def test_constructor(self): + schema = pa.schema([pa.field("a", pa.int32())]) + with pytest.raises(TypeError): + ArrowDigester(schema, False, True) # type: ignore[misc] + ArrowDigester(schema, include_metadata=False, ordered_columns=True, ordered_struct_fields=True, nested_validity=True) + + def test_static_entry_points(self): + schema = pa.schema([pa.field("a", pa.int32())]) + batch = pa.record_batch([pa.array([1], pa.int32())], schema=schema) + table = pa.Table.from_batches([batch]) + arr = batch.column(0) + with pytest.raises(TypeError): + ArrowDigester.hash_schema(schema, False, True) # type: ignore[misc] + with pytest.raises(TypeError): + ArrowDigester.hash_record_batch(batch, False, True) # type: ignore[misc] + with pytest.raises(TypeError): + ArrowDigester.hash_table(table, False, True) # type: ignore[misc] + with pytest.raises(TypeError): + ArrowDigester.hash_array(arr, True) # type: ignore[misc] + for name in _OPTION_FLAGS: + ArrowDigester.hash_schema(schema, **{name: True}) + ArrowDigester.hash_record_batch(batch, **{name: True}) + ArrowDigester.hash_table(table, **{name: True}) + ArrowDigester.hash_array(arr, **{name: True}) + + def test_hash_array_has_no_include_metadata(self): + with pytest.raises(TypeError): + ArrowDigester.hash_array(pa.array([1]), include_metadata=True) # type: ignore[call-arg] + + def test_combinations_are_independent_switches(self): + """All 8 combinations are accepted and each is reachable by keywords alone.""" + schema = pa.schema([pa.field("a", pa.int32())]) + for bits in itertools.product([False, True], repeat=3): + ArrowDigester.hash_schema(schema, **dict(zip((OC, OSF, NV), bits))) From 2297a25bed6fea4bfdac01f80a84ed617676c754 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:46:07 -0800 Subject: [PATCH 02/49] feat: ordered_columns, ordered_struct_fields and nested_validity options (ITL-898) Implements spec Section 9 of the starfix byte layout: options tag, flags-aware Phase 1 / hash_array type JSON, nested validity entries, node-path rejection and the per-batch schema check when streaming. With all options off every code path and output is unchanged. Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 446 ++++++++++++++++++++++++++++++---- 1 file changed, 397 insertions(+), 49 deletions(-) diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 609c272..0c85aba 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -34,6 +34,29 @@ def update(self, data: bytes | bytearray, /) -> None: ... "nested_validity": 0x04, } +# Options tag prefix (spec Section 9.2); the flags byte is appended. +_OPTIONS_TAG_PREFIX = b"\x00starfix-options-v1" + +_ORDERED_COLUMNS = _OPTION_FLAGS["ordered_columns"] +_ORDERED_STRUCT_FIELDS = _OPTION_FLAGS["ordered_struct_fields"] +_NESTED_VALIDITY = _OPTION_FLAGS["nested_validity"] + +_SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" + + +def _flags(ordered_columns: bool, ordered_struct_fields: bool, nested_validity: bool) -> int: + """Build the flags byte of spec Section 9.1 from the option values.""" + return ( + (_ORDERED_COLUMNS if ordered_columns else 0) + | (_ORDERED_STRUCT_FIELDS if ordered_struct_fields else 0) + | (_NESTED_VALIDITY if nested_validity else 0) + ) + + +def _options_tag(flags: int) -> bytes: + """Options tag (spec Section 9.2): 0x00 || "starfix-options-v1" || flags (20 bytes).""" + return _OPTIONS_TAG_PREFIX + bytes([flags]) + # --------------------------------------------------------------------------- # Bit-vector helper (LSB-first packing, matching bitvec) @@ -75,31 +98,35 @@ def raw_bytes(self) -> bytes: # Schema / DataType serialization (spec Section 2) # --------------------------------------------------------------------------- -def _data_type_to_value(dt: pa.DataType) -> object: +def _data_type_to_value(dt: pa.DataType, ordered_struct_fields: bool = False) -> object: """Convert a pyarrow DataType to the JSON-compatible value that matches the canonical form described in spec Section 2.1. Types are normalized: Utf8→LargeUtf8, Binary→LargeBinary, List→LargeList, - Dictionary→value_type. Struct fields are sorted alphabetically. + Dictionary→value_type. Struct fields are sorted alphabetically, or kept in + declaration order when ``ordered_struct_fields`` is set (spec Section 9.3), + at every depth. """ import pyarrow as pa + osf = ordered_struct_fields # Normalize: Dictionary → recurse on value type if pa.types.is_dictionary(dt): - return _data_type_to_value(dt.value_type) + return _data_type_to_value(dt.value_type, osf) if pa.types.is_struct(dt): - # Sort struct fields alphabetically by name fields = [dt.field(i) for i in range(dt.num_fields)] - fields.sort(key=lambda f: f.name) - fields_json = [_inner_field_to_value(f) for f in fields] + if not osf: + # Sort struct fields alphabetically by name + fields.sort(key=lambda f: f.name) + fields_json = [_inner_field_to_value(f, osf) for f in fields] return {"Struct": fields_json} if pa.types.is_list(dt) or pa.types.is_large_list(dt): - return {"LargeList": _element_type_to_value(dt.value_field)} + return {"LargeList": _element_type_to_value(dt.value_field, osf)} if pa.types.is_fixed_size_list(dt): - return {"FixedSizeList": [_element_type_to_value(dt.value_field), dt.list_size]} + return {"FixedSizeList": [_element_type_to_value(dt.value_field, osf), dt.list_size]} if pa.types.is_map(dt): - return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries")), False]} + return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries"), osf), False]} # Primitive / leaf types – must match Arrow-Rust serde return _primitive_data_type_string(dt) @@ -166,22 +193,22 @@ def _primitive_data_type_string(dt: pa.DataType) -> object: raise NotImplementedError(f"Unsupported data type: {dt}") -def _inner_field_to_value(field: pa.Field) -> dict: +def _inner_field_to_value(field: pa.Field, ordered_struct_fields: bool = False) -> dict: """Convert a field to JSON with name, data_type, and nullable.""" return { "name": field.name, - "data_type": _data_type_to_value(field.type), + "data_type": _data_type_to_value(field.type, ordered_struct_fields), "nullable": field.nullable, } -def _element_type_to_value(field: pa.Field) -> dict: +def _element_type_to_value(field: pa.Field, ordered_struct_fields: bool = False) -> dict: """Convert a container element field to JSON with only data_type and nullable (no name). Used for list and fixed-size list element types, matching Rust ``element_type_to_value``. """ return { - "data_type": _data_type_to_value(field.type), + "data_type": _data_type_to_value(field.type, ordered_struct_fields), "nullable": field.nullable, } @@ -209,6 +236,98 @@ def _serialized_schema(schema: pa.Schema) -> str: return json.dumps(sorted_fields, separators=(",", ":"), ensure_ascii=False) +def _phase1_json(schema: pa.Schema, flags: int) -> str: + """Phase 1 canonical schema JSON for a flags byte (spec Sections 2.1 and 9.3). + + ``flags == 0`` is exactly the default serialization (Section 2.1). + """ + if flags == 0: + return _serialized_schema(schema) + osf = bool(flags & _ORDERED_STRUCT_FIELDS) + fields = [schema.field(i) for i in range(len(schema))] + if flags & _ORDERED_COLUMNS: + # Top level is an array of struct-child-form objects, in schema order. + doc: object = [_sort_json_value(_inner_field_to_value(f, osf)) for f in fields] + else: + doc = OrderedDict(sorted( + (f.name, _sort_json_value({ + "data_type": _data_type_to_value(f.type, osf), + "nullable": f.nullable, + })) + for f in fields + )) + return json.dumps(doc, separators=(",", ":"), ensure_ascii=False) + + +def _type_json(data_type: pa.DataType, flags: int) -> str: + """``hash_array`` canonical type JSON (spec Sections 6 and 9.4). + + ``flags == 0`` keeps the historical serialization byte for byte. With any + option on, non-ASCII characters are written as raw UTF-8 (as serde_json does). + """ + value = _sort_json_value(_data_type_to_value(data_type, bool(flags & _ORDERED_STRUCT_FIELDS))) + if flags == 0: + return json.dumps(value, separators=(",", ":")) + return json.dumps(value, separators=(",", ":"), ensure_ascii=False) + + +# --------------------------------------------------------------------------- +# Node-path rejection (spec Section 9.6, any option on) +# --------------------------------------------------------------------------- + +def _join(parent: str, name: str) -> str: + return f"{parent}{DELIMITER}{name}" if parent else name + + +def _claim(seen: set[str], path: str) -> None: + if path in seen: + raise ValueError( + f"Ambiguous node path {path!r}: two schema nodes share one path " + "(duplicate names, or a name containing '/' that aliases another node); " + "rejected when any hashing option is on" + ) + seen.add(path) + + +def _walk_node_paths(data_type: pa.DataType, path: str, seen: set[str]) -> None: + import pyarrow as pa + + t = data_type + while pa.types.is_dictionary(t): + t = t.value_type + if pa.types.is_struct(t): + for i in range(t.num_fields): + child = t.field(i) + child_path = _join(path, child.name) + _claim(seen, child_path) + _walk_node_paths(child.type, child_path, seen) + elif pa.types.is_map(t): + # The element of a map is its entries struct (key, value). + element_path = f"{path}{DELIMITER}" + _claim(seen, element_path) + _walk_node_paths(pa.struct([t.key_field, t.item_field]), element_path, seen) + elif pa.types.is_list(t) or pa.types.is_large_list(t) or pa.types.is_fixed_size_list(t): + element_path = f"{path}{DELIMITER}" + _claim(seen, element_path) + _walk_node_paths(t.value_field.type, element_path, seen) + + +def _check_schema_node_paths(schema: pa.Schema) -> None: + """Raise ``ValueError`` if two nodes of ``schema`` share a node path (spec 9.6).""" + seen: set[str] = set() + for i in range(len(schema)): + field = schema.field(i) + _claim(seen, field.name) + _walk_node_paths(field.type, field.name, seen) + + +def _check_type_node_paths(data_type: pa.DataType) -> None: + """Raise ``ValueError`` if two nodes of an array type share a node path (spec 9.6).""" + seen: set[str] = set() + _claim(seen, "") + _walk_node_paths(data_type, "", seen) + + # --------------------------------------------------------------------------- # Metadata helpers (Phase 2 schema hashing — PLT-1734) # --------------------------------------------------------------------------- @@ -300,9 +419,32 @@ def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema) -> None: hasher.update(json.dumps(meta_doc, separators=(",", ":"), ensure_ascii=False).encode()) -def _hash_schema(schema: pa.Schema, include_metadata: bool = False) -> bytes: +class _BytesCollector: + """A ``_Hasher`` that records its input (used to compare Phase 2 documents).""" + + def __init__(self) -> None: + self.data = bytearray() + + def update(self, data: bytes | bytearray, /) -> None: + self.data += data + + +def _schema_key(schema: pa.Schema, include_metadata: bool, flags: int) -> tuple[str, bytes]: + """Everything a schema contributes to the schema digest (spec 9.7 check key).""" + phase2 = _BytesCollector() + if include_metadata: + _update_metadata_hash(phase2, schema) + return _phase1_json(schema, flags), bytes(phase2.data) + + +def _hash_schema(schema: pa.Schema, include_metadata: bool = False, flags: int = 0) -> bytes: h = hashlib.sha256() - h.update(_serialized_schema(schema).encode()) + if flags: + # Spec Section 9.2: tag, Phase 1 under flags, then Phase 2 unchanged. + h.update(_options_tag(flags)) + h.update(_phase1_json(schema, flags).encode()) + else: + h.update(_serialized_schema(schema).encode()) if include_metadata: _update_metadata_hash(h, schema) return h.digest() @@ -346,6 +488,7 @@ def _extract_type_entries( nullable: bool, path: str, out: dict[str, tuple], + nested_validity: bool = False, ) -> None: """Recursively decompose a data type into BTreeMap entries. @@ -353,22 +496,34 @@ def _extract_type_entries( - Structs are transparent — no entry, recurse into sorted children - Lists create validity-only + structural/data entries - Leaves create data entries + + With ``nested_validity`` (spec Section 9.5) a nullable struct gets a + validity-only entry, and a nullable struct or list that is a list element + records its validity in the list's element entry (``reuse``) instead of + replacing it. """ import pyarrow as pa canonical = _normalize_data_type(data_type) + nv = nested_validity + # True only for a nullable list element: the list has just created its + # element entry at `path` (spec Section 9.5). + reuse = nv and nullable and path in out if pa.types.is_struct(canonical): - # Struct is transparent — no entry for the struct itself. + # Struct is transparent — no entry for the struct itself (default). + if nv and nullable and not reuse: + out[path] = _new_validity_only() # Recurse into children sorted alphabetically (spec Section 3.5). children = [canonical.field(i) for i in range(canonical.num_fields)] children.sort(key=lambda f: f.name) for child in children: child_path = f"{path}{DELIMITER}{child.name}" if path else child.name - _extract_type_entries(child.type, child.nullable, child_path, out) + _extract_type_entries(child.type, child.nullable, child_path, out, nv) elif pa.types.is_large_list(canonical) or pa.types.is_list(canonical): - # Nullable list: validity-only entry at `path` (spec Section 3.4) - if nullable: + # Nullable list: validity-only entry at `path` (spec Section 3.4). + # Default: this REPLACES an existing list-element entry. + if nullable and not reuse: out[path] = _new_validity_only() # List level: entry at path + "/" (spec Section 3.4) @@ -379,11 +534,11 @@ def _extract_type_entries( if pa.types.is_struct(inner_canonical): # List: structural-only at list_path, struct children get own entries out[list_path] = _new_structural_only(inner_field.nullable) - _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out) + _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out, nv) elif pa.types.is_large_list(inner_canonical) or pa.types.is_list(inner_canonical): # List: structural-only, recurse into inner list out[list_path] = _new_structural_only(inner_field.nullable) - _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out) + _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out, nv) else: # List: list-leaf entry with both structural + data out[list_path] = _new_list_leaf(inner_field.nullable) @@ -393,10 +548,12 @@ def _extract_type_entries( out[path] = _new_data_only(nullable) -def _extract_fields(field: pa.Field, parent: str, out: dict[str, tuple]) -> None: +def _extract_fields( + field: pa.Field, parent: str, out: dict[str, tuple], nested_validity: bool = False +) -> None: """Extract BTreeMap entries from a schema field (record-batch path).""" full_name = f"{parent}{DELIMITER}{field.name}" if parent else field.name - _extract_type_entries(field.type, field.nullable, full_name, out) + _extract_type_entries(field.type, field.nullable, full_name, out, nested_validity) # --------------------------------------------------------------------------- @@ -482,7 +639,7 @@ def _get_validity_list(array): return [array[i].is_valid for i in range(len(array))] -def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, fields): +def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, fields, nested_validity=False): """Top-down recursive traversal that routes data to BTreeMap entries. Parameters: @@ -492,6 +649,7 @@ def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, field path: current BTreeMap key path ancestor_nulls: list of bools from ancestor struct nulls, or None fields: the BTreeMap of entries to populate + nested_validity: spec Section 9.5 (nullable structs record their validity) """ import pyarrow as pa @@ -499,14 +657,16 @@ def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, field canonical = _normalize_data_type(effective_type) if pa.types.is_large_list(canonical): - _traverse_list(effective_array, canonical.value_field, nullable, path, ancestor_nulls, fields) + _traverse_list( + effective_array, canonical.value_field, nullable, path, ancestor_nulls, fields, nested_validity + ) elif pa.types.is_struct(canonical): - _traverse_struct(effective_array, nullable, path, ancestor_nulls, fields) + _traverse_struct(effective_array, nullable, path, ancestor_nulls, fields, nested_validity) else: _traverse_leaf(effective_type, effective_array, path, ancestor_nulls, fields) -def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields): +def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields, nested_validity=False): """Traverse a list array, populating validity/structural/data entries (spec Section 3.4).""" import pyarrow as pa @@ -553,13 +713,16 @@ def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields): list_path, None, # list elements don't inherit ancestor struct nulls fields, + nested_validity, ) -def _traverse_struct(array, nullable, path, ancestor_nulls, fields): +def _traverse_struct(array, nullable, path, ancestor_nulls, fields, nested_validity=False): """Traverse a struct array — struct is transparent (spec Section 3.5). - Struct-level nulls are AND-propagated to all descendant entries. + Struct-level nulls are AND-propagated to all descendant entries. With + ``nested_validity`` a nullable struct also pushes that combined validity + into its own entry's null bits (spec Section 9.5). """ import pyarrow as pa @@ -570,6 +733,15 @@ def _traverse_struct(array, nullable, path, ancestor_nulls, fields): else: combined = ancestor_nulls + if nested_validity and nullable: + entry = fields.get(path) + if entry is not None and entry[0] is not None: + if combined is not None: + for v in combined: + entry[0].push(v) + else: + entry[0].extend_true(len(struct_array)) + # Sort children alphabetically by field name children = [(i, struct_array.type.field(i)) for i in range(struct_array.type.num_fields)] children.sort(key=lambda x: x[1].name) @@ -584,6 +756,7 @@ def _traverse_struct(array, nullable, path, ancestor_nulls, fields): child_path, combined, fields, + nested_validity, ) @@ -769,9 +942,21 @@ class ArrowDigester: them — see the ``include_metadata`` parameter on each method. A schema with no metadata produces the same hash regardless of that flag (empty-metadata invariant). + + Three further keyword-only options, all off by default, are described in + spec Section 9: ``ordered_columns``, ``ordered_struct_fields`` and + ``nested_validity``. With all three off every hash is exactly as before. """ - def __init__(self, schema: pa.Schema, *, include_metadata: bool = False) -> None: + def __init__( + self, + schema: pa.Schema, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + nested_validity: bool = False, + ) -> None: """Initialize a streaming Arrow hasher. Args: @@ -781,21 +966,60 @@ def __init__(self, schema: pa.Schema, *, include_metadata: bool = False) -> None preserving hash format 0.0.1 stability. A schema with no metadata produces the same hash regardless of this flag (empty-metadata invariant). + ordered_columns: When True, the order of the top-level columns is + part of the hash (spec Section 9.3). + ordered_struct_fields: When True, the order of struct fields, at + every nesting depth, is part of the hash (spec Section 9.3). + nested_validity: When True, every nullable struct, and every + nullable list or struct that is a list element, records its + own validity bits (spec Section 9.5). + + With any of these three options on, the hash never equals the hash + taken with a different set of options (in particular with all of them + off), and schemas in which two nodes share a path (duplicate names, or + a name containing ``/`` that aliases another node) are rejected with + ``ValueError`` (spec Section 9.6). + + With any option on, every batch passed to :meth:`update` must have the + same canonical schema as ``schema`` under those options, otherwise + ``ValueError`` is raised (spec Section 9.7). For example, with + ``ordered_columns`` a batch with the columns in a different order is + rejected. + + Raises: + ValueError: With any option on, if ``schema`` is rejected (spec 9.6). """ + flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) + if flags: + _check_schema_node_paths(schema) self._schema = schema - self._include_metadata = include_metadata # captured in _schema_digest; stored for repr/diagnostics - self._schema_digest = _hash_schema(schema, include_metadata=include_metadata) + self._include_metadata = include_metadata # captured in _schema_digest; reused by update() + self._flags = flags + self._schema_digest = _hash_schema(schema, include_metadata=include_metadata, flags=flags) + # Spec Section 9.7: with any option on, every batch must match this key. + self._schema_key = _schema_key(schema, include_metadata, flags) if flags else None # BTreeMap — sorted by key self._fields: dict[str, tuple] = {} + nv = bool(flags & _NESTED_VALIDITY) for i in range(len(schema)): - _extract_fields(schema.field(i), "", self._fields) + _extract_fields(schema.field(i), "", self._fields, nv) # Ensure sorted order (Python 3.7+ dicts are insertion-ordered) self._fields = dict(sorted(self._fields.items())) def update(self, record_batch: pa.RecordBatch) -> None: - """Feed a RecordBatch into the running digest (spec Sections 3–5).""" - # Build a mapping from top-level column name to (field, array) + """Feed a RecordBatch into the running digest (spec Sections 3–5). + + Raises: + ValueError: With any option on, if the batch's schema is rejected + (spec 9.6) or does not match the digester's schema under its + options (spec 9.7). + """ schema = record_batch.schema + if self._flags: + _check_schema_node_paths(schema) + if _schema_key(schema, self._include_metadata, self._flags) != self._schema_key: + raise ValueError(_SCHEMA_MISMATCH) + nv = bool(self._flags & _NESTED_VALIDITY) # Traverse each top-level field using the recursive traversal for i in range(len(schema)): field = schema.field(i) @@ -807,6 +1031,7 @@ def update(self, record_batch: pa.RecordBatch) -> None: field.name, None, # no ancestor struct nulls at top level self._fields, + nv, ) def finalize(self) -> bytes: @@ -820,7 +1045,14 @@ def finalize(self) -> bytes: # -- Convenience class methods ------------------------------------------ @staticmethod - def hash_schema(schema: pa.Schema, *, include_metadata: bool = False) -> bytes: + def hash_schema( + schema: pa.Schema, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + nested_validity: bool = False, + ) -> bytes: """Hash an Arrow schema. Args: @@ -830,11 +1062,39 @@ def hash_schema(schema: pa.Schema, *, include_metadata: bool = False) -> bytes: preserving hash format 0.0.1 stability. A schema with no metadata produces the same hash regardless of this flag (empty-metadata invariant). + ordered_columns: When True, the order of the top-level columns is + part of the hash (spec Section 9.3). + ordered_struct_fields: When True, the order of struct fields, at + every nesting depth, is part of the hash (spec Section 9.3). + nested_validity: When True, every nullable struct, and every + nullable list or struct that is a list element, records its + own validity bits (spec Section 9.5). + + With any of these three options on, the hash never equals the hash + taken with a different set of options (in particular with all of them + off), and schemas in which two nodes share a path (duplicate names, or + a name containing ``/`` that aliases another node) are rejected with + ``ValueError`` (spec Section 9.6). + ``nested_validity`` does not change the schema JSON, but like every + option it is part of the hash. + + Raises: + ValueError: With any option on, if ``schema`` is rejected (spec 9.6). """ - return VERSION_BYTES + _hash_schema(schema, include_metadata=include_metadata) + flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) + if flags: + _check_schema_node_paths(schema) + return VERSION_BYTES + _hash_schema(schema, include_metadata=include_metadata, flags=flags) @staticmethod - def hash_record_batch(record_batch: pa.RecordBatch, *, include_metadata: bool = False) -> bytes: + def hash_record_batch( + record_batch: pa.RecordBatch, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + nested_validity: bool = False, + ) -> bytes: """Hash an Arrow record batch. Args: @@ -844,15 +1104,46 @@ def hash_record_batch(record_batch: pa.RecordBatch, *, include_metadata: bool = preserving hash format 0.0.1 stability. A schema with no metadata produces the same hash regardless of this flag (empty-metadata invariant). + ordered_columns: When True, the order of the top-level columns is + part of the hash (spec Section 9.3). + ordered_struct_fields: When True, the order of struct fields, at + every nesting depth, is part of the hash (spec Section 9.3). + nested_validity: When True, every nullable struct, and every + nullable list or struct that is a list element, records its + own validity bits (spec Section 9.5). + + With any of these three options on, the hash never equals the hash + taken with a different set of options (in particular with all of them + off), and schemas in which two nodes share a path (duplicate names, or + a name containing ``/`` that aliases another node) are rejected with + ``ValueError`` (spec Section 9.6). + Raises: + ValueError: With any option on, if the schema is rejected (spec 9.6). """ - d = ArrowDigester(record_batch.schema, include_metadata=include_metadata) + d = ArrowDigester( + record_batch.schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + nested_validity=nested_validity, + ) d.update(record_batch) return d.finalize() @staticmethod - def hash_table(table: pa.Table, *, include_metadata: bool = False) -> bytes: + def hash_table( + table: pa.Table, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + nested_validity: bool = False, + ) -> bytes: """Hash a full Arrow table (iterates over all batches). + Equivalent to ``ArrowDigester(table.schema, ...)``, :meth:`update` for each + batch of ``table.to_batches()``, then :meth:`finalize`. + Args: table: The table to hash. include_metadata: When True, schema-level and per-field Arrow @@ -860,24 +1151,76 @@ def hash_table(table: pa.Table, *, include_metadata: bool = False) -> bytes: preserving hash format 0.0.1 stability. A schema with no metadata produces the same hash regardless of this flag (empty-metadata invariant). + ordered_columns: When True, the order of the top-level columns is + part of the hash (spec Section 9.3). + ordered_struct_fields: When True, the order of struct fields, at + every nesting depth, is part of the hash (spec Section 9.3). + nested_validity: When True, every nullable struct, and every + nullable list or struct that is a list element, records its + own validity bits (spec Section 9.5). + + With any of these three options on, the hash never equals the hash + taken with a different set of options (in particular with all of them + off), and schemas in which two nodes share a path (duplicate names, or + a name containing ``/`` that aliases another node) are rejected with + ``ValueError`` (spec Section 9.6). + Raises: + ValueError: With any option on, if the schema is rejected (spec 9.6). """ - d = ArrowDigester(table.schema, include_metadata=include_metadata) + d = ArrowDigester( + table.schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + nested_validity=nested_validity, + ) for batch in table.to_batches(): d.update(batch) return d.finalize() @staticmethod - def hash_array(array: pa.Array) -> bytes: + def hash_array( + array: pa.Array, + *, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + nested_validity: bool = False, + ) -> bytes: """Hash a single array (spec Section 6). Uses the same recursive BTreeMap decomposition as the record-batch path. + Args: + array: The array to hash. + ordered_columns: When True, the order of the top-level columns is + part of the hash (spec Section 9.3). + ordered_struct_fields: When True, the order of struct fields, at + every nesting depth, is part of the hash (spec Section 9.3). + nested_validity: When True, every nullable struct, and every + nullable list or struct that is a list element, records its + own validity bits (spec Section 9.5). + + With any of these three options on, the hash never equals the hash + taken with a different set of options (in particular with all of them + off), and schemas in which two nodes share a path (duplicate names, or + a name containing ``/`` that aliases another node) are rejected with + ``ValueError`` (spec Section 9.6). + ``ordered_columns`` does not change the type JSON of an array, but like + every option it is part of the hash (spec Section 9.4). + + Raises: + ValueError: With any option on, if the array's type is rejected + (spec 9.6). + Note: ``include_metadata`` is intentionally absent here — standalone arrays carry no schema or field metadata. This matches the Rust ``starfix`` API. """ import pyarrow as pa + flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) + nv = bool(flags & _NESTED_VALIDITY) + # Resolve dictionary arrays to their plain value type effective_type = array.type effective_array = array @@ -885,23 +1228,26 @@ def hash_array(array: pa.Array) -> bytes: effective_type = effective_type.value_type effective_array = array.cast(effective_type) + if flags: + _check_type_node_paths(effective_type) + # Normalize to canonical large types normalized_type = _normalize_data_type(effective_type) - # Step 1: Type metadata (canonical JSON string) - dt_value = _data_type_to_value(normalized_type) - dt_value = _sort_json_value(dt_value) - dt_json = json.dumps(dt_value, separators=(",", ":")) - final_digest = hashlib.sha256() - final_digest.update(dt_json.encode()) + if flags: + # Spec Section 9.2: the options tag is the first input. + final_digest.update(_options_tag(flags)) + + # Step 1: Type metadata (canonical JSON string) + final_digest.update(_type_json(normalized_type, flags).encode()) # Determine nullability: arrays with null_count > 0 are nullable nullable = effective_array.null_count > 0 # Step 2: Build BTreeMap entries from the type tree (same as record-batch) fields: dict[str, tuple] = {} - _extract_type_entries(effective_type, nullable, "", fields) + _extract_type_entries(effective_type, nullable, "", fields, nv) fields = dict(sorted(fields.items())) # Step 3: Traverse and populate entries @@ -912,6 +1258,7 @@ def hash_array(array: pa.Array) -> bytes: "", None, fields, + nv, ) # Step 4: Finalize all entries into the digest @@ -919,3 +1266,4 @@ def hash_array(array: pa.Array) -> bytes: _finalize_digest(final_digest, entry) return VERSION_BYTES + final_digest.digest() + From f7c544b93898c97c27a759e90fb7c3c7c4b1b112 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:47:04 -0800 Subject: [PATCH 03/49] test: golden parity test for ordered_v0.5.json; docs and CI sync check (ITL-898) The parity test runs every vector and every relation of the Rust golden file (to be copied in unchanged). README documents the three options. The golden-sync check also diffs ordered_v0.5.json against starfix main. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 21 +++++ README.md | 54 +++++++++++- tests/test_golden_parity_ordered.py | 131 ++++++++++++++++++++++++++++ 3 files changed, 205 insertions(+), 1 deletion(-) create mode 100644 tests/test_golden_parity_ordered.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c69e51a..2e11a02 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -107,3 +107,24 @@ jobs: echo "Copy the updated fixture from the starfix repo and commit it." exit 1 fi + + - name: Fetch authoritative ordered fixture from starfix + run: | + gh api repos/nauticalab/starfix/contents/tests/golden/ordered_v0.5.json \ + --jq '.content' | base64 -d > /tmp/upstream_ordered.json + env: + GH_TOKEN: ${{ steps.app-token.outputs.token }} + + - name: Fail on ordered fixture drift + run: | + if [ ! -s /tmp/upstream_ordered.json ]; then + echo "ERROR: Could not fetch fixture from nauticalab/starfix main." + echo "Ensure nauticalab/starfix#main has tests/golden/ordered_v0.5.json" + echo "(the starfix ITL-898 PR must be merged before this check can pass)" + exit 1 + fi + if ! diff tests/golden/ordered_v0.5.json /tmp/upstream_ordered.json; then + echo "ERROR: tests/golden/ordered_v0.5.json has drifted from nauticalab/starfix main." + echo "Copy the updated fixture from the starfix repo and commit it." + exit 1 + fi diff --git a/README.md b/README.md index 7c098c2..92c7136 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ Pure-Python implementation of the [starfix](https://github.com/nauticalab/starfi Produces stable SHA-256 hashes of Arrow tables, record batches, and arrays that are: -- **Column-order independent** — reordering columns does not change the hash +- **Column-order independent** by default — reordering columns or struct fields does not change the hash (opt-in order sensitivity: see [Hashing options](#hashing-options-order-sensitivity-and-nested-validity)) - **Batch-split independent** — splitting data across batches does not change the hash - **Cross-language compatible** — identical hashes to the Rust implementation @@ -61,6 +61,58 @@ regardless of insertion order. A schema with no metadata produces the same hash regardless of `include_metadata` (empty-metadata invariant). +## Hashing options: order sensitivity and nested validity + +Three further keyword-only options, all `False` by default, are accepted by +`ArrowDigester(...)`, `hash_schema`, `hash_record_batch`, `hash_table` and +`hash_array`. They have the same names as the Rust `HasherConfig` fields and +produce byte-identical hashes (layout: starfix `docs/byte-layout-spec.md`, +Section 9). + +| Option | Effect | +|---|---| +| `ordered_columns` | The order of the top-level columns is part of the hash. | +| `ordered_struct_fields` | The order of struct fields, at every nesting depth (inside lists, struct children, …), is part of the hash. | +| `nested_validity` | Every nullable struct, and every nullable list or struct that is a list element, records its own validity. A null struct then differs from a struct whose fields are all null, null struct rows are counted, and the outer lengths of a list of nullable lists are hashed. | + +```python +# A pa.Table whose column order and struct field order are part of its identity +digest = ArrowDigester.hash_table( + table, ordered_columns=True, ordered_struct_fields=True, nested_validity=True +) + +# hash_array takes the same options (ordered_columns has no effect on an array's +# layout, but like every option it is part of the hash) +digest = ArrowDigester.hash_array(struct_array, ordered_struct_fields=True) +``` + +When to use them: + +- Leave them off to identify *data* independent of how columns or struct fields + happen to be ordered (the default; every existing hash is unchanged). +- Turn on `ordered_columns` / `ordered_struct_fields` when order is part of the + value's identity, as for a DataFrame or a `pa.StructArray` whose type + `struct` differs from `struct`. +- Turn on `nested_validity` when null structs and null nested lists must be + distinguished from their non-null look-alikes. + +Things to know: + +- **A hash taken with any option on never equals a hash taken with a different + set of options**, in particular with all options off, even when order cannot + matter (for example, a one-column table). Choose the options once per use case. +- With any option on, a schema in which two nodes share a path is rejected with + `ValueError`: duplicate column names, duplicate field names within a struct, + or a name containing `/` that aliases another node (a column `"a/b"` next to a + struct column `a` with a child `b`). A `/` that aliases nothing (`"km/h"`) is + fine. +- Streaming with any option on: every batch passed to `update` must have the + digester's schema under those options, otherwise `ValueError` is raised. With + `ordered_columns`, a batch with the same columns in another order is rejected; + without it, the batch is accepted. The same holds for struct field order and + `ordered_struct_fields`. +- `include_metadata` works with every option as described above. + ## License MIT OR Apache-2.0 diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py new file mode 100644 index 0000000..c5b9a76 --- /dev/null +++ b/tests/test_golden_parity_ordered.py @@ -0,0 +1,131 @@ +"""Cross-language golden-hash parity tests for the v0.5 hashing options (ITL-898). + +Every expected hash in ``tests/golden/ordered_v0.5.json`` was generated by +``cargo run --bin emit_golden_ordered`` in the Rust starfix crate and is the +authoritative source of truth. The file is a byte-for-byte copy and is never edited +here. Every vector and every relation is checked; nothing is skipped. + +Vector methods (IPC stream decoded with ``pyarrow.ipc.open_stream``): + +* ``hash_schema`` the stream's schema +* ``hash_record_batch`` exactly one batch +* ``hash_stream`` ``ArrowDigester(schema)``, ``update`` per batch in stream order, ``finalize`` +* ``hash_array`` exactly one batch with exactly one column; that column's array +""" + +from __future__ import annotations + +import base64 +import io +import itertools +import json +from functools import cache +from pathlib import Path +from typing import Any + +import pyarrow as pa +import pytest + +from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester + +_FIXTURE_PATH = Path(__file__).parent / "golden" / "ordered_v0.5.json" + + +@cache +def _fixture() -> dict[str, Any]: + with _FIXTURE_PATH.open(encoding="utf-8") as f: + return json.load(f) + + +def _vectors() -> list[dict[str, Any]]: + return _fixture()["vectors"] + + +def _relations() -> list[dict[str, Any]]: + return _fixture()["relations"] + + +def _options(vector: dict[str, Any]) -> dict[str, bool]: + """The vector's option values, keyed by the Python keyword names.""" + missing = [name for name in _OPTION_FLAGS if name not in vector] + assert not missing, f"Vector '{vector['id']}' has no value for option(s) {missing}" + return {name: vector[name] for name in _OPTION_FLAGS} + + +def _read_ipc(ipc_b64: str) -> tuple[pa.Schema, list[pa.RecordBatch]]: + reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(ipc_b64))) + return reader.schema, list(reader) + + +def _hash(vector: dict[str, Any]) -> str: + vid = vector["id"] + schema, batches = _read_ipc(vector["ipc_b64"]) + options = _options(vector) + include_metadata: bool = vector["include_metadata"] + method = vector["method"] + + if method == "hash_schema": + result = ArrowDigester.hash_schema(schema, include_metadata=include_metadata, **options) + elif method == "hash_record_batch": + assert len(batches) == 1, f"Vector '{vid}': hash_record_batch needs exactly one batch" + result = ArrowDigester.hash_record_batch(batches[0], include_metadata=include_metadata, **options) + elif method == "hash_stream": + digester = ArrowDigester(schema, include_metadata=include_metadata, **options) + for batch in batches: + digester.update(batch) + result = digester.finalize() + elif method == "hash_array": + assert len(batches) == 1 and batches[0].num_columns == 1, ( + f"Vector '{vid}': hash_array needs exactly one batch with one column" + ) + result = ArrowDigester.hash_array(batches[0].column(0), **options) + else: + pytest.fail(f"Vector '{vid}': unknown method '{method}'") + return result.hex() + + +def test_fixture_is_well_formed() -> None: + vectors = _vectors() + assert vectors, "golden file has no vectors" + ids = [v["id"] for v in vectors] + duplicates = sorted({i for i in ids if ids.count(i) > 1}) + assert not duplicates, f"duplicate vector ids: {duplicates}" + known = set(ids) + for rel in _relations(): + assert rel["kind"] in ("equal", "different"), f"unknown relation kind {rel['kind']!r}" + assert len(rel["ids"]) >= 2, f"relation {rel['ids']} names fewer than two vectors" + unknown = [i for i in rel["ids"] if i not in known] + assert not unknown, f"relation {rel['ids']} names unknown vector ids {unknown}" + + +@pytest.mark.parametrize("vector", _vectors(), ids=lambda v: v["id"]) +def test_golden_vector(vector: dict[str, Any]) -> None: + """Each vector must produce the Rust-authoritative expected_hash.""" + got = _hash(vector) + assert got == vector["expected_hash"], ( + f"Vector '{vector['id']}' mismatch: {vector['description']}\n" + f" got: {got}\n" + f" expected: {vector['expected_hash']}" + ) + + +@pytest.mark.parametrize( + "relation", _relations(), ids=lambda r: f"{r['kind']}:{'|'.join(r['ids'])}" +) +def test_golden_relation(relation: dict[str, Any]) -> None: + """Each relation holds for the pinned values and for the live Python hashes.""" + by_id = {v["id"]: v for v in _vectors()} + ids = relation["ids"] + pinned = {i: by_id[i]["expected_hash"] for i in ids} + live = {i: _hash(by_id[i]) for i in ids} + for label, hashes in (("pinned", pinned), ("live", live)): + if relation["kind"] == "equal": + assert len(set(hashes.values())) == 1, ( + f"relation equal {ids} fails on {label} hashes: {hashes} ({relation.get('why', '')})" + ) + else: + for a, b in itertools.combinations(ids, 2): + assert hashes[a] != hashes[b], ( + f"relation different {ids} fails on {label} hashes: '{a}' == '{b}' " + f"({relation.get('why', '')})" + ) From 3576735d10bebce15e105521607addeb999e7abe Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:49:18 -0800 Subject: [PATCH 04/49] feat: Boolean one-byte layout under nested_validity; Rust Map form with options; golden file (ITL-898) - nested_validity feeds one byte per valid Boolean value (spec 9.5.1, T6) - with any option on, Map serializes its entries field and keys_sorted as Rust does; the default (flags 0) form is unchanged - tests/golden/ordered_v0.5.json copied byte for byte from starfix (sha256 ff86795d...) Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 65 +- tests/golden/ordered_v0.5.json | 2162 ++++++++++++++++++++++++++++++++ tests/test_ordered_hashing.py | 60 +- 3 files changed, 2261 insertions(+), 26 deletions(-) create mode 100644 tests/golden/ordered_v0.5.json diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 0c85aba..a95a779 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -98,35 +98,40 @@ def raw_bytes(self) -> bytes: # Schema / DataType serialization (spec Section 2) # --------------------------------------------------------------------------- -def _data_type_to_value(dt: pa.DataType, ordered_struct_fields: bool = False) -> object: +def _data_type_to_value(dt: pa.DataType, flags: int = 0) -> object: """Convert a pyarrow DataType to the JSON-compatible value that matches the canonical form described in spec Section 2.1. Types are normalized: Utf8→LargeUtf8, Binary→LargeBinary, List→LargeList, Dictionary→value_type. Struct fields are sorted alphabetically, or kept in - declaration order when ``ordered_struct_fields`` is set (spec Section 9.3), - at every depth. + declaration order when ``flags`` has ``ordered_struct_fields`` (spec + Section 9.3), at every depth. ``flags == 0`` is the historical form. """ import pyarrow as pa - osf = ordered_struct_fields # Normalize: Dictionary → recurse on value type if pa.types.is_dictionary(dt): - return _data_type_to_value(dt.value_type, osf) + return _data_type_to_value(dt.value_type, flags) if pa.types.is_struct(dt): fields = [dt.field(i) for i in range(dt.num_fields)] - if not osf: + if not flags & _ORDERED_STRUCT_FIELDS: # Sort struct fields alphabetically by name fields.sort(key=lambda f: f.name) - fields_json = [_inner_field_to_value(f, osf) for f in fields] + fields_json = [_inner_field_to_value(f, flags) for f in fields] return {"Struct": fields_json} if pa.types.is_list(dt) or pa.types.is_large_list(dt): - return {"LargeList": _element_type_to_value(dt.value_field, osf)} + return {"LargeList": _element_type_to_value(dt.value_field, flags)} if pa.types.is_fixed_size_list(dt): - return {"FixedSizeList": [_element_type_to_value(dt.value_field, osf), dt.list_size]} + return {"FixedSizeList": [_element_type_to_value(dt.value_field, flags), dt.list_size]} if pa.types.is_map(dt): - return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries"), osf), False]} + if flags: + # The entries field (a struct of key and value) and keys_sorted, + # as the Rust implementation serializes DataType::Map(entries, sorted). + return {"Map": [_inner_field_to_value(dt.field(0), flags), dt.keys_sorted]} + # Historical form (flags == 0), kept byte for byte: it omits the value + # type and does not match the Rust form (see tests/test_known_divergences.py). + return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries")), False]} # Primitive / leaf types – must match Arrow-Rust serde return _primitive_data_type_string(dt) @@ -193,22 +198,22 @@ def _primitive_data_type_string(dt: pa.DataType) -> object: raise NotImplementedError(f"Unsupported data type: {dt}") -def _inner_field_to_value(field: pa.Field, ordered_struct_fields: bool = False) -> dict: +def _inner_field_to_value(field: pa.Field, flags: int = 0) -> dict: """Convert a field to JSON with name, data_type, and nullable.""" return { "name": field.name, - "data_type": _data_type_to_value(field.type, ordered_struct_fields), + "data_type": _data_type_to_value(field.type, flags), "nullable": field.nullable, } -def _element_type_to_value(field: pa.Field, ordered_struct_fields: bool = False) -> dict: +def _element_type_to_value(field: pa.Field, flags: int = 0) -> dict: """Convert a container element field to JSON with only data_type and nullable (no name). Used for list and fixed-size list element types, matching Rust ``element_type_to_value``. """ return { - "data_type": _data_type_to_value(field.type, ordered_struct_fields), + "data_type": _data_type_to_value(field.type, flags), "nullable": field.nullable, } @@ -243,15 +248,14 @@ def _phase1_json(schema: pa.Schema, flags: int) -> str: """ if flags == 0: return _serialized_schema(schema) - osf = bool(flags & _ORDERED_STRUCT_FIELDS) fields = [schema.field(i) for i in range(len(schema))] if flags & _ORDERED_COLUMNS: # Top level is an array of struct-child-form objects, in schema order. - doc: object = [_sort_json_value(_inner_field_to_value(f, osf)) for f in fields] + doc: object = [_sort_json_value(_inner_field_to_value(f, flags)) for f in fields] else: doc = OrderedDict(sorted( (f.name, _sort_json_value({ - "data_type": _data_type_to_value(f.type, osf), + "data_type": _data_type_to_value(f.type, flags), "nullable": f.nullable, })) for f in fields @@ -265,7 +269,7 @@ def _type_json(data_type: pa.DataType, flags: int) -> str: ``flags == 0`` keeps the historical serialization byte for byte. With any option on, non-ASCII characters are written as raw UTF-8 (as serde_json does). """ - value = _sort_json_value(_data_type_to_value(data_type, bool(flags & _ORDERED_STRUCT_FIELDS))) + value = _sort_json_value(_data_type_to_value(data_type, flags)) if flags == 0: return json.dumps(value, separators=(",", ":")) return json.dumps(value, separators=(",", ":"), ensure_ascii=False) @@ -305,7 +309,7 @@ def _walk_node_paths(data_type: pa.DataType, path: str, seen: set[str]) -> None: # The element of a map is its entries struct (key, value). element_path = f"{path}{DELIMITER}" _claim(seen, element_path) - _walk_node_paths(pa.struct([t.key_field, t.item_field]), element_path, seen) + _walk_node_paths(t.field(0).type, element_path, seen) elif pa.types.is_list(t) or pa.types.is_large_list(t) or pa.types.is_fixed_size_list(t): element_path = f"{path}{DELIMITER}" _claim(seen, element_path) @@ -663,7 +667,7 @@ def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, field elif pa.types.is_struct(canonical): _traverse_struct(effective_array, nullable, path, ancestor_nulls, fields, nested_validity) else: - _traverse_leaf(effective_type, effective_array, path, ancestor_nulls, fields) + _traverse_leaf(effective_type, effective_array, path, ancestor_nulls, fields, nested_validity) def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields, nested_validity=False): @@ -760,7 +764,7 @@ def _traverse_struct(array, nullable, path, ancestor_nulls, fields, nested_valid ) -def _traverse_leaf(data_type, array, path, ancestor_nulls, fields): +def _traverse_leaf(data_type, array, path, ancestor_nulls, fields, nested_validity=False): """Traverse a leaf array — hash data into its BTreeMap entry (spec Sections 3.1–3.3).""" entry = fields.get(path) if entry is None: @@ -783,15 +787,18 @@ def _traverse_leaf(data_type, array, path, ancestor_nulls, fields): null_bits.extend_true(len(array)) # Hash leaf data, skipping null elements - _hash_leaf_data(data_type, array, data_digest, effective) + _hash_leaf_data(data_type, array, data_digest, effective, nested_validity) -def _hash_leaf_data(data_type, array, data_digest, effective_nulls): - """Hash leaf-level data bytes into the data digest (spec Sections 3.1–3.3).""" +def _hash_leaf_data(data_type, array, data_digest, effective_nulls, nested_validity=False): + """Hash leaf-level data bytes into the data digest (spec Sections 3.1–3.3, 9.5.1).""" import pyarrow as pa if pa.types.is_boolean(data_type): - _hash_boolean_data(array, data_digest, effective_nulls) + if nested_validity: + _hash_boolean_bytes(array, data_digest, effective_nulls) + else: + _hash_boolean_data(array, data_digest, effective_nulls) elif pa.types.is_large_binary(data_type): _hash_binary_data(array, data_digest, effective_nulls) elif pa.types.is_large_string(data_type): @@ -874,6 +881,14 @@ def _hash_boolean_data(arr, data_digest, effective_nulls) -> None: data_digest.update(bv.raw_bytes()) +def _hash_boolean_bytes(arr, data_digest, effective_nulls) -> None: + """Hash boolean data as one byte (0x00/0x01) per valid value (spec Section 9.5.1).""" + values = arr.to_pylist() if effective_nulls is None else [ + arr[i].as_py() for i in range(len(arr)) if effective_nulls[i] + ] + data_digest.update(bytes(1 if v else 0 for v in values)) + + def _hash_binary_data(arr, data_digest, effective_nulls) -> None: """Hash binary array data (spec Section 3.3).""" if effective_nulls is None: diff --git a/tests/golden/ordered_v0.5.json b/tests/golden/ordered_v0.5.json new file mode 100644 index 0000000..3aa50ad --- /dev/null +++ b/tests/golden/ordered_v0.5.json @@ -0,0 +1,2162 @@ +{ + "version": "0.5", + "generated_by": "cargo run --bin emit_golden_ordered", + "rust_commit": "b826f81662c91ccdd92544a484e14601585e8c57", + "vectors": [ + { + "id": "cols_ab_rb_f0", + "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d" + }, + { + "id": "cols_ba_rb_f0", + "description": "Same data, columns b,a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d" + }, + { + "id": "cols_ab_schema_f0", + "description": "Schema [a, b]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9" + }, + { + "id": "cols_ba_schema_f0", + "description": "Schema [b, a]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9" + }, + { + "id": "cols_ab_rb_f1", + "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000121b54ec5ca8e122a2196ee4432edd4e2a2819d2c72b9ae19868874ee1a4d4595" + }, + { + "id": "cols_ba_rb_f1", + "description": "Same data, columns b,a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000197d403796b51f4aecb389b95428a3a628c0eec3f87f3e7e98c3ad2f028c88dac" + }, + { + "id": "cols_ab_schema_f1", + "description": "Schema [a, b]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001433f79fbd0ee506ee7dc7fcb53dcb20a5513d301283e81e48a9c4eddf2657edb" + }, + { + "id": "cols_ba_schema_f1", + "description": "Schema [b, a]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001927f7ad3301ffa6420efb0e7fbd1928d98454a92d55888e53e3b37f3ff6c7b4a" + }, + { + "id": "cols_ba_stream_f1", + "description": "Stream of the cols_ba data split into two batches, ordered_columns", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000197d403796b51f4aecb389b95428a3a628c0eec3f87f3e7e98c3ad2f028c88dac" + }, + { + "id": "combo_ns_xy_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" + }, + { + "id": "combo_sn_xy_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" + }, + { + "id": "combo_ns_yx_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" + }, + { + "id": "combo_sn_yx_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" + }, + { + "id": "combo_ns_xy_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a12d9d439905c16338fec9ab33c757d3c9c11ed4ed14e8d618a699fbf170e40d" + }, + { + "id": "combo_sn_xy_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000016d9c52cf9a055df5764d2b52e57929f650d6ac8b92206eb7f67adb9b679cfd41" + }, + { + "id": "combo_ns_yx_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a12d9d439905c16338fec9ab33c757d3c9c11ed4ed14e8d618a699fbf170e40d" + }, + { + "id": "combo_sn_yx_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000016d9c52cf9a055df5764d2b52e57929f650d6ac8b92206eb7f67adb9b679cfd41" + }, + { + "id": "combo_ns_xy_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001f3338aeec6740e360c7919ed1527d3a180d721611dbe2573fdfdafb01c250b93" + }, + { + "id": "combo_sn_xy_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001f3338aeec6740e360c7919ed1527d3a180d721611dbe2573fdfdafb01c250b93" + }, + { + "id": "combo_ns_yx_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001ce00ff6234af4635713dbc8ef6ed4acc6f751e2153fca3fd292e9d7bf20a6a28" + }, + { + "id": "combo_sn_yx_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001ce00ff6234af4635713dbc8ef6ed4acc6f751e2153fca3fd292e9d7bf20a6a28" + }, + { + "id": "combo_ns_xy_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000157528aa46dc70002df3ac22328918d1128fdad6b3fb0f428b944214ff283ec1f" + }, + { + "id": "combo_sn_xy_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001bbbb6e0038be6938efa52f5b1cd8107f54d7db033790b27d5f9068b852efec9f" + }, + { + "id": "combo_ns_yx_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000018ad68d9e117c5551e8bddf182148c7f4873d14ea322df73dfe52ea6ef8be26da" + }, + { + "id": "combo_sn_yx_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000018484372d6f9b79b7e2dd09a4574784f5d16d8cd32c8e9f5d806d7961ba15e0f6" + }, + { + "id": "nested_struct_ab_schema_f0", + "description": "s: Struct>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad" + }, + { + "id": "nested_struct_ba_schema_f0", + "description": "s: Struct> (only the inner level permuted)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad" + }, + { + "id": "list_struct_ab_rb_f0", + "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" + }, + { + "id": "list_struct_ba_rb_f0", + "description": "Same, struct fields declared b, a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" + }, + { + "id": "large_list_struct_ab_rb_f0", + "description": "Same as list_struct_ab with LargeList", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" + }, + { + "id": "fsl_struct_ab_schema_f0", + "description": "f: FixedSizeList, 2> (schema only: data unsupported)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5" + }, + { + "id": "fsl_struct_ba_schema_f0", + "description": "f: FixedSizeList, 2>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5" + }, + { + "id": "map_struct_ab_schema_f0", + "description": "m: Map> (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c" + }, + { + "id": "map_struct_ba_schema_f0", + "description": "m: Map>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c" + }, + { + "id": "nested_struct_ab_schema_f2", + "description": "s: Struct>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000103feec3edfc6ad67372f2a0b039b31e3c5e09dc89c38f1a333d0c235c20daff0" + }, + { + "id": "nested_struct_ba_schema_f2", + "description": "s: Struct> (only the inner level permuted)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000011db23e275141dbafc6885145528be2d78b2896fe00d8c05d97e6cb7433092169" + }, + { + "id": "list_struct_ab_rb_f2", + "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000174b0ee3721df257940875351a9d9a639b5422637c6e83725d0f346ae5cc38a37" + }, + { + "id": "list_struct_ba_rb_f2", + "description": "Same, struct fields declared b, a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001098bdb016a9ef1086c264d7d6dc16e42d30b82cb6b44a194545f2262dee91101" + }, + { + "id": "large_list_struct_ab_rb_f2", + "description": "Same as list_struct_ab with LargeList", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000174b0ee3721df257940875351a9d9a639b5422637c6e83725d0f346ae5cc38a37" + }, + { + "id": "fsl_struct_ab_schema_f2", + "description": "f: FixedSizeList, 2> (schema only: data unsupported)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000175deb7bc7a57e6937b78f9feaf9110e93842cf762f743c2221497657a944da77" + }, + { + "id": "fsl_struct_ba_schema_f2", + "description": "f: FixedSizeList, 2>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000154a53df59f8a47829c7b277d9e95b47320608fdf6c1ed9e9712dfb996484538e" + }, + { + "id": "map_struct_ab_schema_f2", + "description": "m: Map> (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001d700e3cc5935b5cb72702e39727308f5bd6d3419dff84d400a8c189b2d469cd2" + }, + { + "id": "map_struct_ba_schema_f2", + "description": "m: Map>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001436d0e9de48650db71fbb3af6c2ef02e1269edf8a93a8e5c8f63814fdccb4b6a" + }, + { + "id": "one_col_rb_f0", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857" + }, + { + "id": "one_col_schema_f0", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000001b7f25ba092def78ecd57c231765bac9d23a37ef04734462c1f50ec5880e7f204" + }, + { + "id": "one_col_array_f0", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c" + }, + { + "id": "one_col_rb_f1", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001b78fcdc09baafc38945854618d7f457e01535e7c72f8e959c0073acb8b99da8b" + }, + { + "id": "one_col_schema_f1", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000001962aa3a655a41ac8a79532f949b5af68637de2b08d0ef7a787d0c19e5b804fe1" + }, + { + "id": "one_col_array_f1", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000013f93038c45e900987f5428c0615210a40e9c9a64a7dff45a397ac163ece0c383" + }, + { + "id": "one_col_rb_f2", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001f4c62f99ec684a654040f08a293c249f7d7ed930242c15bbdb9883575cdff57e" + }, + { + "id": "one_col_schema_f2", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "00000171533ac6eefe6e41b09c75961a5b9700d6c9d68f48ac427496a80c9e28aa1a0a" + }, + { + "id": "one_col_array_f2", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001c3423f6ea4cd018fc045934f847cfa79c30a2201390d75cdfacbf84302493fe4" + }, + { + "id": "one_col_rb_f3", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000013362f852129e33e3204b15ac3ddc8dd57bdc8771c4396a9946d2c911628e5f65" + }, + { + "id": "one_col_schema_f3", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000001e1e6d344de70bc1eb034163991fc1fc57787adb5af12ce57c00bead160cf53ba" + }, + { + "id": "one_col_array_f3", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000011470123be74fd71dc50ade81d0226a3e68a6337b057c2b85f9468bf90dd0da59" + }, + { + "id": "one_col_rb_f4", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000017b8433e7bd2c431a74138d9935ee6d619c001af4f2e4e128c35c60dbdb53c70b" + }, + { + "id": "one_col_schema_f4", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "0000017022b81e60e4a1dba9ec4602a4976a0dea50f490c916d0ce01e697ebcf9069ee" + }, + { + "id": "one_col_array_f4", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000019e3adff54fa94dec7e5d72a37b3d7b1f8153afedd28032b59997d2ba47c51db0" + }, + { + "id": "one_col_rb_f5", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001c38897ca9f720d18fb37eba87e4b28765a1e664b92764a914590130131816bd2" + }, + { + "id": "one_col_schema_f5", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000001d90f32c33eaaa8b3c3c51f2cf33ff920ca09015eeb50d98727a556765a83bd3e" + }, + { + "id": "one_col_array_f5", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000016add16fe46328698a1f252768018a01aa8eab9eacef5adaf602c67fa4196f869" + }, + { + "id": "one_col_rb_f6", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001dbbf891eed1bf9ef6a93202984a39deb5c993b7481cd734eba54878bce23e6f1" + }, + { + "id": "one_col_schema_f6", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "0000018996061e12067c82279f8c5f08d3defe8ad2f9509c6701416a7b75055dcf0d95" + }, + { + "id": "one_col_array_f6", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001973166b6e70cba833de35adaed48af4416d986c5b411196e4b5a1951259119c7" + }, + { + "id": "one_col_rb_f7", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000165a886e87aaa8efd06668bc6bb3f154d0aad098cc2f301eaf45150d1bacb15ca" + }, + { + "id": "one_col_schema_f7", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "0000010da7daf6e5c269dcc172b9756942366d3ed59d809ed79f0a8c961c21a64ba581" + }, + { + "id": "one_col_array_f7", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000016135b88789127c04f395b05ffd47ceac8ed34829f9bb952ad5e5f4e17c881394" + }, + { + "id": "plain_schema_f1_im0", + "description": "Schema [b, a] without metadata, include_metadata=false", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001f671b75064ce3c0dcc6722dec4c8b7dfae3f5aecd931ae45073f449a59f0abe6" + }, + { + "id": "plain_schema_f1_im1", + "description": "Same, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001f671b75064ce3c0dcc6722dec4c8b7dfae3f5aecd931ae45073f449a59f0abe6" + }, + { + "id": "meta_schema_f1_im1", + "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001155c895b58a677b6e8b553e5c934ade77df1a089f400e8dc82a11617e12fa746" + }, + { + "id": "plain_schema_f7_im0", + "description": "Schema [b, a] without metadata, include_metadata=false", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000012e5ca80a107600a263f4ae5362e7be8f5531dc190fb745134eeb99b5dd29cf42" + }, + { + "id": "plain_schema_f7_im1", + "description": "Same, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000012e5ca80a107600a263f4ae5362e7be8f5531dc190fb745134eeb99b5dd29cf42" + }, + { + "id": "meta_schema_f7_im1", + "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000015a690f2487025a0de8162d8c5eaa4a7684991819b210b7726f83f3249a34b22f" + }, + { + "id": "ext_struct_xy_rb_f0_im1", + "description": "Extension type (metadata) over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb" + }, + { + "id": "ext_struct_yx_rb_f0_im1", + "description": "Extension type over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb" + }, + { + "id": "ext_struct_xy_rb_f2_im1", + "description": "Extension type (metadata) over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001d2a7a89d0cd08c78e9a16fff1d4e7db5600bd3b9e9407c6ab3c245b150650455" + }, + { + "id": "ext_struct_yx_rb_f2_im1", + "description": "Extension type over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000015a7cc4edc5954bcd08d7d331dfe81ca1b319196b62d362e04ce595ca84cbf376" + }, + { + "id": "empty_stream_f1", + "description": "Schema [b, a], zero batches, ordered_columns", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001a0334ecb0161cff7c3008d42ca53d6753aaba6e75e948a1ae7ef6771bbd05bff" + }, + { + "id": "zero_row_rb_f1", + "description": "Schema [b, a], one batch with zero rows, ordered_columns", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAADAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001a0334ecb0161cff7c3008d42ca53d6753aaba6e75e948a1ae7ef6771bbd05bff" + }, + { + "id": "zero_cols_0rows_rb_f0", + "description": "Zero columns, 0 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6" + }, + { + "id": "zero_cols_3rows_rb_f0", + "description": "Zero columns, 3 rows (row count of a zero-column table is not hashed)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6" + }, + { + "id": "zero_cols_0rows_rb_f1", + "description": "Zero columns, 0 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000102cd9a406580a25178a7838fba0e6266f84a8508d93696c2eca2467bbd58c22d" + }, + { + "id": "zero_cols_3rows_rb_f1", + "description": "Zero columns, 3 rows (row count of a zero-column table is not hashed)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000102cd9a406580a25178a7838fba0e6266f84a8508d93696c2eca2467bbd58c22d" + }, + { + "id": "leaf_nulls_rb_f3", + "description": "Nullable leaves with nulls and an all-null Int32 column, flags 3", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAABwAAAANAAAAAQAAACs////EAAAABgAAAAAAAECFAAAAJz///8gAAAAAAAAAQAAAAABAAAAegAAANj///8YAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGEAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAACAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001b4426782caaad59a74937bf850a86141caf138caa1badeaa2420520edb390f24" + }, + { + "id": "nv_null_struct_rb_f0", + "description": "s: Struct? rows [{a:1}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9" + }, + { + "id": "nv_null_fields_rb_f0", + "description": "s: Struct? rows [{a:1}, {a:null}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9" + }, + { + "id": "nv_rows3_rb_f0", + "description": "s: Struct? rows [{a:1}, null, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a" + }, + { + "id": "nv_rows2_rb_f0", + "description": "s: Struct? rows [{a:1}, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a" + }, + { + "id": "nv_list_list_1row_rb_f0", + "description": "c: List?> one row [[1], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006" + }, + { + "id": "nv_list_list_2rows_rb_f0", + "description": "c: List?> two rows [[1]], [[2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006" + }, + { + "id": "nv_list_null_elem_rb_f0", + "description": "l: List?> one row [null, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6" + }, + { + "id": "nv_list_null_fields_elem_rb_f0", + "description": "l: List?> one row [{a:null}, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6" + }, + { + "id": "nv_null_struct_rb_f4", + "description": "s: Struct? rows [{a:1}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001bac1fd3395c1558237b83d1058ddfe0ed147777235b268f915d0db961d5d5a92" + }, + { + "id": "nv_null_fields_rb_f4", + "description": "s: Struct? rows [{a:1}, {a:null}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000013c71bf0f16c580e51fecfe6a319bcabf8726c971c7dae68aadabfae3a2d463ba" + }, + { + "id": "nv_rows3_rb_f4", + "description": "s: Struct? rows [{a:1}, null, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ca0b11291a17b3a74df4d3e07e598df6254f18bea48d6de658bad6ce0764ed2c" + }, + { + "id": "nv_rows2_rb_f4", + "description": "s: Struct? rows [{a:1}, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000014938f09116f0bd0ba424d14c2147fba37f50156ea6a8a16ad6491e7a19fd7b4e" + }, + { + "id": "nv_list_list_1row_rb_f4", + "description": "c: List?> one row [[1], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a12b9454ccc5aba3531a3402e2b245afa5c13aeb7e34760893614025460c3510" + }, + { + "id": "nv_list_list_2rows_rb_f4", + "description": "c: List?> two rows [[1]], [[2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001024d511e3ecf756438dae91a23fc5129a7f075aa30be86f6605370b076567c95" + }, + { + "id": "nv_list_null_elem_rb_f4", + "description": "l: List?> one row [null, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000014be0fee254d85051c22a6be84af446096947a5a04b993571fdbb6ff1967f3113" + }, + { + "id": "nv_list_null_fields_elem_rb_f4", + "description": "l: List?> one row [{a:null}, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000110b24fe51f19bcd11887cc0b00514da0939a1f4e6465852f5b67c2ba5ee8d4fe" + }, + { + "id": "nv_null_struct_rb_f7", + "description": "s: Struct? rows [{a:1}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000178a32a80015616d24eec5c25eca12bbea6685c04bde437c1f1575dfa1afafda3" + }, + { + "id": "nv_null_fields_rb_f7", + "description": "s: Struct? rows [{a:1}, {a:null}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001196f0d60192e3fd1b9cab06112c76238fdb91f17e489099e71551c29faeef270" + }, + { + "id": "nv_rows3_rb_f7", + "description": "s: Struct? rows [{a:1}, null, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000198afb787b75ff51607154462604f6c5a87c59c8b3d559d40ea3633f750cb2794" + }, + { + "id": "nv_rows2_rb_f7", + "description": "s: Struct? rows [{a:1}, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001323fc9c3c1bcd52c819613c152c5f57af4249574a11a1cec936827576f3e507a" + }, + { + "id": "nv_list_list_1row_rb_f7", + "description": "c: List?> one row [[1], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000018c0df99d4e6f5a1e71c6dfcbe32a9812cd8c2027ec6d83d699e52aeff7c6b0bb" + }, + { + "id": "nv_list_list_2rows_rb_f7", + "description": "c: List?> two rows [[1]], [[2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001fbafc458f570526d42a9a81f3ecd8e5e15ca485efab0e1a96a4d84c3c2e2d1c7" + }, + { + "id": "nv_list_null_elem_rb_f7", + "description": "l: List?> one row [null, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000183c17f4fc47ee0bae5018422ed0d792ceeb5d1d8bedec85cc476996b96056a00" + }, + { + "id": "nv_list_null_fields_elem_rb_f7", + "description": "l: List?> one row [{a:null}, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001002591d3d2c26cc8b54288f76f17955ee1563be257ed6ff1671e6511c0481641" + }, + { + "id": "nv_nested_structs_rb_f4", + "description": "o: Struct?>? with nulls at both levels", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000142749678d54b57f5edea35b4cdf05ee82198181e33812ce1b9dea23f3b0b5c71" + }, + { + "id": "nv_nested_structs_rb_f7", + "description": "o: Struct?>? with nulls at both levels", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000137e9864f3f6ecc066f6e970390de95773bf728c664df3ce23b9f5093e038b2a8" + }, + { + "id": "nv_rows3_stream_f4", + "description": "nv_rows3 data split into two batches, nested_validity", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ca0b11291a17b3a74df4d3e07e598df6254f18bea48d6de658bad6ce0764ed2c" + }, + { + "id": "nv_array_rows3_f0", + "description": "hash_array of Struct [{a:1}, null, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a" + }, + { + "id": "nv_array_rows2_f0", + "description": "hash_array of Struct [{a:1}, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a" + }, + { + "id": "nv_array_rows3_f4", + "description": "hash_array of Struct [{a:1}, null, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000012fb1af7ca813fefcbd19e1f6d01edc842e1729b0531d2e1bee183692647d4173" + }, + { + "id": "nv_array_rows2_f4", + "description": "hash_array of Struct [{a:1}, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001db8ad691e48339ba83ece8c4d4aa7a720788c0e415edbfba4d8ad51d2fc0a692" + }, + { + "id": "phys_dict_rb_f0", + "description": "[z: Int32, d: Dictionary]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" + }, + { + "id": "phys_utf8_rb_f0", + "description": "[z: Int32, d: Utf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" + }, + { + "id": "phys_large_utf8_rb_f0", + "description": "[z: Int32, d: LargeUtf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" + }, + { + "id": "phys_dict_rb_f3", + "description": "[z: Int32, d: Dictionary]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" + }, + { + "id": "phys_utf8_rb_f3", + "description": "[z: Int32, d: Utf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" + }, + { + "id": "phys_large_utf8_rb_f3", + "description": "[z: Int32, d: LargeUtf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" + }, + { + "id": "phys_dict_rb_f7", + "description": "[z: Int32, d: Dictionary]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" + }, + { + "id": "phys_utf8_rb_f7", + "description": "[z: Int32, d: Utf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" + }, + { + "id": "phys_large_utf8_rb_f7", + "description": "[z: Int32, d: LargeUtf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" + }, + { + "id": "array_struct_xy_f0", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd" + }, + { + "id": "array_struct_yx_f0", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd" + }, + { + "id": "array_struct_xy_f2", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001e79c0ad382c937100b1dba1ae06a2c0b27be7f78cc72a4b37b9c3d0d87348098" + }, + { + "id": "array_struct_yx_f2", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000015fe62c542a14a2b619eca6792dba8d93fa89a87176995a8b5ae6462a8da51788" + }, + { + "id": "array_struct_xy_f6", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001ec888add39caf7a9dedd6ec56bfa446143f3f2abf03848fbf82f61af9cda7215" + }, + { + "id": "array_struct_yx_f6", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000015735e773b173cc5fe0e1e882674f130575b03e4133667062a777592ac31c5faf" + }, + { + "id": "array_list_struct_f2", + "description": "hash_array of List?> with a null row", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000183624352b7ebacda7b8c3a3e8a2e51561b694c3835b8468e5a9fcfac3d488c5b" + }, + { + "id": "array_list_struct_f7", + "description": "hash_array of List?> with a null row", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000106b91fc017c699ca97737d4bc78d5f52525b6406dd3efecb46b902e928731e4e" + }, + { + "id": "combo_sn_yx_3rows_rb_f7", + "description": "Columns s, n; struct y, x; 3 rows; all options on", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001d6b4594d17ae3482c202877531923bb9212bcf8389fb7597b173dc5796079929" + }, + { + "id": "combo_sn_yx_3rows_stream_f7", + "description": "Same data as two batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "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", + "expected_hash": "000001d6b4594d17ae3482c202877531923bb9212bcf8389fb7597b173dc5796079929" + }, + { + "id": "bool_1row_rb_f0", + "description": "b: Boolean non-null [true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31" + }, + { + "id": "bool_3rows_rb_f0", + "description": "b: Boolean non-null [true, false, false]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31" + }, + { + "id": "bool_array_1_f0", + "description": "hash_array of Boolean [true]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005" + }, + { + "id": "bool_array_2_f0", + "description": "hash_array of Boolean [true, false]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005" + }, + { + "id": "bool_1row_rb_f4", + "description": "b: Boolean non-null [true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001e392174345825efe12d76a8cf613d226902dcc594342c537f9d81c528b137531" + }, + { + "id": "bool_3rows_rb_f4", + "description": "b: Boolean non-null [true, false, false]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001b5597cc0ee4c9dc458c9e06baa947609cd923db09dacbe2378f33aaf6c690f14" + }, + { + "id": "bool_array_1_f4", + "description": "hash_array of Boolean [true]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000014e102943402882cc417bc1d710b20cae5f60c411ccea8c77bdc020a884ca1236" + }, + { + "id": "bool_array_2_f4", + "description": "hash_array of Boolean [true, false]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000019f574770ec94ceca20efe47c91263b67b642a106bc40d27345e22d1e72dd2423" + }, + { + "id": "bool_nullable_rb_f0", + "description": "b: Boolean nullable [true, null, false, true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000012374ef8a63a8cfe593283ae0336f8d9ea5a84c534655acd6eff15636812d388b" + }, + { + "id": "bool_nullable_stream_f0", + "description": "Same as two batches [true] + [null, false, true]", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001185dc35a80c8f2e12d34ceaa7062f09b6edbba7131bd7298752debea7e9c9d04" + }, + { + "id": "bool_nullable_rb_f4", + "description": "b: Boolean nullable [true, null, false, true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001f38e97f8e2fe332a95bf129fbc7bd02bf809c7ff2ad345cbed6045ec3085ddf4" + }, + { + "id": "bool_nullable_stream_f4", + "description": "Same as two batches [true] + [null, false, true]", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001f38e97f8e2fe332a95bf129fbc7bd02bf809c7ff2ad345cbed6045ec3085ddf4" + } + ], + "relations": [ + { + "kind": "equal", + "ids": [ + "cols_ab_rb_f0", + "cols_ba_rb_f0" + ], + "why": "column order ignored by default" + }, + { + "kind": "different", + "ids": [ + "cols_ab_rb_f1", + "cols_ba_rb_f1" + ], + "why": "ordered_columns: column order is part of the hash" + }, + { + "kind": "equal", + "ids": [ + "cols_ab_schema_f0", + "cols_ba_schema_f0" + ], + "why": "schema: column order ignored by default" + }, + { + "kind": "different", + "ids": [ + "cols_ab_schema_f1", + "cols_ba_schema_f1" + ], + "why": "schema: ordered_columns" + }, + { + "kind": "equal", + "ids": [ + "cols_ba_stream_f1", + "cols_ba_rb_f1" + ], + "why": "batch-split independence in ordered mode" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f0", + "combo_sn_xy_f0", + "combo_ns_yx_f0", + "combo_sn_yx_f0" + ], + "why": "flags 0: no order matters" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f1", + "combo_ns_yx_f1" + ], + "why": "flags 1: struct order ignored" + }, + { + "kind": "equal", + "ids": [ + "combo_sn_xy_f1", + "combo_sn_yx_f1" + ], + "why": "flags 1: struct order ignored" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f1", + "combo_sn_xy_f1" + ], + "why": "flags 1: column order matters" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f2", + "combo_sn_xy_f2" + ], + "why": "flags 2: column order ignored" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_yx_f2", + "combo_sn_yx_f2" + ], + "why": "flags 2: column order ignored" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f2", + "combo_ns_yx_f2" + ], + "why": "flags 2: struct order matters" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f3", + "combo_sn_xy_f3", + "combo_ns_yx_f3", + "combo_sn_yx_f3" + ], + "why": "flags 3: both orders matter" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f0", + "combo_ns_xy_f1", + "combo_ns_xy_f2", + "combo_ns_xy_f3" + ], + "why": "the four combinations are domain separated" + }, + { + "kind": "equal", + "ids": [ + "nested_struct_ab_schema_f0", + "nested_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "nested_struct_ab_schema_f2", + "nested_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f0", + "list_struct_ba_rb_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "list_struct_ab_rb_f2", + "list_struct_ba_rb_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "fsl_struct_ab_schema_f0", + "fsl_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "fsl_struct_ab_schema_f2", + "fsl_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "map_struct_ab_schema_f0", + "map_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "map_struct_ab_schema_f2", + "map_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f2", + "large_list_struct_ab_rb_f2" + ], + "why": "List and LargeList agree in ordered mode" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f0", + "large_list_struct_ab_rb_f0" + ], + "why": "List and LargeList agree by default" + }, + { + "kind": "different", + "ids": [ + "one_col_rb_f0", + "one_col_rb_f1", + "one_col_rb_f2", + "one_col_rb_f3", + "one_col_rb_f4", + "one_col_rb_f5", + "one_col_rb_f6", + "one_col_rb_f7" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "different", + "ids": [ + "one_col_schema_f0", + "one_col_schema_f1", + "one_col_schema_f2", + "one_col_schema_f3", + "one_col_schema_f4", + "one_col_schema_f5", + "one_col_schema_f6", + "one_col_schema_f7" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "different", + "ids": [ + "one_col_array_f0", + "one_col_array_f1", + "one_col_array_f2", + "one_col_array_f3", + "one_col_array_f4", + "one_col_array_f5", + "one_col_array_f6", + "one_col_array_f7" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "equal", + "ids": [ + "plain_schema_f1_im0", + "plain_schema_f1_im1" + ], + "why": "empty-metadata invariant holds within each mode" + }, + { + "kind": "different", + "ids": [ + "plain_schema_f1_im1", + "meta_schema_f1_im1" + ], + "why": "metadata counts within each mode" + }, + { + "kind": "equal", + "ids": [ + "plain_schema_f7_im0", + "plain_schema_f7_im1" + ], + "why": "empty-metadata invariant holds within each mode" + }, + { + "kind": "different", + "ids": [ + "plain_schema_f7_im1", + "meta_schema_f7_im1" + ], + "why": "metadata counts within each mode" + }, + { + "kind": "equal", + "ids": [ + "ext_struct_xy_rb_f0_im1", + "ext_struct_yx_rb_f0_im1" + ], + "why": "extension storage struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "ext_struct_xy_rb_f2_im1", + "ext_struct_yx_rb_f2_im1" + ], + "why": "extension storage struct order counts with ordered_struct_fields" + }, + { + "kind": "equal", + "ids": [ + "empty_stream_f1", + "zero_row_rb_f1" + ], + "why": "a zero-row batch contributes nothing" + }, + { + "kind": "equal", + "ids": [ + "zero_cols_0rows_rb_f0", + "zero_cols_3rows_rb_f0" + ], + "why": "documented limitation: zero-column tables do not hash their row count" + }, + { + "kind": "equal", + "ids": [ + "zero_cols_0rows_rb_f1", + "zero_cols_3rows_rb_f1" + ], + "why": "documented limitation: zero-column tables do not hash their row count" + }, + { + "kind": "different", + "ids": [ + "zero_cols_0rows_rb_f0", + "zero_cols_0rows_rb_f1" + ], + "why": "zero-column table is still domain separated" + }, + { + "kind": "equal", + "ids": [ + "nv_null_struct_rb_f0", + "nv_null_fields_rb_f0" + ], + "why": "default layout loses this distinction (frozen)" + }, + { + "kind": "different", + "ids": [ + "nv_null_struct_rb_f4", + "nv_null_fields_rb_f4" + ], + "why": "nested_validity records it" + }, + { + "kind": "different", + "ids": [ + "nv_null_struct_rb_f7", + "nv_null_fields_rb_f7" + ], + "why": "nested_validity records it (all options on)" + }, + { + "kind": "equal", + "ids": [ + "nv_rows3_rb_f0", + "nv_rows2_rb_f0" + ], + "why": "default layout loses this distinction (frozen)" + }, + { + "kind": "different", + "ids": [ + "nv_rows3_rb_f4", + "nv_rows2_rb_f4" + ], + "why": "nested_validity records it" + }, + { + "kind": "different", + "ids": [ + "nv_rows3_rb_f7", + "nv_rows2_rb_f7" + ], + "why": "nested_validity records it (all options on)" + }, + { + "kind": "equal", + "ids": [ + "nv_list_list_1row_rb_f0", + "nv_list_list_2rows_rb_f0" + ], + "why": "default layout loses this distinction (frozen)" + }, + { + "kind": "different", + "ids": [ + "nv_list_list_1row_rb_f4", + "nv_list_list_2rows_rb_f4" + ], + "why": "nested_validity records it" + }, + { + "kind": "different", + "ids": [ + "nv_list_list_1row_rb_f7", + "nv_list_list_2rows_rb_f7" + ], + "why": "nested_validity records it (all options on)" + }, + { + "kind": "equal", + "ids": [ + "nv_list_null_elem_rb_f0", + "nv_list_null_fields_elem_rb_f0" + ], + "why": "default layout loses this distinction (frozen)" + }, + { + "kind": "different", + "ids": [ + "nv_list_null_elem_rb_f4", + "nv_list_null_fields_elem_rb_f4" + ], + "why": "nested_validity records it" + }, + { + "kind": "different", + "ids": [ + "nv_list_null_elem_rb_f7", + "nv_list_null_fields_elem_rb_f7" + ], + "why": "nested_validity records it (all options on)" + }, + { + "kind": "equal", + "ids": [ + "nv_rows3_stream_f4", + "nv_rows3_rb_f4" + ], + "why": "batch-split independence with nested_validity" + }, + { + "kind": "equal", + "ids": [ + "nv_array_rows3_f0", + "nv_array_rows2_f0" + ], + "why": "default hash_array drops null struct rows (frozen)" + }, + { + "kind": "different", + "ids": [ + "nv_array_rows3_f4", + "nv_array_rows2_f4" + ], + "why": "nested_validity counts them" + }, + { + "kind": "equal", + "ids": [ + "phys_dict_rb_f0", + "phys_utf8_rb_f0", + "phys_large_utf8_rb_f0" + ], + "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" + }, + { + "kind": "equal", + "ids": [ + "phys_dict_rb_f3", + "phys_utf8_rb_f3", + "phys_large_utf8_rb_f3" + ], + "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" + }, + { + "kind": "equal", + "ids": [ + "phys_dict_rb_f7", + "phys_utf8_rb_f7", + "phys_large_utf8_rb_f7" + ], + "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" + }, + { + "kind": "equal", + "ids": [ + "array_struct_xy_f0", + "array_struct_yx_f0" + ], + "why": "hash_array: struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "array_struct_xy_f2", + "array_struct_yx_f2" + ], + "why": "hash_array: ordered_struct_fields" + }, + { + "kind": "different", + "ids": [ + "array_struct_xy_f6", + "array_struct_yx_f6" + ], + "why": "hash_array: ordered_struct_fields with nested_validity" + }, + { + "kind": "equal", + "ids": [ + "combo_sn_yx_3rows_rb_f7", + "combo_sn_yx_3rows_stream_f7" + ], + "why": "batch-split independence with all options on" + }, + { + "kind": "equal", + "ids": [ + "bool_1row_rb_f0", + "bool_3rows_rb_f0" + ], + "why": "default layout: trailing false Boolean rows are lost (frozen)" + }, + { + "kind": "different", + "ids": [ + "bool_1row_rb_f4", + "bool_3rows_rb_f4" + ], + "why": "third switch: one byte per Boolean value counts them" + }, + { + "kind": "equal", + "ids": [ + "bool_array_1_f0", + "bool_array_2_f0" + ], + "why": "default hash_array: trailing false lost (frozen)" + }, + { + "kind": "different", + "ids": [ + "bool_array_1_f4", + "bool_array_2_f4" + ], + "why": "third switch: counted" + }, + { + "kind": "different", + "ids": [ + "bool_nullable_rb_f0", + "bool_nullable_stream_f0" + ], + "why": "default layout: Boolean data is packed per batch, so batch splits change the hash (frozen)" + }, + { + "kind": "equal", + "ids": [ + "bool_nullable_rb_f4", + "bool_nullable_stream_f4" + ], + "why": "third switch: Boolean is batch-split independent" + } + ] +} diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index c06c85f..561bf5d 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -167,6 +167,22 @@ def test_t5_nested_validity_list_of_nullable_list(self): ) assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + def test_t6_nested_validity_boolean_column(self): + schema = pa.schema([pa.field("b", pa.bool_(), nullable=True)]) + batch = pa.record_batch([pa.array([True, None, False])], schema=schema) + schema_digest = sha(tag(0x04), b'{"b":{"data_type":"Boolean","nullable":true}}') + expected = V + sha( + schema_digest, + u64(3) + b"\x05", # validity [1,0,1] + sha(b"\x01\x00"), # one byte per VALID value: true, false + ) + assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected + + def test_t6_nested_validity_boolean_hash_array(self): + arr = pa.array([True, False, True]) + expected = V + sha(tag(0x04), b'"Boolean"', sha(b"\x01\x00\x01")) + assert ArrowDigester.hash_array(arr, nested_validity=True) == expected + # ── Spec Section 9.3: Phase 1 JSON for every flags value ────────────── @@ -416,7 +432,19 @@ def s_col(child, mask, field=a_null): _batch({"c": pa.array([[None]], type=ls)}), _batch({"c": pa.array([[{"a": None}]], type=ls)}), ) - return {"null_struct": p1, "vanishing_rows": p2, "list_of_nullable_list": p3, "list_of_nullable_struct": p4} + # 5. (9.5.1) non-nullable Boolean: padding bits look like false values + bt = pa.field("b", pa.bool_(), nullable=False) + p5 = ( + pa.record_batch([pa.array([True])], schema=pa.schema([bt])), + pa.record_batch([pa.array([True, False, False])], schema=pa.schema([bt])), + ) + return { + "null_struct": p1, + "vanishing_rows": p2, + "list_of_nullable_list": p3, + "list_of_nullable_struct": p4, + "boolean_padding": p5, + } class TestNestedValidity: @@ -427,6 +455,36 @@ def test_i8_losses(self, case, flags): equal = batch_hash(left, flags) == batch_hash(right, flags) assert equal == (not flags & 0x04) + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_boolean_padding_hash_array(self, flags): + one = ArrowDigester.hash_array(pa.array([True]), **opts(flags)) + two = ArrowDigester.hash_array(pa.array([True, False]), **opts(flags)) + assert (one == two) == (not flags & 0x04) + + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f & 0x04]) + def test_boolean_batch_split_and_slices(self, flags): + """Spec 9.5.1 / I8: Boolean leaves are split- and slice-independent with the third switch.""" + st = pa.struct([pa.field("v", pa.bool_(), nullable=False)]) + cols = { + "b": pa.array([True, False, None, True, True, False, True, False, True]), + "s": pa.array([{"v": i % 3 == 0} for i in range(9)], type=st), + "l": pa.array([[True], [False, True], None, [], [True, True, False], [False], [True], [], [False]]), + } + whole = _batch(cols, nullable=True) + ref = batch_hash(whole, flags) + d = ArrowDigester(whole.schema, **opts(flags)) + for start, length in ((0, 3), (3, 1), (4, 5)): + d.update(whole.slice(start, length)) + assert d.finalize() == ref + d = ArrowDigester(whole.schema, **opts(flags)) + d.update(whole.slice(0, 0)) + d.update(whole) + assert d.finalize() == ref + # non-zero offset slices of an array equal the same values built fresh + assert ArrowDigester.hash_array(cols["b"].slice(3, 5), **opts(flags)) == ArrowDigester.hash_array( + pa.array(cols["b"].slice(3, 5).to_pylist()), **opts(flags) + ) + def test_hash_array_nullable_struct_root_entry(self): """A nullable struct array passed to hash_array gets a validity-only entry at "".""" arr = pa.StructArray.from_arrays( From bee6820fa98da634b930b09960aa430ee0b6a1d3 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:51:11 -0800 Subject: [PATCH 05/49] test: pin known default-mode divergences from Rust as strict xfails; design note (ITL-898) Default Map JSON and the default hash_array non-ASCII escaping differ from Rust in released starfix-python. They are left unchanged (moving released hashes is the developer's decision) and pinned as xfail(strict=True). Co-Authored-By: Claude Opus 5.5 --- .../2026-11-11-ordered-hashing-design.md | 70 ++++++++++++++++++ tests/test_golden_parity_ordered.py | 28 +++++++- tests/test_known_divergences.py | 71 +++++++++++++++++++ 3 files changed, 168 insertions(+), 1 deletion(-) create mode 100644 docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md create mode 100644 tests/test_known_divergences.py diff --git a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md new file mode 100644 index 0000000..2fa2e50 --- /dev/null +++ b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md @@ -0,0 +1,70 @@ +# Ordered and Nested-Validity Hashing Options (Python) + +**Date:** 2026-11-11 +**Issue:** ITL-898 +**Repos:** nauticalab/starfix (Rust, authoritative), nauticalab/starfix-python (this repo) +**Status:** Provisional: the Rust design is not yet approved, and the third option's name may change. + +--- + +## Source of truth + +The byte layout is defined in the Rust repository: `docs/byte-layout-spec.md` Section 9 +(options and flags byte, options tag, ordered Phase 1 JSON, `hash_array` type JSON, nested +validity, Boolean layout under the third option, node-path rejection, streaming, invariants, +worked examples T1 to T6, golden-file format). The design rationale is in the Rust repo at +`docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md`. This document records only the +Python-specific decisions. + +The golden values are produced by Rust (`cargo run --bin emit_golden_ordered`) and copied here +byte for byte as `tests/golden/ordered_v0.5.json`. Python never generates or edits them. + +## API + +Keyword-only arguments with the Rust `HasherConfig` field names, all `False` by default: + +```python +ArrowDigester(schema, *, include_metadata=False, ordered_columns=False, + ordered_struct_fields=False, nested_validity=False) +ArrowDigester.hash_schema(schema, *, include_metadata=..., ordered_columns=..., ordered_struct_fields=..., nested_validity=...) +ArrowDigester.hash_record_batch(batch, *, ...same four...) +ArrowDigester.hash_table(table, *, ...same four...) +ArrowDigester.hash_array(array, *, ordered_columns=..., ordered_struct_fields=..., nested_validity=...) +``` + +Rejections (spec 9.6, 9.7) raise `ValueError`. + +**Renaming an option:** `_OPTION_FLAGS` in `src/starfix/arrow_digester.py` is the single table +of option names and flag bits. A rename changes that table, the keyword in the five +signatures, their docstrings, the README, and the name constants at the top of +`tests/test_ordered_hashing.py`. The golden parity test reads option keys from `_OPTION_FLAGS`. +The name is not hashed, so no hash moves. + +## Implementation notes + +* `flags == 0` takes exactly the previous code paths (`_serialized_schema`, the old + `hash_array` type JSON, the bit-packed Boolean layout, no checks), so every existing hash is + unchanged (invariant I1). All existing tests and golden files pass unmodified. +* With `flags != 0`, JSON is written with raw UTF-8 (`ensure_ascii=False`), as serde_json does, + and `Map` is serialized as the Rust form `{"Map": [, keys_sorted]}`. +* Nested validity threads one boolean through entry extraction and traversal. Booleans are fed + as one byte per valid value under the third option (spec 9.5.1). + +## Known default-mode divergences from Rust (not changed here) + +Found while implementing from the spec. Both predate ITL-898 and are present in the released +starfix-python 0.4.0. Fixing them moves released hashes, which is the developer's decision. +`tests/test_known_divergences.py` pins the Rust values as `xfail(strict=True)` tests; the +two affected golden vectors are marked the same way in `tests/test_golden_parity_ordered.py`. + +| Input | Python today (flags 0) | Rust | +|---|---|---| +| `hash_schema` of a `Map` column | `{"Map":[{"data_type":,"name":"entries","nullable":false},false]}`: the value type and `keys_sorted` are ignored | `{"Map":[{"data_type":{"Struct":[key, value]},"name":"entries","nullable":false},keys_sorted]}` | +| `hash_array` of a struct with a non-ASCII child name | type JSON escapes non-ASCII (`"é"`) | raw UTF-8 (`"é"`) | + +With any option on, Python matches Rust in both cases. + +## Version + +Proposed: 0.5.0, matching the Rust crate (new keyword arguments, new hash modes). The version +comes from git tags (hatch-vcs); nothing is bumped in this change. diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py index c5b9a76..a6114de 100644 --- a/tests/test_golden_parity_ordered.py +++ b/tests/test_golden_parity_ordered.py @@ -98,7 +98,33 @@ def test_fixture_is_well_formed() -> None: assert not unknown, f"relation {rel['ids']} names unknown vector ids {unknown}" -@pytest.mark.parametrize("vector", _vectors(), ids=lambda v: v["id"]) +# Default-mode (no options) vectors on which starfix-python's released output differs +# from Rust. Changing default output moves released hashes; that is the developer's +# decision (see tests/test_known_divergences.py). strict=True: these turn into hard +# failures once the default output is fixed, so the entry must then be removed. +_KNOWN_DEFAULT_MODE_DIVERGENCES = { + "map_struct_ab_schema_f0": "default Map JSON omits the value type (known divergence)", + "map_struct_ba_schema_f0": "default Map JSON omits the value type (known divergence)", +} + + +def _vector_params() -> list[Any]: + params = [] + for v in _vectors(): + reason = _KNOWN_DEFAULT_MODE_DIVERGENCES.get(v["id"]) + marks = [pytest.mark.xfail(strict=True, reason=reason)] if reason else [] + params.append(pytest.param(v, id=v["id"], marks=marks)) + return params + + +def test_known_divergences_are_default_mode_vectors() -> None: + by_id = {v["id"]: v for v in _vectors()} + for vid in _KNOWN_DEFAULT_MODE_DIVERGENCES: + assert vid in by_id, f"known divergence '{vid}' is not in the golden file" + assert not any(_options(by_id[vid]).values()), f"'{vid}' is not a default-mode vector" + + +@pytest.mark.parametrize("vector", _vector_params()) def test_golden_vector(vector: dict[str, Any]) -> None: """Each vector must produce the Rust-authoritative expected_hash.""" got = _hash(vector) diff --git a/tests/test_known_divergences.py b/tests/test_known_divergences.py new file mode 100644 index 0000000..b30f3f4 --- /dev/null +++ b/tests/test_known_divergences.py @@ -0,0 +1,71 @@ +"""Known default-mode divergences from the Rust starfix implementation (ITL-898). + +Each test asserts the Rust value and is marked ``xfail(strict=True)``: it fails today +because starfix-python's released default-mode (no options) output differs from Rust, +and it turns into a hard failure the day the default output is changed to match, so the +marker must then be removed deliberately. Changing a default-mode output moves released +hashes and is the developer's decision; it is not done in ITL-898. + +With any hashing option on (``flags != 0``) Python already uses the Rust form for both +cases, and the golden vectors in ``tests/golden/ordered_v0.5.json`` pin that. +""" + +from __future__ import annotations + +import base64 +import io +import json +from pathlib import Path + +import pyarrow as pa +import pytest + +from starfix.arrow_digester import ArrowDigester + +_GOLDEN = Path(__file__).parent / "golden" / "ordered_v0.5.json" + + +def _golden_vector(vector_id: str) -> dict: + with _GOLDEN.open(encoding="utf-8") as f: + return next(v for v in json.load(f)["vectors"] if v["id"] == vector_id) + + +@pytest.mark.xfail( + strict=True, + reason=( + "Default Map JSON omits the map's value type and keys_sorted: Python emits " + '{"Map":[{"data_type":,"name":"entries","nullable":false},false]}, ' + "Rust emits the entries field (Struct[key, value]) and keys_sorted" + ), +) +@pytest.mark.parametrize("vector_id", ["map_struct_ab_schema_f0", "map_struct_ba_schema_f0"]) +def test_default_map_schema_matches_rust(vector_id: str) -> None: + vector = _golden_vector(vector_id) + schema = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))).schema + assert ArrowDigester.hash_schema(schema).hex() == vector["expected_hash"] + + +def test_default_map_schema_ignores_value_type_today() -> None: + """Documents the consequence: the default schema hash ignores a map's value type.""" + a = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.int8()))]) + b = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.struct([pa.field("x", pa.int64())])))]) + assert ArrowDigester.hash_schema(a) == ArrowDigester.hash_schema(b) + assert ArrowDigester.hash_schema(a, ordered_struct_fields=True) != ArrowDigester.hash_schema( + b, ordered_struct_fields=True + ) + + +# Rust: hash_array of StructArray [{"é": 1}], child Int32 non-null, no options +# (measured on the starfix ITL-898 branch; serde_json writes "é" as raw UTF-8). +_RUST_NON_ASCII_STRUCT_ARRAY = "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c" + + +@pytest.mark.xfail( + strict=True, + reason="Default hash_array type JSON escapes non-ASCII (\\u00e9); Rust writes raw UTF-8", +) +def test_default_hash_array_non_ascii_name_matches_rust() -> None: + arr = pa.StructArray.from_arrays( + [pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32(), nullable=False)] + ) + assert ArrowDigester.hash_array(arr).hex() == _RUST_NON_ASCII_STRUCT_ARRAY From 05cac6b643d4387e01c1ab294e14fb068c6e23f5 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:52:35 -0800 Subject: [PATCH 06/49] ci: let the ordered fixture drift step explain a missing upstream file (ITL-898) Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2e11a02..f7fefa7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -110,8 +110,9 @@ jobs: - name: Fetch authoritative ordered fixture from starfix run: | + # Tolerate a missing file here so the next step prints the explanation. gh api repos/nauticalab/starfix/contents/tests/golden/ordered_v0.5.json \ - --jq '.content' | base64 -d > /tmp/upstream_ordered.json + --jq '.content' | base64 -d > /tmp/upstream_ordered.json || true env: GH_TOKEN: ${{ steps.app-token.outputs.token }} From 98b04c4e8e34aee65844385748d4894a618c2032 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:54:11 -0800 Subject: [PATCH 07/49] test: golden file at starfix e5b49c4 (171 vectors, 73 relations); spec 2.1 and 9.7 tests (ITL-898) - re-copy tests/golden/ordered_v0.5.json byte for byte (sha256 12deacf4...) - names_array_struct_f0 / _int8_f0 are the known default-mode non-ASCII hash_array divergence (strict xfail) - spec 2.1 FixedSizeList and Map examples, JSON text rules, 9.7 metadata check - 9.7 default-mode batch check (Rust checks at flags 0, Python does not): pinned as strict xfails Co-Authored-By: Claude Opus 5.5 --- tests/golden/ordered_v0.5.json | 341 +++++++++++++++++++++++++++- tests/test_golden_parity_ordered.py | 2 + tests/test_known_divergences.py | 71 +++++- tests/test_ordered_hashing.py | 33 +++ 4 files changed, 434 insertions(+), 13 deletions(-) diff --git a/tests/golden/ordered_v0.5.json b/tests/golden/ordered_v0.5.json index 3aa50ad..ca6f669 100644 --- a/tests/golden/ordered_v0.5.json +++ b/tests/golden/ordered_v0.5.json @@ -1,7 +1,7 @@ { "version": "0.5", "generated_by": "cargo run --bin emit_golden_ordered", - "rust_commit": "b826f81662c91ccdd92544a484e14601585e8c57", + "rust_commit": "cf318f6675ff50252cca28442f43f52146e6b3cc", "vectors": [ { "id": "cols_ab_rb_f0", @@ -1608,6 +1608,281 @@ "nested_validity": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", "expected_hash": "000001f38e97f8e2fe332a95bf129fbc7bd02bf809c7ff2ad345cbed6045ec3085ddf4" + }, + { + "id": "names_schema_f0", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "00000158f3ffc55d1fb210829f8ac71f1b4a29f45e70b120217fd17df22abb0eca1a9b" + }, + { + "id": "names_array_struct_f0", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c" + }, + { + "id": "names_schema_f1", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "0000011549b426a5c6fe76ee5b0dce8561aeb4448c86627904d9764bd915917fb8feda" + }, + { + "id": "names_array_struct_f1", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000146e5353e99efadb553b63626e3785e065ea977063290331f6f4cc66254f1efb5" + }, + { + "id": "names_schema_f7", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "00000158f3d79b469fa3908f93bf0521948e82d2c742a631debb55abfe87d98aa75ae5" + }, + { + "id": "names_array_struct_f7", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000011791c000afa0ce2c897e5e6635537d691efe7e7bc7ae6be6589005f8aa805034" + }, + { + "id": "names_array_struct_int8_f0", + "description": "hash_array of Struct<é: Int8 non-null> [{é: 1}], default options", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001e131c1f05f488566a32e4d387451a8998a54d2207416681782e7a2c0ff3affa9" + }, + { + "id": "fsl_int_schema_f0", + "description": "f: FixedSizeList (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696" + }, + { + "id": "fsl_int_schema_f1", + "description": "f: FixedSizeList (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001028f65ed5fcdeb314bb355eedd49c6968b91fc07d3a3048d9868de0075241901" + }, + { + "id": "list_kv_ab_rb_f0", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001622d311ff5b38c734946fffc9088f1dc99bfe8e0cb04ccfda0e420aa8914f4dd" + }, + { + "id": "list_kv_ba_rb_f0", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000015dd41853de5c821a2f13436e7d1886bb606be477024b795d0993cf00f55df2b5" + }, + { + "id": "list_kv_ab_rb_f1", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000013262951dd2bd0d5816a27db1b0dbe6baf6fd321960bdbca93eb77424120754d4" + }, + { + "id": "list_kv_ba_rb_f1", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001b732bdeb1adbe10736db0d382ae346bff3579bcf0c0f726c36097c05621a21ef" + }, + { + "id": "list_kv_ab_rb_f2", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001e3e2ab9ce5627462a6478b88358f11d9e830f9fe0a6e93caea1d99c074bd4ae1" + }, + { + "id": "list_kv_ba_rb_f2", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001934aae7c67907dfb8d81e9065d5882577878dbd6fb9e45a16b70db7a572fe963" + }, + { + "id": "list_kv_ab_rb_f3", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001cc01e2e14642c75fa87a20386fffbc6cbf768573f83746c77236dcfc59ecf72f" + }, + { + "id": "list_kv_ba_rb_f3", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001888c32dcb51501e91305f2b10e384fb4b64f38051fde6ae198a2e354a075e649" + }, + { + "id": "list_kv_ab_rb_f4", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001e7d3f89675621f5a4156f6f078abae23727db8fc317f1cac71e1984e21992ce6" + }, + { + "id": "list_kv_ba_rb_f4", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001ed916278281456016a7a4464aa609718917bb3241fc3dfdab5aa9b195b2b59b6" + }, + { + "id": "list_kv_ab_rb_f5", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000010aebc959d788c3dc406624ce5bc8e8fcd8075b1548cffc3591e1458ff810a49a" + }, + { + "id": "list_kv_ba_rb_f5", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000149081383d6607d80608e51b8b98ef17851e7dd4812a7eef4338767a7f1dfc13a" + }, + { + "id": "list_kv_ab_rb_f6", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001748fdb72d4caf3a1c6801f9e100aa1eec834ece90a80bf9c9ba22dce25c9d006" + }, + { + "id": "list_kv_ba_rb_f6", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001756f035b80282125cf229c8aa85c8d3a57f86d03bde234f60d97c58fce63cab0" + }, + { + "id": "list_kv_ab_rb_f7", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000168c7045a867d7ad44e355b2dd396eeb6a5eaa0755ab51b0e06be7a3fb9ba498f" + }, + { + "id": "list_kv_ba_rb_f7", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "nested_validity": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000165094d74353dc990af3bf495d67dbef64b278e757fed267583a7ce44f7d6088d" } ], "relations": [ @@ -2157,6 +2432,70 @@ "bool_nullable_stream_f4" ], "why": "third switch: Boolean is batch-split independent" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f0", + "list_kv_ba_rb_f0" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f1", + "list_kv_ba_rb_f1" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f2", + "list_kv_ba_rb_f2" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f3", + "list_kv_ba_rb_f3" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f4", + "list_kv_ba_rb_f4" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f5", + "list_kv_ba_rb_f5" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f6", + "list_kv_ba_rb_f6" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f7", + "list_kv_ba_rb_f7" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" } ] } diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py index a6114de..6bec734 100644 --- a/tests/test_golden_parity_ordered.py +++ b/tests/test_golden_parity_ordered.py @@ -105,6 +105,8 @@ def test_fixture_is_well_formed() -> None: _KNOWN_DEFAULT_MODE_DIVERGENCES = { "map_struct_ab_schema_f0": "default Map JSON omits the value type (known divergence)", "map_struct_ba_schema_f0": "default Map JSON omits the value type (known divergence)", + "names_array_struct_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", + "names_array_struct_int8_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", } diff --git a/tests/test_known_divergences.py b/tests/test_known_divergences.py index b30f3f4..1103427 100644 --- a/tests/test_known_divergences.py +++ b/tests/test_known_divergences.py @@ -6,13 +6,15 @@ marker must then be removed deliberately. Changing a default-mode output moves released hashes and is the developer's decision; it is not done in ITL-898. -With any hashing option on (``flags != 0``) Python already uses the Rust form for both -cases, and the golden vectors in ``tests/golden/ordered_v0.5.json`` pin that. +With any hashing option on (``flags != 0``) Python already uses the Rust form for the +two JSON cases and checks every streamed batch, and the golden vectors in +``tests/golden/ordered_v0.5.json`` pin that. """ from __future__ import annotations import base64 +import hashlib import io import json from pathlib import Path @@ -55,17 +57,62 @@ def test_default_map_schema_ignores_value_type_today() -> None: ) -# Rust: hash_array of StructArray [{"é": 1}], child Int32 non-null, no options -# (measured on the starfix ITL-898 branch; serde_json writes "é" as raw UTF-8). -_RUST_NON_ASCII_STRUCT_ARRAY = "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c" - - @pytest.mark.xfail( strict=True, reason="Default hash_array type JSON escapes non-ASCII (\\u00e9); Rust writes raw UTF-8", ) -def test_default_hash_array_non_ascii_name_matches_rust() -> None: - arr = pa.StructArray.from_arrays( - [pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32(), nullable=False)] - ) - assert ArrowDigester.hash_array(arr).hex() == _RUST_NON_ASCII_STRUCT_ARRAY +@pytest.mark.parametrize("vector_id", ["names_array_struct_f0", "names_array_struct_int8_f0"]) +def test_default_hash_array_non_ascii_name_matches_rust(vector_id: str) -> None: + vector = _golden_vector(vector_id) + batch = next(iter(pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))))) + assert ArrowDigester.hash_array(batch.column(0)).hex() == vector["expected_hash"] + + +# Spec Section 2.1 Map example (literal JSON and hash from the spec text). +_SPEC_MAP_JSON = ( + '{"m":{"data_type":{"Map":[{"data_type":{"Struct":[{"data_type":"LargeUtf8","name":"key",' + '"nullable":false},{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":false},' + '{"data_type":"Int32","name":"z","nullable":false}]},"name":"value","nullable":true}]},' + '"name":"entries","nullable":false},false]},"nullable":true}}' +) +_SPEC_MAP_HASH = "000001edad0efdc8086afa34e6633ee4213d2ed803cbd8849e7d062f882f698bdcf897" + + +def _spec_map_schema() -> pa.Schema: + value = pa.struct([pa.field("z", pa.int32(), nullable=False), pa.field("a", pa.int32(), nullable=False)]) + return pa.schema([pa.field("m", pa.map_(pa.utf8(), value), nullable=True)]) + + +def test_spec_map_example_is_self_consistent() -> None: + assert "000001" + hashlib.sha256(_SPEC_MAP_JSON.encode()).hexdigest() == _SPEC_MAP_HASH + + +@pytest.mark.xfail(strict=True, reason="Default Map JSON differs from the spec Section 2.1 form") +def test_default_map_spec_example() -> None: + assert ArrowDigester.hash_schema(_spec_map_schema()).hex() == _SPEC_MAP_HASH + + +def test_map_spec_form_used_with_options() -> None: + """With any option on, Phase 1 uses the spec Section 2.1 Map form (here under the tag).""" + tag = b"\x00starfix-options-v1\x04" + expected = "000001" + hashlib.sha256(tag + _SPEC_MAP_JSON.encode()).hexdigest() + assert ArrowDigester.hash_schema(_spec_map_schema(), nested_validity=True).hex() == expected + + +# Spec Section 9.7: with flags == 0, Rust also checks every batch (Phase 1 JSON equality, +# plus the Phase 2 document with include_metadata). Python has never checked at flags == 0. + + +@pytest.mark.xfail(strict=True, reason="Python does not check batches against the schema with no options") +def test_default_update_rejects_mismatched_batch() -> None: + d = ArrowDigester(pa.schema([pa.field("a", pa.int32())])) + with pytest.raises(ValueError): + d.update(pa.record_batch([pa.array([1], pa.int64())], names=["a"])) + + +@pytest.mark.xfail(strict=True, reason="Python does not check batches against the schema with no options") +def test_default_update_rejects_metadata_mismatch_with_include_metadata() -> None: + d = ArrowDigester(pa.schema([pa.field("a", pa.int32())]), include_metadata=True) + other = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) + with pytest.raises(ValueError): + d.update(pa.record_batch([pa.array([1], pa.int32())], schema=other)) diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index 561bf5d..b2047da 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -270,6 +270,28 @@ def test_metadata_phase2_appended_after_tagged_phase1(self): assert got == V + sha(tag(0x01), phase1, phase2) +class TestSpecSection2Examples: + """Literal examples added to spec Section 2.1 for ITL-898.""" + + def test_fixed_size_list_example(self): + schema = pa.schema([pa.field("f", pa.list_(pa.field("item", pa.int32(), nullable=True), 2), nullable=False)]) + json_ = b'{"f":{"data_type":{"FixedSizeList":[{"data_type":"Int32","nullable":true},2]},"nullable":false}}' + expected = "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696" + assert (V + sha(json_)).hex() == expected + assert ArrowDigester.hash_schema(schema).hex() == expected + + @pytest.mark.parametrize("flags", ALL_FLAGS) + def test_json_text_rules_control_characters(self, flags): + """`ab` serializes as "a\\nb\\u001b"; '/' and U+007F stay raw.""" + schema = pa.schema([pa.field("a\nb\x1b/\x7f\"\\", pa.int8(), nullable=False)]) + name = b'"a\\nb\\u001b/\x7f\\"\\\\"' + if flags & 0x01: + json_ = b'[{"data_type":"Int8","name":' + name + b',"nullable":false}]' + else: + json_ = b"{" + name + b':{"data_type":"Int8","nullable":false}}' + prefix = tag(flags) if flags else b"" + assert ArrowDigester.hash_schema(schema, **opts(flags)) == V + sha(prefix, json_) + # ── Spec Section 9.8: invariants ─────────────────────────────────────── @@ -685,6 +707,17 @@ def test_different_type_rejected(self, flags): with pytest.raises(ValueError, match="does not match"): d.update(other) + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_metadata_mismatch_rejected_with_include_metadata(self, flags): + """Spec 9.7 rule 2: with include_metadata the Phase 2 documents must be equal.""" + plain = pa.schema([pa.field("a", pa.int32())]) + meta = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) + batch = pa.record_batch([pa.array([1], pa.int32())], schema=meta) + ArrowDigester(plain, **opts(flags)).update(batch) # metadata ignored without include_metadata + d = ArrowDigester(plain, include_metadata=True, **opts(flags)) + with pytest.raises(ValueError, match="does not match"): + d.update(batch) + @pytest.mark.parametrize("flags", ALL_FLAGS) def test_equivalent_physical_types_accepted(self, flags): ab, _ = self._schemas() From ea770d0eefe497d66bad269e1fbcda690a8d342f Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:55:09 -0800 Subject: [PATCH 08/49] docs: list all three default-mode divergences in the design note (ITL-898) Co-Authored-By: Claude Opus 5.5 --- .../specs/2026-11-11-ordered-hashing-design.md | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md index 2fa2e50..099168d 100644 --- a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md +++ b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md @@ -52,17 +52,20 @@ The name is not hashed, so no hash moves. ## Known default-mode divergences from Rust (not changed here) -Found while implementing from the spec. Both predate ITL-898 and are present in the released -starfix-python 0.4.0. Fixing them moves released hashes, which is the developer's decision. -`tests/test_known_divergences.py` pins the Rust values as `xfail(strict=True)` tests; the -two affected golden vectors are marked the same way in `tests/test_golden_parity_ordered.py`. +Found while implementing from the spec. All three predate ITL-898 and are present in the +released starfix-python 0.4.0. Fixing them moves released hashes, or rejects batches that are +accepted today, which is the developer's decision. `tests/test_known_divergences.py` pins the +Rust behaviour as `xfail(strict=True)` tests; the four affected golden vectors +(`map_struct_ab_schema_f0`, `map_struct_ba_schema_f0`, `names_array_struct_f0`, +`names_array_struct_int8_f0`) are marked the same way in `tests/test_golden_parity_ordered.py`. | Input | Python today (flags 0) | Rust | |---|---|---| | `hash_schema` of a `Map` column | `{"Map":[{"data_type":,"name":"entries","nullable":false},false]}`: the value type and `keys_sorted` are ignored | `{"Map":[{"data_type":{"Struct":[key, value]},"name":"entries","nullable":false},keys_sorted]}` | -| `hash_array` of a struct with a non-ASCII child name | type JSON escapes non-ASCII (`"é"`) | raw UTF-8 (`"é"`) | +| `hash_array` of a struct with a non-ASCII child name `é` | type JSON escapes it as the six ASCII characters `é` | raw UTF-8 (bytes `c3 a9`), spec 2.1 JSON text rules | +| `update` with a batch whose schema differs (spec 9.7, no options) | accepted and hashed as given | rejected: Phase 1 JSON must match, plus the Phase 2 document with `include_metadata` | -With any option on, Python matches Rust in both cases. +With any option on, Python matches Rust in all three cases. ## Version From 27ab18b593a9c3900d9f2819896cc9c959834f15 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:55:45 -0800 Subject: [PATCH 09/49] docs: show the escaped form in the divergence table (ITL-898) Co-Authored-By: Claude Opus 5.5 --- docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md index 099168d..454d080 100644 --- a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md +++ b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md @@ -62,7 +62,7 @@ Rust behaviour as `xfail(strict=True)` tests; the four affected golden vectors | Input | Python today (flags 0) | Rust | |---|---|---| | `hash_schema` of a `Map` column | `{"Map":[{"data_type":,"name":"entries","nullable":false},false]}`: the value type and `keys_sorted` are ignored | `{"Map":[{"data_type":{"Struct":[key, value]},"name":"entries","nullable":false},keys_sorted]}` | -| `hash_array` of a struct with a non-ASCII child name `é` | type JSON escapes it as the six ASCII characters `é` | raw UTF-8 (bytes `c3 a9`), spec 2.1 JSON text rules | +| `hash_array` of a struct with a non-ASCII child name `é` | type JSON escapes it as the six ASCII characters `\u00e9` | raw UTF-8 (bytes `c3 a9`), spec 2.1 JSON text rules | | `update` with a batch whose schema differs (spec 9.7, no options) | accepted and hashed as given | rejected: Phase 1 JSON must match, plus the Phase 2 document with `include_metadata` | With any option on, Python matches Rust in all three cases. From 4e9f5fd5d467f4ed97ec6213e602c12471b915db Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:56:41 -0800 Subject: [PATCH 10/49] test: tidy ordered hashing tests (ITL-898) Co-Authored-By: Claude Opus 5.5 --- tests/test_ordered_hashing.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index b2047da..40f46c5 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -295,7 +295,7 @@ def test_json_text_rules_control_characters(self, flags): # ── Spec Section 9.8: invariants ─────────────────────────────────────── -def _struct_xy(order: str, nullable_struct: bool = False) -> pa.StructArray: +def _struct_xy(order: str) -> pa.StructArray: vals = {"x": pa.array([1, 2], pa.int32()), "y": pa.array([True, False])} return pa.StructArray.from_arrays( [vals[n] for n in order], @@ -767,4 +767,4 @@ def test_combinations_are_independent_switches(self): """All 8 combinations are accepted and each is reachable by keywords alone.""" schema = pa.schema([pa.field("a", pa.int32())]) for bits in itertools.product([False, True], repeat=3): - ArrowDigester.hash_schema(schema, **dict(zip((OC, OSF, NV), bits))) + ArrowDigester.hash_schema(schema, **dict(zip((OC, OSF, NV), bits, strict=True))) From 2e82a5780f1535bf05503efbced8fafa7176d4ba Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 02:59:44 -0800 Subject: [PATCH 11/49] perf: hash Booleans under nested_validity in bounded chunks (ITL-898) Expanding to one byte per value now works on 64Ki-element chunks via pyarrow compute (filter, cast to uint8) instead of materializing the whole column as a Python list and byte string. The digest input bytes are unchanged. Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 26 +++++++++++++++++++++----- tests/test_ordered_hashing.py | 18 ++++++++++++++++++ 2 files changed, 39 insertions(+), 5 deletions(-) diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index a95a779..317dc7f 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -881,12 +881,28 @@ def _hash_boolean_data(arr, data_digest, effective_nulls) -> None: data_digest.update(bv.raw_bytes()) +# Elements per chunk when expanding Booleans to one byte each (bounds temporary memory). +_BOOLEAN_CHUNK = 1 << 16 + + def _hash_boolean_bytes(arr, data_digest, effective_nulls) -> None: - """Hash boolean data as one byte (0x00/0x01) per valid value (spec Section 9.5.1).""" - values = arr.to_pylist() if effective_nulls is None else [ - arr[i].as_py() for i in range(len(arr)) if effective_nulls[i] - ] - data_digest.update(bytes(1 if v else 0 for v in values)) + """Hash boolean data as one byte (0x00/0x01) per valid value (spec Section 9.5.1). + + Works in chunks of ``_BOOLEAN_CHUNK`` elements: consecutive digest updates give + the same bytes as one update, without expanding the whole column at once. + """ + import pyarrow as pa + import pyarrow.compute as pc + + for start in range(0, len(arr), _BOOLEAN_CHUNK): + chunk = arr.slice(start, _BOOLEAN_CHUNK) + if effective_nulls is not None: + mask = pa.array(effective_nulls[start:start + len(chunk)], pa.bool_()) + chunk = pc.filter(chunk, mask) + as_u8 = pc.cast(chunk, pa.uint8()) + data_digest.update( + as_u8.buffers()[1].to_pybytes()[as_u8.offset:as_u8.offset + len(as_u8)] + ) def _hash_binary_data(arr, data_digest, effective_nulls) -> None: diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index 40f46c5..dbe0458 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -507,6 +507,24 @@ def test_boolean_batch_split_and_slices(self, flags): pa.array(cols["b"].slice(3, 5).to_pylist()), **opts(flags) ) + @pytest.mark.parametrize("chunk", [1, 3, 8, 1 << 16]) + def test_boolean_bytes_hashed_in_bounded_chunks(self, chunk, monkeypatch): + """Chunked hashing gives the spec 9.5.1 bytes across chunk boundaries, nulls and offsets.""" + import starfix.arrow_digester as ad + + monkeypatch.setattr(ad, "_BOOLEAN_CHUNK", chunk) + values = [True, None, False, True, True, None, False, False, True, True, None] + arr = pa.array(values).slice(1, 9) # non-zero offset + valid = [v for v in values[1:10] if v is not None] + bits = sum(1 << i for i, v in enumerate(values[1:10]) if v is not None) + expected = V + sha( + tag(0x04), b'"Boolean"', u64(9) + bits.to_bytes(2, "little"), sha(bytes(int(v) for v in valid)) + ) + assert ArrowDigester.hash_array(arr, nested_validity=True) == expected + no_nulls = pa.array([True, False, True, True, False, True, False]).slice(2, 5) + expected = V + sha(tag(0x04), b'"Boolean"', sha(bytes([1, 1, 0, 1, 0]))) + assert ArrowDigester.hash_array(no_nulls, nested_validity=True) == expected + def test_hash_array_nullable_struct_root_entry(self): """A nullable struct array passed to hash_array gets a validity-only entry at "".""" arr = pa.StructArray.from_arrays( From 1a1aa4b70af3b12239deef3480f478deadce3cd5 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:04:15 -0800 Subject: [PATCH 12/49] feat: spec 2.1 type forms and 2.2.1 map metadata paths with options; golden at starfix 544cb1b (ITL-898) - golden file re-copied byte for byte (226 vectors, 77 relations; sha256 e21dd703...) - with any option on: Null, Interval, Utf8View, BinaryView schema forms and Rust map metadata paths (entries m/, key m//key, value m//value) - default-mode misses are strict xfails; map entries-field metadata vectors are strict xfails because pyarrow drops that metadata on IPC read - README: qualify Rust parity for default calls; document the Boolean effect of nested_validity Co-Authored-By: Claude Opus 5.5 --- README.md | 31 +- .../2026-11-11-ordered-hashing-design.md | 20 +- src/starfix/arrow_digester.py | 44 +- tests/golden/ordered_v0.5.json | 641 +++++++++++++++++- tests/test_golden_parity_ordered.py | 36 +- tests/test_ordered_hashing.py | 37 + 6 files changed, 780 insertions(+), 29 deletions(-) diff --git a/README.md b/README.md index 92c7136..8a39d73 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ Produces stable SHA-256 hashes of Arrow tables, record batches, and arrays that - **Column-order independent** by default — reordering columns or struct fields does not change the hash (opt-in order sensitivity: see [Hashing options](#hashing-options-order-sensitivity-and-nested-validity)) - **Batch-split independent** — splitting data across batches does not change the hash -- **Cross-language compatible** — identical hashes to the Rust implementation +- **Cross-language compatible** — identical hashes to the Rust implementation for the supported types, with a few known exceptions when no hashing option is on (see [Rust compatibility](#rust-compatibility)) ## Installation @@ -65,15 +65,16 @@ A schema with no metadata produces the same hash regardless of `include_metadata Three further keyword-only options, all `False` by default, are accepted by `ArrowDigester(...)`, `hash_schema`, `hash_record_batch`, `hash_table` and -`hash_array`. They have the same names as the Rust `HasherConfig` fields and -produce byte-identical hashes (layout: starfix `docs/byte-layout-spec.md`, -Section 9). +`hash_array`. They have the same names as the Rust `HasherConfig` fields. With +at least one of them on, hashes are byte-identical to Rust; the shared golden +vectors in `tests/golden/ordered_v0.5.json` pin this (layout: starfix +`docs/byte-layout-spec.md`, Section 9). | Option | Effect | |---|---| | `ordered_columns` | The order of the top-level columns is part of the hash. | | `ordered_struct_fields` | The order of struct fields, at every nesting depth (inside lists, struct children, …), is part of the hash. | -| `nested_validity` | Every nullable struct, and every nullable list or struct that is a list element, records its own validity. A null struct then differs from a struct whose fields are all null, null struct rows are counted, and the outer lengths of a list of nullable lists are hashed. | +| `nested_validity` | Every nullable struct, and every nullable list or struct that is a list element, records its own validity. A null struct then differs from a struct whose fields are all null, null struct rows are counted, and the outer lengths of a list of nullable lists are hashed. Every Boolean value (in any column, nullable or not) is also hashed as one byte per valid value. Without this option, `[true]` and `[true, false, false]` in a non-nullable Boolean column hash the same, and a Boolean column's hash depends on how its rows are split into batches. | ```python # A pa.Table whose column order and struct field order are part of its identity @@ -113,6 +114,26 @@ Things to know: `ordered_struct_fields`. - `include_metadata` works with every option as described above. +## Rust compatibility + +With at least one hashing option on, every hash matches the Rust implementation +byte for byte, with one exception: with `include_metadata`, metadata on a map's +*entries* field is not seen, because pyarrow does not keep it when it reads Arrow +data (key and value field metadata are kept). With all options off, the hashes are those of starfix-python 0.4.0, +which differ from Rust in these cases (`tests/test_known_divergences.py` and the +`_f0` entries marked as known divergences in `tests/test_golden_parity_ordered.py`): + +- schemas containing a `Map` column (the map's value type, `keys_sorted` and the + key / entries metadata paths are not hashed as Rust does); +- `hash_array` of a struct whose field names contain non-ASCII characters; +- schemas containing `Null`, `Interval`, `Utf8View` or `BinaryView` columns, which + raise `NotImplementedError` instead of hashing; +- streaming: a batch whose schema differs from the digester's is accepted, while + Rust rejects it. + +Whether to align the default mode with Rust (which would move these existing +Python hashes) is a separate decision. + ## License MIT OR Apache-2.0 diff --git a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md index 454d080..1cb4e7c 100644 --- a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md +++ b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md @@ -52,12 +52,10 @@ The name is not hashed, so no hash moves. ## Known default-mode divergences from Rust (not changed here) -Found while implementing from the spec. All three predate ITL-898 and are present in the +Found while implementing from the spec. All of these predate ITL-898 and are present in the released starfix-python 0.4.0. Fixing them moves released hashes, or rejects batches that are accepted today, which is the developer's decision. `tests/test_known_divergences.py` pins the -Rust behaviour as `xfail(strict=True)` tests; the four affected golden vectors -(`map_struct_ab_schema_f0`, `map_struct_ba_schema_f0`, `names_array_struct_f0`, -`names_array_struct_int8_f0`) are marked the same way in `tests/test_golden_parity_ordered.py`. +Rust behaviour as `xfail(strict=True)` tests; the affected default-mode golden vectors are marked the same way in `tests/test_golden_parity_ordered.py`. | Input | Python today (flags 0) | Rust | |---|---|---| @@ -65,7 +63,19 @@ Rust behaviour as `xfail(strict=True)` tests; the four affected golden vectors | `hash_array` of a struct with a non-ASCII child name `é` | type JSON escapes it as the six ASCII characters `\u00e9` | raw UTF-8 (bytes `c3 a9`), spec 2.1 JSON text rules | | `update` with a batch whose schema differs (spec 9.7, no options) | accepted and hashed as given | rejected: Phase 1 JSON must match, plus the Phase 2 document with `include_metadata` | -With any option on, Python matches Rust in all three cases. +| `hash_schema` with `include_metadata` of a `Map` column with field metadata | value field metadata at `m/`, key skipped | entries at `m/`, key at `m//key`, value at `m//value` (spec 2.2.1) | +| `hash_schema` of `Null`, `Interval`, `Utf8View`, `BinaryView` columns | raises `NotImplementedError` | spec 2.1 forms (`"Null"`, `{"Interval":"DayTime"}`, `"Utf8View"`, `"BinaryView"`) | + +With any option on, Python matches Rust in all of these cases (golden vectors `*_f0` above are +strict xfails; their option-on counterparts pass). + +## pyarrow limitation + +pyarrow does not keep the metadata of a map's *entries* field when it reads Arrow IPC (key +and value field metadata are kept; verified with pyarrow 26). The golden vectors +`meta_map_entries_schema_f1_im1` and `meta_map_all_schema_f1_im1` therefore cannot be +reproduced by any pyarrow-based implementation; they are strict xfails pending a decision in +the Rust spec. ## Version diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 317dc7f..2c0d813 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -134,11 +134,23 @@ def _data_type_to_value(dt: pa.DataType, flags: int = 0) -> object: return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries")), False]} # Primitive / leaf types – must match Arrow-Rust serde - return _primitive_data_type_string(dt) + return _primitive_data_type_string(dt, flags) + + +# Spec Section 2.1 forms of types that the historical (flags == 0) serializer rejects. +# They are used only when an option is on, so default-mode behaviour is unchanged. +_V05_ONLY_TYPE_FORMS = { + "null": "Null", + "month_interval": {"Interval": "YearMonth"}, + "day_time_interval": {"Interval": "DayTime"}, + "month_day_nano_interval": {"Interval": "MonthDayNano"}, + "string_view": "Utf8View", + "binary_view": "BinaryView", +} -def _primitive_data_type_string(dt: pa.DataType) -> object: - """Return the serde_json representation that arrow-rs produces.""" +def _primitive_data_type_string(dt: pa.DataType, flags: int = 0) -> object: + """Return the serde_json representation that arrow-rs produces (spec Section 2.1).""" import pyarrow as pa _simple = { @@ -195,6 +207,9 @@ def _primitive_data_type_string(dt: pa.DataType) -> object: if pa.types.is_fixed_size_binary(dt): return {"FixedSizeBinary": dt.byte_width} + if flags and str(dt) in _V05_ONLY_TYPE_FORMS: + return _V05_ONLY_TYPE_FORMS[str(dt)] + raise NotImplementedError(f"Unsupported data type: {dt}") @@ -353,7 +368,7 @@ def _sort_metadata(metadata) -> dict[str, str]: def _collect_nested_field_metadata( - field, path: str + field, path: str, flags: int = 0 ) -> dict[str, dict[str, str]]: """Recursively collect metadata from a field and its nested children. @@ -364,8 +379,10 @@ def _collect_nested_field_metadata( - Struct children: "{parent_path}/{child_name}" - List/LargeList/FixedSizeList/Map element: "{parent_path}/" (trailing slash, no element name) - For Map types, only the value/item field is traversed; Map key fields are - intentionally skipped (no path exists for them in the data-hashing BTreeMap). + For Map types with ``flags == 0`` (historical form), only the value/item field + is traversed, at "{parent_path}/"; Map key fields are skipped. With any option + on (spec Section 2.2.1), a map's element is its entries field: entries at + "{parent_path}/", key at "{parent_path}//key", value at "{parent_path}//value". """ import pyarrow as pa @@ -378,22 +395,23 @@ def _collect_nested_field_metadata( for i in range(field.type.num_fields): child = field.type.field(i) child_path = f"{path}{DELIMITER}{child.name}" - result.update(_collect_nested_field_metadata(child, child_path)) + result.update(_collect_nested_field_metadata(child, child_path, flags)) elif ( pa.types.is_list(field.type) or pa.types.is_large_list(field.type) or pa.types.is_fixed_size_list(field.type) ): element_path = f"{path}{DELIMITER}" - result.update(_collect_nested_field_metadata(field.type.value_field, element_path)) + result.update(_collect_nested_field_metadata(field.type.value_field, element_path, flags)) elif pa.types.is_map(field.type): element_path = f"{path}{DELIMITER}" - result.update(_collect_nested_field_metadata(field.type.item_field, element_path)) + element = field.type.field(0) if flags else field.type.item_field + result.update(_collect_nested_field_metadata(element, element_path, flags)) return dict(sorted(result.items())) -def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema) -> None: +def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema, flags: int = 0) -> None: """Feed Phase 2 metadata JSON into ``hasher`` (only when metadata is present). Builds a compact JSON string of the form: @@ -411,7 +429,7 @@ def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema) -> None: all_field_meta: dict[str, dict[str, str]] = {} for i in range(len(schema)): field = schema.field(i) - all_field_meta.update(_collect_nested_field_metadata(field, field.name)) + all_field_meta.update(_collect_nested_field_metadata(field, field.name, flags)) meta_doc: dict[str, object] = {} if all_field_meta: @@ -437,7 +455,7 @@ def _schema_key(schema: pa.Schema, include_metadata: bool, flags: int) -> tuple[ """Everything a schema contributes to the schema digest (spec 9.7 check key).""" phase2 = _BytesCollector() if include_metadata: - _update_metadata_hash(phase2, schema) + _update_metadata_hash(phase2, schema, flags) return _phase1_json(schema, flags), bytes(phase2.data) @@ -450,7 +468,7 @@ def _hash_schema(schema: pa.Schema, include_metadata: bool = False, flags: int = else: h.update(_serialized_schema(schema).encode()) if include_metadata: - _update_metadata_hash(h, schema) + _update_metadata_hash(h, schema, flags) return h.digest() diff --git a/tests/golden/ordered_v0.5.json b/tests/golden/ordered_v0.5.json index ca6f669..775c925 100644 --- a/tests/golden/ordered_v0.5.json +++ b/tests/golden/ordered_v0.5.json @@ -1,7 +1,7 @@ { "version": "0.5", "generated_by": "cargo run --bin emit_golden_ordered", - "rust_commit": "cf318f6675ff50252cca28442f43f52146e6b3cc", + "rust_commit": "e5b49c45351194943498a2ef488a388be71a1c1e", "vectors": [ { "id": "cols_ab_rb_f0", @@ -1883,6 +1883,611 @@ "nested_validity": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", "expected_hash": "00000165094d74353dc990af3bf495d67dbef64b278e757fed267583a7ce44f7d6088d" + }, + { + "id": "type_null_schema_f0", + "description": "Schema [c: Null nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQEQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001450e51629d5bf2b2ef7ab0639e64238f7598446f0dbd0716e3d7f4b64b8c640c" + }, + { + "id": "type_boolean_schema_f0", + "description": "Schema [c: Boolean nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001f9913189cc32c79fb14c307c8eef776bfe6a5ac40a7ccc49a0461b5ee557e0d1" + }, + { + "id": "type_int8_schema_f0", + "description": "Schema [c: Int8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "0000012b83e283d49b73e9069da9861fc1741adb391ce8f592220935a64344ada102a8" + }, + { + "id": "type_int16_schema_f0", + "description": "Schema [c: Int16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000001880d3e13346e5b9ee77784fc268e1627cf77e8b3411e11b46f6454c3510e381e" + }, + { + "id": "type_int32_schema_f0", + "description": "Schema [c: Int32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "00000127e2d4e9ff00877d5f7d23ed3881633983fc7aef3b006a96fedb859d128c3989" + }, + { + "id": "type_int64_schema_f0", + "description": "Schema [c: Int64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000001b025613f15b5f393a4989ef73a15771a1102a55ef411a4b632aabade82a3d01b" + }, + { + "id": "type_uint8_schema_f0", + "description": "Schema [c: UInt8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000100824cb9155025aae789d5dd0df53c9c16c88deb0972fc9b1e863c39ec55acbd" + }, + { + "id": "type_uint16_schema_f0", + "description": "Schema [c: UInt16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b0f78a84d6b3598e5526341cd4f4570bc0ec6e98718f4d5249b851c6152eabc7" + }, + { + "id": "type_uint32_schema_f0", + "description": "Schema [c: UInt32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001351c5bba858bc19d1b0e76c645616c137ab578e680a168263de0c183d881ebfe" + }, + { + "id": "type_uint64_schema_f0", + "description": "Schema [c: UInt64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000013f0e525838f78941dd7ebf1cf53a38aab1ce76083120f046e3c7d5d3a1d36674" + }, + { + "id": "type_float16_schema_f0", + "description": "Schema [c: Float16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAAFAAAAAAAAQMQAAAABAAEAAQAAAAAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000014da58ec28052f47317cbc02b5af025698cb2c541ca0c0296a0f37098e1bc8393" + }, + { + "id": "type_float32_schema_f0", + "description": "Schema [c: Float32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b79ddc004ecda1cacf1ca4129c9339f87231e38b3feb324f37505fbb00448261" + }, + { + "id": "type_float64_schema_f0", + "description": "Schema [c: Float64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000018a4b885963f8e74a322a01627a43ace66eff8b29f9bffaae78d75026d6c338f0" + }, + { + "id": "type_date32_schema_f0", + "description": "Schema [c: Date32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000017067a187a25f7004d66cca4b06e7e3e319f7f71288a9fc42df603f092b6c7f4b" + }, + { + "id": "type_date64_schema_f0", + "description": "Schema [c: Date64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001eafdd4283792f22e1655bf61378bdc53de9f32d3b34cba20ee33349b6d215d27" + }, + { + "id": "type_time32_s_schema_f0", + "description": "Schema [c: Time32(Second) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001fedd3327155f022a4dd129ad3ed5afca9999f932498d991cc8efbb8e020052a2" + }, + { + "id": "type_time32_ms_schema_f0", + "description": "Schema [c: Time32(Millisecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001c2e1de3bcbf6a5a5faaec60dce7c65c5124061f0ccb97e7ef165a17a42b2fc4b" + }, + { + "id": "type_time64_us_schema_f0", + "description": "Schema [c: Time64(Microsecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAgBAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000001228968561050acaeb788b5475feba508a6ea8234768429d0671bf0e62d58d71b" + }, + { + "id": "type_time64_ns_schema_f0", + "description": "Schema [c: Time64(Nanosecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "0000018b7675631dcdbdaf3dfa91e3f3286f7211cf2193dcae672411b09afe4050fe59" + }, + { + "id": "type_timestamp_s_naive_schema_f0", + "description": "Schema [c: Timestamp(Second, None) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQoYAAAAAAAAAAQABAAEAAAAAAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000019fe4c7746047294fd6a07264648cedf7f0e64f08a644d779c852d270dde089db" + }, + { + "id": "type_timestamp_ms_utc_schema_f0", + "description": "Schema [c: Timestamp(Millisecond, Some(\"UTC\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQokAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAEAAwAAAFVUQwABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000196d90de77d3557403eb475d0f0d64774319117987aa1c588115c455666c597b5" + }, + { + "id": "type_timestamp_us_offset_schema_f0", + "description": "Schema [c: Timestamp(Microsecond, Some(\"+05:30\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQooAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAIABgAAACswNTozMAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001c87d3b92444ee5a6b5e4e2f3bc098236ba7bcc9524ffe6e58cd012c3092bb922" + }, + { + "id": "type_timestamp_ns_named_tz_schema_f0", + "description": "Schema [c: Timestamp(Nanosecond, Some(\"America/New_York\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQo0AAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAMAEAAAAEFtZXJpY2EvTmV3X1lvcmsAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001940af673c638fc1ff9aefe02078d47ad1713ba21d3916a1a87bdb0ead51afc5e" + }, + { + "id": "type_duration_s_schema_f0", + "description": "Schema [c: Duration(Second) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000019ef92ec048bd73719517bcdd78f1a52e57dd8d3ebbba8c3dbe689bf3473c8454" + }, + { + "id": "type_duration_ms_schema_f0", + "description": "Schema [c: Duration(Millisecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARIQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000015f844828d2b1cf182199ab026ac2903425f0f84898befe53f53b38a8468ae257" + }, + { + "id": "type_duration_us_schema_f0", + "description": "Schema [c: Duration(Microsecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001bc8e82b752d5d898ae332e360b8325e742b6d7359b6b6aed59ff21578b53141e" + }, + { + "id": "type_duration_ns_schema_f0", + "description": "Schema [c: Duration(Nanosecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAwABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001e881ee30b58bdaa77fbc333e13eb21a00d3ca4e96283f1eeb4062fb29995352f" + }, + { + "id": "type_interval_year_month_schema_f0", + "description": "Schema [c: Interval(YearMonth) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQsQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001edfdb7dd18d6d1f1726bd0a820e82c13ba013ca920bd3d93d08530782119785b" + }, + { + "id": "type_interval_day_time_schema_f0", + "description": "Schema [c: Interval(DayTime) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAQABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001ff900d6b57d11a3aed395b0a882a0cdf411450df8a497826e4cbdad57a41217f" + }, + { + "id": "type_interval_month_day_nano_schema_f0", + "description": "Schema [c: Interval(MonthDayNano) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001b8ebd94791c839fcf2572f1abfe6584d39ff559624dc3362f6ff6a9b43bfd9b7" + }, + { + "id": "type_decimal32_schema_f0", + "description": "Schema [c: Decimal32(9, 2) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAAAgAAAAAgAAAAkAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001dd88bf3c39e96145f03d8fc9054089eb4dd8c437d74b1d4aa1b25b8e351e5c75" + }, + { + "id": "type_decimal64_negative_scale_schema_f0", + "description": "Schema [c: Decimal64(18, -3) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAABAAAAA/f///xIAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001e16e0018ba784be83994c7a94db3071ab9c5462566161105d4ef8128105ed816" + }, + { + "id": "type_decimal128_schema_f0", + "description": "Schema [c: Decimal128(38, 10) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQccAAAAAAAAAAgADAAIAAQACAAAAAoAAAAmAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000001ebcc3afc437ac2f831005f29907440ae6d08ab647a04f974be15d44951326683" + }, + { + "id": "type_decimal256_schema_f0", + "description": "Schema [c: Decimal256(76, 0) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQcgAAAAAAAAAAAACgAMAAgAAAAEAAoAAAAAAQAATAAAAAEAAABjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000017bf47db10e1322b3ebd6780afe01406dd3680654a3b77133f8139ebd4c987e04" + }, + { + "id": "type_fixed_size_binary_schema_f0", + "description": "Schema [c: FixedSizeBinary(16) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a1ed63688a1bfef27f1bb08ffbc85de0edc469fc74ca4a78b89d524c1524eaa4" + }, + { + "id": "type_utf8_schema_f0", + "description": "Schema [c: Utf8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8" + }, + { + "id": "type_large_utf8_schema_f0", + "description": "Schema [c: LargeUtf8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8" + }, + { + "id": "type_binary_schema_f0", + "description": "Schema [c: Binary nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5" + }, + { + "id": "type_large_binary_schema_f0", + "description": "Schema [c: LargeBinary nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARMQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5" + }, + { + "id": "type_utf8_view_schema_f0", + "description": "Schema [c: Utf8View nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001c4f113df591f75ffe79c1da85c5000f0ade80eae214b97713872cab348800aa7" + }, + { + "id": "type_binary_view_schema_f0", + "description": "Schema [c: BinaryView nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARcQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001d212dca06f49287359b6359167ac3cc02782572c4463bb552297ae03a347b856" + }, + { + "id": "meta_map_value_schema_f0_im1", + "description": "m: Map, metadata on the value field (path m//value)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000018e90e39f63cff9891fa1536def277ab7c2545567c51cecf37e765e75f0609789" + }, + { + "id": "meta_map_key_schema_f0_im1", + "description": "m: Map, metadata on the key field (path m//key)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000197b0e3e6528d52a065864a687be4a19b4197dfb62a4ca9915c6b7d3e6bd31ee7" + }, + { + "id": "meta_map_entries_schema_f0_im1", + "description": "m: Map, metadata on the entries field (path m/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000138559b12d08a2cd6fc073ad2f98a22d75737b580905227d99207851c25e89951" + }, + { + "id": "meta_map_all_schema_f0_im1", + "description": "m: Map, metadata on entries, key and value", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", + "expected_hash": "0000017f5cbc6a8a7a9e6f8b06fdb33a8689f413b5034a80e41451cc7d3e50d648dbaf" + }, + { + "id": "meta_struct_child_schema_f0_im1", + "description": "s: Struct, metadata on a struct child (path s/a)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000013ad8bf07377e7c14cdf271b6626b203a28f2295391ef0e9ac21d40d99bd0473a" + }, + { + "id": "meta_list_element_schema_f0_im1", + "description": "l: List, metadata on the element field (path l/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000138cb63f6c736f44536dbc3c1cef7a81d6caa89a68a35db9ef4fcb04a82cfe91f" + }, + { + "id": "meta_fsl_element_schema_f0_im1", + "description": "f: FixedSizeList, metadata on the element field (path f/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", + "expected_hash": "00000167f097bbffcd5ab67297252711a30106996ce8d0d7940e91ceab68b69c07023a" + }, + { + "id": "meta_map_value_schema_f1_im1", + "description": "m: Map, metadata on the value field (path m//value)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000113d0fd6b28169745d9c4d182918e571390b1cdc5081347332df240882251759d" + }, + { + "id": "meta_map_key_schema_f1_im1", + "description": "m: Map, metadata on the key field (path m//key)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000114911c97fa61b213f4dad790c41703f48d942ae6dc5c5daedc3f6058445c0015" + }, + { + "id": "meta_map_entries_schema_f1_im1", + "description": "m: Map, metadata on the entries field (path m/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000001a75deaf594d41aa6dd774d1a115aa616f04c70a36e485293823428d2e508d8f3" + }, + { + "id": "meta_map_all_schema_f1_im1", + "description": "m: Map, metadata on entries, key and value", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", + "expected_hash": "000001a6df789e7d95703d35ac88bf1438ef6da2062c332fc369685c2983abf3987407" + }, + { + "id": "meta_struct_child_schema_f1_im1", + "description": "s: Struct, metadata on a struct child (path s/a)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000001116ae1c6756fb49fdc4725823fec527edd01ac1967861bfee2aa1f9173b5c2a7" + }, + { + "id": "meta_list_element_schema_f1_im1", + "description": "l: List, metadata on the element field (path l/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000001f9f1fcf3d5677aacd3ded7dd226567241e40326037a175e03ac1c8f974de1d12" + }, + { + "id": "meta_fsl_element_schema_f1_im1", + "description": "f: FixedSizeList, metadata on the element field (path f/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "nested_validity": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", + "expected_hash": "0000018a1bc48fd6b563121326907f9cd57a3b038a74de116c9ba2594f50d0913bee86" } ], "relations": [ @@ -2496,6 +3101,40 @@ "list_kv_ba_rb_f7" ], "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "equal", + "ids": [ + "type_utf8_schema_f0", + "type_large_utf8_schema_f0" + ], + "why": "Utf8 and LargeUtf8 share the canonical form" + }, + { + "kind": "equal", + "ids": [ + "type_binary_schema_f0", + "type_large_binary_schema_f0" + ], + "why": "Binary and LargeBinary share the canonical form" + }, + { + "kind": "different", + "ids": [ + "type_utf8_schema_f0", + "type_utf8_view_schema_f0" + ], + "why": "Utf8View is not canonicalized" + }, + { + "kind": "different", + "ids": [ + "meta_map_value_schema_f0_im1", + "meta_map_key_schema_f0_im1", + "meta_map_entries_schema_f0_im1", + "meta_map_all_schema_f0_im1" + ], + "why": "metadata on the map's entries, key and value fields is recorded at distinct paths" } ] } diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py index 6bec734..7a7c92b 100644 --- a/tests/test_golden_parity_ordered.py +++ b/tests/test_golden_parity_ordered.py @@ -107,13 +107,35 @@ def test_fixture_is_well_formed() -> None: "map_struct_ba_schema_f0": "default Map JSON omits the value type (known divergence)", "names_array_struct_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", "names_array_struct_int8_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", + # Types the historical serializer rejects (NotImplementedError); options on: supported. + "type_null_schema_f0": "default schema hashing rejects Null (known divergence)", + "type_interval_year_month_schema_f0": "default schema hashing rejects Interval (known divergence)", + "type_interval_day_time_schema_f0": "default schema hashing rejects Interval (known divergence)", + "type_interval_month_day_nano_schema_f0": "default schema hashing rejects Interval (known divergence)", + "type_utf8_view_schema_f0": "default schema hashing rejects Utf8View (known divergence)", + "type_binary_view_schema_f0": "default schema hashing rejects BinaryView (known divergence)", + # Default Phase 2 map paths: value metadata at "m/", key skipped (Rust: entries/key/value). + "meta_map_value_schema_f0_im1": "default Map metadata paths (known divergence)", + "meta_map_key_schema_f0_im1": "default Map metadata paths (known divergence)", + "meta_map_entries_schema_f0_im1": "default Map metadata paths (known divergence)", + "meta_map_all_schema_f0_im1": "default Map metadata paths (known divergence)", } +# Vectors that no pyarrow-based implementation can reproduce: pyarrow drops the metadata +# of a map's entries field when it reads an IPC stream (key and value metadata survive), +# so the input Rust hashed is not visible to Python. Pending a decision in the Rust spec. +_PYARROW_UNREPRESENTABLE = { + "meta_map_entries_schema_f1_im1": "pyarrow drops map entries-field metadata on IPC read", + "meta_map_all_schema_f1_im1": "pyarrow drops map entries-field metadata on IPC read", +} + +_XFAIL_VECTORS = {**_KNOWN_DEFAULT_MODE_DIVERGENCES, **_PYARROW_UNREPRESENTABLE} + def _vector_params() -> list[Any]: params = [] for v in _vectors(): - reason = _KNOWN_DEFAULT_MODE_DIVERGENCES.get(v["id"]) + reason = _XFAIL_VECTORS.get(v["id"]) marks = [pytest.mark.xfail(strict=True, reason=reason)] if reason else [] params.append(pytest.param(v, id=v["id"], marks=marks)) return params @@ -141,18 +163,22 @@ def test_golden_vector(vector: dict[str, Any]) -> None: "relation", _relations(), ids=lambda r: f"{r['kind']}:{'|'.join(r['ids'])}" ) def test_golden_relation(relation: dict[str, Any]) -> None: - """Each relation holds for the pinned values and for the live Python hashes.""" + """Each relation holds for the pinned values and for the live Python hashes. + + Live hashes are compared over the relation's vectors that Python reproduces; the + others (``_XFAIL_VECTORS``) are each covered by their own strict xfail above. + """ by_id = {v["id"]: v for v in _vectors()} ids = relation["ids"] pinned = {i: by_id[i]["expected_hash"] for i in ids} - live = {i: _hash(by_id[i]) for i in ids} + live = {i: _hash(by_id[i]) for i in ids if i not in _XFAIL_VECTORS} for label, hashes in (("pinned", pinned), ("live", live)): if relation["kind"] == "equal": - assert len(set(hashes.values())) == 1, ( + assert len(set(hashes.values())) <= 1, ( f"relation equal {ids} fails on {label} hashes: {hashes} ({relation.get('why', '')})" ) else: - for a, b in itertools.combinations(ids, 2): + for a, b in itertools.combinations(list(hashes), 2): assert hashes[a] != hashes[b], ( f"relation different {ids} fails on {label} hashes: '{a}' == '{b}' " f"({relation.get('why', '')})" diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index dbe0458..8dde963 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -292,6 +292,43 @@ def test_json_text_rules_control_characters(self, flags): prefix = tag(flags) if flags else b"" assert ArrowDigester.hash_schema(schema, **opts(flags)) == V + sha(prefix, json_) +class TestTypeFormsAndMetadataPathsWithOptions: + """Spec 2.1 forms of Null/Interval/view types and 2.2.1 map metadata paths (options on).""" + + @pytest.mark.parametrize( + "factory, form", + [ + ("null", b'"Null"'), + ("month_day_nano_interval", b'{"Interval":"MonthDayNano"}'), + ("string_view", b'"Utf8View"'), + ("binary_view", b'"BinaryView"'), + ], + ) + def test_type_forms(self, factory, form): + if not hasattr(pa, factory): # view types need pyarrow >= 16 + pytest.skip(f"pyarrow {pa.__version__} has no pa.{factory}()") + dt = getattr(pa, factory)() + schema = pa.schema([pa.field("c", dt, nullable=True)]) + json_ = b'[{"data_type":' + form + b',"name":"c","nullable":true}]' + assert ArrowDigester.hash_schema(schema, ordered_columns=True) == V + sha(tag(0x01), json_) + + def test_default_mode_still_rejects_these_types(self): + with pytest.raises(NotImplementedError): + ArrowDigester.hash_schema(pa.schema([pa.field("c", pa.null())])) + + def test_map_key_and_value_metadata_paths(self): + key = pa.field("key", pa.utf8(), nullable=False, metadata={"role": "id"}) + value = pa.field("value", pa.int32(), metadata={"unit": "kg"}) + schema = pa.schema([pa.field("m", pa.map_(key, value), nullable=True)]) + entries = ( + b'{"data_type":{"Struct":[{"data_type":"LargeUtf8","name":"key","nullable":false},' + b'{"data_type":"Int32","name":"value","nullable":true}]},"name":"entries","nullable":false}' + ) + phase1 = b'{"m":{"data_type":{"Map":[' + entries + b',false]},"nullable":true}}' + phase2 = b'{"fields":{"m//key":{"role":"id"},"m//value":{"unit":"kg"}}}' + got = ArrowDigester.hash_schema(schema, include_metadata=True, nested_validity=True) + assert got == V + sha(tag(0x04), phase1, phase2) + # ── Spec Section 9.8: invariants ─────────────────────────────────────── From 42ca15937b3237c2f8ce2ac994595abc9df42ac7 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:07:50 -0800 Subject: [PATCH 13/49] refactor: one-line switches for pending default-mode decisions; lossless-fix scope test (ITL-898) Developer ruling 2026-11-11: the lossless layout becomes the default fix. Prepares that change and the other pending default-mode decisions as isolated module switches (all off; behaviour unchanged): _LOSSLESS_BY_DEFAULT, _FIX_DEFAULT_MAP_JSON, _FIX_DEFAULT_TYPE_JSON_UTF8, _FIX_DEFAULT_TYPE_FORMS, _FIX_DEFAULT_MAP_METADATA_PATHS, _FIX_DEFAULT_BATCH_CHECK. Tests show each flipped switch reproduces the Rust golden values, and that every golden input the 'unaffected' rule covers hashes identically under the lossless layout. Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 49 ++++++++++--- tests/test_known_divergences.py | 66 +++++++++++++++++ tests/test_lossless_fix_scope.py | 119 +++++++++++++++++++++++++++++++ 3 files changed, 226 insertions(+), 8 deletions(-) create mode 100644 tests/test_lossless_fix_scope.py diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 2c0d813..942dfe2 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -22,9 +22,33 @@ class _Hasher(Protocol): def update(self, data: bytes | bytearray, /) -> None: ... +# Hash format version prefix. ITL-898 variant (b), pending the developer's decision: +# bump to b"\x00\x00\x02" so that every hash taken with the fixed layout differs +# from every v0.4.0 hash. VERSION_BYTES = b"\x00\x00\x01" DELIMITER = "/" +# --------------------------------------------------------------------------- +# Default-mode decisions pending for ITL-898. Each is one switch: flipping it to +# True applies the Rust/spec behaviour with no options on (it is already applied +# whenever an option is on). tests/test_known_divergences.py checks each flipped +# switch against the Rust values, and pins the current default as strict xfails. +# --------------------------------------------------------------------------- + +# Lossless layout (spec 9.5 / 9.5.1) in the default: developer ruling 2026-11-11 +# makes it the only layout once the regenerated Rust golden values land. +_LOSSLESS_BY_DEFAULT = False +# Map schema JSON: entries field (Struct[key, value]) and keys_sorted (spec 2.1). +_FIX_DEFAULT_MAP_JSON = False +# hash_array type JSON: non-ASCII written raw, as serde_json does (spec 2.1). +_FIX_DEFAULT_TYPE_JSON_UTF8 = False +# Null / Interval / Utf8View / BinaryView schema forms (spec 2.1), raising today. +_FIX_DEFAULT_TYPE_FORMS = False +# Phase 2 metadata paths of map fields: entries m/, key m//key, value m//value (2.2.1). +_FIX_DEFAULT_MAP_METADATA_PATHS = False +# Streaming: reject a batch whose schema differs from the digester's (spec 9.7). +_FIX_DEFAULT_BATCH_CHECK = False + # Hashing options (spec Section 9.1): keyword name -> bit of the flags byte. # This table is the single place that names the options; the keyword arguments of # the public API must use exactly these names. @@ -53,6 +77,11 @@ def _flags(ordered_columns: bool, ordered_struct_fields: bool, nested_validity: ) +def _lossless(flags: int) -> bool: + """Whether the lossless layout of spec 9.5 / 9.5.1 applies.""" + return _LOSSLESS_BY_DEFAULT or bool(flags & _NESTED_VALIDITY) + + def _options_tag(flags: int) -> bytes: """Options tag (spec Section 9.2): 0x00 || "starfix-options-v1" || flags (20 bytes).""" return _OPTIONS_TAG_PREFIX + bytes([flags]) @@ -125,7 +154,7 @@ def _data_type_to_value(dt: pa.DataType, flags: int = 0) -> object: if pa.types.is_fixed_size_list(dt): return {"FixedSizeList": [_element_type_to_value(dt.value_field, flags), dt.list_size]} if pa.types.is_map(dt): - if flags: + if flags or _FIX_DEFAULT_MAP_JSON: # The entries field (a struct of key and value) and keys_sorted, # as the Rust implementation serializes DataType::Map(entries, sorted). return {"Map": [_inner_field_to_value(dt.field(0), flags), dt.keys_sorted]} @@ -207,7 +236,7 @@ def _primitive_data_type_string(dt: pa.DataType, flags: int = 0) -> object: if pa.types.is_fixed_size_binary(dt): return {"FixedSizeBinary": dt.byte_width} - if flags and str(dt) in _V05_ONLY_TYPE_FORMS: + if (flags or _FIX_DEFAULT_TYPE_FORMS) and str(dt) in _V05_ONLY_TYPE_FORMS: return _V05_ONLY_TYPE_FORMS[str(dt)] raise NotImplementedError(f"Unsupported data type: {dt}") @@ -285,7 +314,7 @@ def _type_json(data_type: pa.DataType, flags: int) -> str: option on, non-ASCII characters are written as raw UTF-8 (as serde_json does). """ value = _sort_json_value(_data_type_to_value(data_type, flags)) - if flags == 0: + if flags == 0 and not _FIX_DEFAULT_TYPE_JSON_UTF8: return json.dumps(value, separators=(",", ":")) return json.dumps(value, separators=(",", ":"), ensure_ascii=False) @@ -405,7 +434,8 @@ def _collect_nested_field_metadata( result.update(_collect_nested_field_metadata(field.type.value_field, element_path, flags)) elif pa.types.is_map(field.type): element_path = f"{path}{DELIMITER}" - element = field.type.field(0) if flags else field.type.item_field + rust_paths = flags or _FIX_DEFAULT_MAP_METADATA_PATHS + element = field.type.field(0) if rust_paths else field.type.item_field result.update(_collect_nested_field_metadata(element, element_path, flags)) return dict(sorted(result.items())) @@ -1046,10 +1076,12 @@ def __init__( self._flags = flags self._schema_digest = _hash_schema(schema, include_metadata=include_metadata, flags=flags) # Spec Section 9.7: with any option on, every batch must match this key. - self._schema_key = _schema_key(schema, include_metadata, flags) if flags else None + self._schema_key = ( + _schema_key(schema, include_metadata, flags) if flags or _FIX_DEFAULT_BATCH_CHECK else None + ) # BTreeMap — sorted by key self._fields: dict[str, tuple] = {} - nv = bool(flags & _NESTED_VALIDITY) + nv = _lossless(flags) for i in range(len(schema)): _extract_fields(schema.field(i), "", self._fields, nv) # Ensure sorted order (Python 3.7+ dicts are insertion-ordered) @@ -1066,9 +1098,10 @@ def update(self, record_batch: pa.RecordBatch) -> None: schema = record_batch.schema if self._flags: _check_schema_node_paths(schema) + if self._schema_key is not None: if _schema_key(schema, self._include_metadata, self._flags) != self._schema_key: raise ValueError(_SCHEMA_MISMATCH) - nv = bool(self._flags & _NESTED_VALIDITY) + nv = _lossless(self._flags) # Traverse each top-level field using the recursive traversal for i in range(len(schema)): field = schema.field(i) @@ -1268,7 +1301,7 @@ def hash_array( import pyarrow as pa flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) - nv = bool(flags & _NESTED_VALIDITY) + nv = _lossless(flags) # Resolve dictionary arrays to their plain value type effective_type = array.type diff --git a/tests/test_known_divergences.py b/tests/test_known_divergences.py index 1103427..3ded7d2 100644 --- a/tests/test_known_divergences.py +++ b/tests/test_known_divergences.py @@ -116,3 +116,69 @@ def test_default_update_rejects_metadata_mismatch_with_include_metadata() -> Non other = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) with pytest.raises(ValueError): d.update(pa.record_batch([pa.array([1], pa.int32())], schema=other)) + + +# ── Each pending default-mode fix is one switch: flipping it reproduces Rust ── + + +def _schema_of(vector: dict) -> pa.Schema: + return pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))).schema + + +@pytest.mark.parametrize( + "switches, vector_ids", + [ + (["_FIX_DEFAULT_MAP_JSON"], ["map_struct_ab_schema_f0", "map_struct_ba_schema_f0"]), + ( + ["_FIX_DEFAULT_TYPE_FORMS"], + [ + "type_null_schema_f0", + "type_interval_year_month_schema_f0", + "type_interval_day_time_schema_f0", + "type_interval_month_day_nano_schema_f0", + "type_utf8_view_schema_f0", + "type_binary_view_schema_f0", + ], + ), + ( + # Map metadata vectors also carry a Map schema, so both map switches apply. + ["_FIX_DEFAULT_MAP_JSON", "_FIX_DEFAULT_MAP_METADATA_PATHS"], + ["meta_map_value_schema_f0_im1", "meta_map_key_schema_f0_im1"], + ), + ], +) +def test_flipping_switch_matches_rust_hash_schema(switches, vector_ids, monkeypatch) -> None: + import starfix.arrow_digester as ad + + for name in switches: + monkeypatch.setattr(ad, name, True) + for vid in vector_ids: + vector = _golden_vector(vid) + got = ArrowDigester.hash_schema(_schema_of(vector), include_metadata=vector["include_metadata"]) + assert got.hex() == vector["expected_hash"], vid + + +def test_flipping_type_json_switch_matches_rust_hash_array(monkeypatch) -> None: + import starfix.arrow_digester as ad + + monkeypatch.setattr(ad, "_FIX_DEFAULT_TYPE_JSON_UTF8", True) + for vid in ("names_array_struct_f0", "names_array_struct_int8_f0"): + vector = _golden_vector(vid) + batch = next(iter(pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))))) + assert ArrowDigester.hash_array(batch.column(0)).hex() == vector["expected_hash"], vid + + +def test_flipping_batch_check_switch_rejects_mismatched_batches(monkeypatch) -> None: + import starfix.arrow_digester as ad + + monkeypatch.setattr(ad, "_FIX_DEFAULT_BATCH_CHECK", True) + d = ArrowDigester(pa.schema([pa.field("a", pa.int32())])) + with pytest.raises(ValueError, match="does not match"): + d.update(pa.record_batch([pa.array([1], pa.int64())], names=["a"])) + d = ArrowDigester(pa.schema([pa.field("a", pa.int32())]), include_metadata=True) + other = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) + with pytest.raises(ValueError, match="does not match"): + d.update(pa.record_batch([pa.array([1], pa.int32())], schema=other)) + # physically equivalent batches stay accepted + d = ArrowDigester(pa.schema([pa.field("s", pa.utf8())])) + d.update(pa.record_batch([pa.array(["x"], pa.large_utf8())], names=["s"])) diff --git a/tests/test_lossless_fix_scope.py b/tests/test_lossless_fix_scope.py new file mode 100644 index 0000000..ac2115d --- /dev/null +++ b/tests/test_lossless_fix_scope.py @@ -0,0 +1,119 @@ +"""Scope of the lossless-layout fix (ITL-898 developer ruling, 2026-11-11). + +The lossless layout (byte-layout spec 9.5 / 9.5.1) becomes the default. Under variant (a) +(version prefix unchanged) hashes of *unaffected* inputs must stay byte-identical. Rule: + + a type is AFFECTED iff it contains a Boolean, a nullable struct, or a list whose + element is a nullable list or a nullable struct (dictionaries are looked through). + +``hash_schema`` is never affected (the layout only changes data entries). For +``hash_array`` the root counts as nullable iff the array contains a null. + +"Affected" is a property of the type: some values of an affected type hash the same in +both layouts (for example a single Boolean value packs to the same byte). +""" + +from __future__ import annotations + +import base64 +import io +import json +from pathlib import Path +from typing import Any + +import pyarrow as pa +import pytest + +import starfix.arrow_digester as ad +from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester + +_GOLDEN_DIR = Path(__file__).parent / "golden" + + +def _strip_dictionary(t: pa.DataType) -> pa.DataType: + while pa.types.is_dictionary(t): + t = t.value_type + return t + + +def affected(t: pa.DataType, nullable: bool) -> bool: + t = _strip_dictionary(t) + if pa.types.is_boolean(t): + return True + if pa.types.is_struct(t): + return nullable or any(affected(t.field(i).type, t.field(i).nullable) for i in range(t.num_fields)) + if pa.types.is_list(t) or pa.types.is_large_list(t): + element = t.value_field + et = _strip_dictionary(element.type) + if element.nullable and (pa.types.is_struct(et) or pa.types.is_list(et) or pa.types.is_large_list(et)): + return True + return affected(element.type, element.nullable) + return False + + +def _vectors() -> list[dict[str, Any]]: + out = [] + for path in sorted(_GOLDEN_DIR.glob("*.json")): + with path.open(encoding="utf-8") as f: + for v in json.load(f)["vectors"]: + # Only vectors without the (retired) third flag describe the default layout. + if not v.get("nested_validity", False): + out.append({**v, "_file": path.name}) + return out + + +def _hash(vector: dict[str, Any]) -> str: + reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))) + schema, batches = reader.schema, list(reader) + options = {k: vector.get(k, False) for k in _OPTION_FLAGS if k != "nested_validity"} + method = vector["method"] + if method == "hash_schema": + return ArrowDigester.hash_schema(schema, include_metadata=vector["include_metadata"], **options).hex() + if method == "hash_array": + return ArrowDigester.hash_array(batches[0].column(0), **options).hex() + d = ArrowDigester(schema, include_metadata=vector["include_metadata"], **options) + for b in batches: + d.update(b) + return d.finalize().hex() + + +def _is_affected(vector: dict[str, Any]) -> bool: + if vector["method"] == "hash_schema": + return False + reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))) + if vector["method"] == "hash_array": + arr = next(iter(reader)).column(0) + return affected(arr.type, arr.null_count > 0) + return any(affected(f.type, f.nullable) for f in reader.schema) + + +@pytest.mark.parametrize("vector", _vectors(), ids=lambda v: f"{v['_file']}:{v['id']}") +def test_unaffected_inputs_hash_identically_under_lossless_layout(vector, monkeypatch) -> None: + if _is_affected(vector): + return # affected inputs may move; their new values are pinned by the Rust golden file + try: + before = _hash(vector) + except NotImplementedError: + return # types the default serializer rejects (see test_known_divergences.py) + monkeypatch.setattr(ad, "_LOSSLESS_BY_DEFAULT", True) + assert _hash(vector) == before, f"unaffected vector {vector['id']} moved under the lossless layout" + + +@pytest.mark.parametrize( + "dt, nullable, expected", + [ + (pa.int32(), True, False), + (pa.bool_(), False, True), + (pa.dictionary(pa.int8(), pa.utf8()), True, False), + (pa.struct([pa.field("a", pa.int32())]), False, False), + (pa.struct([pa.field("a", pa.int32())]), True, True), + (pa.struct([pa.field("s", pa.struct([pa.field("a", pa.int8())]), nullable=True)]), False, True), + (pa.list_(pa.field("item", pa.int32(), nullable=True)), True, False), + (pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=True)), False, True), + (pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=False)), True, False), + (pa.list_(pa.field("item", pa.struct([pa.field("a", pa.int8())]), nullable=True)), False, True), + (pa.list_(pa.field("item", pa.struct([pa.field("a", pa.int8())]), nullable=False)), True, False), + ], +) +def test_affected_rule(dt, nullable, expected) -> None: + assert affected(dt, nullable) is expected From 83a41a18ce72c937f170459ed682026ca676b35b Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:09:04 -0800 Subject: [PATCH 14/49] refactor: tie default-mode fixes to one hash format version constant (ITL-898) Developer decision 2026-11-11: bump the hash format version. _FORMAT_VERSION (1 today) derives VERSION_BYTES and every pending default-mode fix, so moving to format 2 is a one-line change once the regenerated Rust spec and golden file land. No behaviour change. Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 37 +++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 942dfe2..d876ca1 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -22,32 +22,35 @@ class _Hasher(Protocol): def update(self, data: bytes | bytearray, /) -> None: ... -# Hash format version prefix. ITL-898 variant (b), pending the developer's decision: -# bump to b"\x00\x00\x02" so that every hash taken with the fixed layout differs -# from every v0.4.0 hash. -VERSION_BYTES = b"\x00\x00\x01" +# Hash format version (developer decision 2026-11-11: bump it). Format 1 is the +# v0.4.0 layout. Format 2 (pending the regenerated Rust spec and golden file) is the +# corrected lossless layout with every default-mode alignment below; switching to it +# is this one line. The version prefix is the 3-byte big-endian format number. +_FORMAT_VERSION = 1 +VERSION_BYTES = _FORMAT_VERSION.to_bytes(3, "big") DELIMITER = "/" +_FORMAT_2 = _FORMAT_VERSION >= 2 + # --------------------------------------------------------------------------- -# Default-mode decisions pending for ITL-898. Each is one switch: flipping it to -# True applies the Rust/spec behaviour with no options on (it is already applied -# whenever an option is on). tests/test_known_divergences.py checks each flipped -# switch against the Rust values, and pins the current default as strict xfails. +# Default-mode changes that format 2 brings. Each is a separate switch so that it +# can be tested on its own: True applies the Rust/spec behaviour with no options on +# (it already applies whenever an option is on). tests/test_known_divergences.py +# checks each switch against the Rust values and pins format 1 as strict xfails. # --------------------------------------------------------------------------- -# Lossless layout (spec 9.5 / 9.5.1) in the default: developer ruling 2026-11-11 -# makes it the only layout once the regenerated Rust golden values land. -_LOSSLESS_BY_DEFAULT = False +# Lossless layout (spec 9.5 / 9.5.1): developer ruling 2026-11-11, the only layout in format 2. +_LOSSLESS_BY_DEFAULT = _FORMAT_2 # Map schema JSON: entries field (Struct[key, value]) and keys_sorted (spec 2.1). -_FIX_DEFAULT_MAP_JSON = False +_FIX_DEFAULT_MAP_JSON = _FORMAT_2 # hash_array type JSON: non-ASCII written raw, as serde_json does (spec 2.1). -_FIX_DEFAULT_TYPE_JSON_UTF8 = False -# Null / Interval / Utf8View / BinaryView schema forms (spec 2.1), raising today. -_FIX_DEFAULT_TYPE_FORMS = False +_FIX_DEFAULT_TYPE_JSON_UTF8 = _FORMAT_2 +# Null / Interval / Utf8View / BinaryView schema forms (spec 2.1); format 1 raises. +_FIX_DEFAULT_TYPE_FORMS = _FORMAT_2 # Phase 2 metadata paths of map fields: entries m/, key m//key, value m//value (2.2.1). -_FIX_DEFAULT_MAP_METADATA_PATHS = False +_FIX_DEFAULT_MAP_METADATA_PATHS = _FORMAT_2 # Streaming: reject a batch whose schema differs from the digester's (spec 9.7). -_FIX_DEFAULT_BATCH_CHECK = False +_FIX_DEFAULT_BATCH_CHECK = _FORMAT_2 # Hashing options (spec Section 9.1): keyword name -> bit of the flags byte. # This table is the single place that names the options; the keyword arguments of From 4e64254a689e6f355c47e25e2266c491d5170797 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:15:14 -0800 Subject: [PATCH 15/49] fix: look through dictionaries in option-on metadata paths; guard old-pyarrow golden decoding (ITL-898) - with any option on, Phase 2 metadata traversal looks through dictionary types (spec 2.2.1 paths are the 9.6 node paths); format 1 unchanged - golden vectors that pyarrow < 19 (Decimal32/64) or < 16 (view types) cannot decode are strict xfails on those versions only Co-Authored-By: Claude Opus 5.5 --- src/starfix/arrow_digester.py | 29 ++++++++++++++++++----------- tests/_pyarrow_compat.py | 22 ++++++++++++++++++++++ tests/test_golden_parity_ordered.py | 3 ++- tests/test_known_divergences.py | 3 +++ tests/test_lossless_fix_scope.py | 3 +++ tests/test_ordered_hashing.py | 14 ++++++++++++++ 6 files changed, 62 insertions(+), 12 deletions(-) create mode 100644 tests/_pyarrow_compat.py diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index d876ca1..5988ed7 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -47,7 +47,8 @@ def update(self, data: bytes | bytearray, /) -> None: ... _FIX_DEFAULT_TYPE_JSON_UTF8 = _FORMAT_2 # Null / Interval / Utf8View / BinaryView schema forms (spec 2.1); format 1 raises. _FIX_DEFAULT_TYPE_FORMS = _FORMAT_2 -# Phase 2 metadata paths of map fields: entries m/, key m//key, value m//value (2.2.1). +# Phase 2 metadata paths (2.2.1): map entries m/, key m//key, value m//value, and +# dictionaries looked through. _FIX_DEFAULT_MAP_METADATA_PATHS = _FORMAT_2 # Streaming: reject a batch whose schema differs from the digester's (spec 9.7). _FIX_DEFAULT_BATCH_CHECK = _FORMAT_2 @@ -423,22 +424,28 @@ def _collect_nested_field_metadata( if field.metadata: result[path] = _sort_metadata(field.metadata) - if pa.types.is_struct(field.type): - for i in range(field.type.num_fields): - child = field.type.field(i) + # Spec 2.2.1 paths (options on) are the 9.6 node paths: dictionaries are looked + # through and a map's element is its entries field. Format 1 does neither. + rust_paths = flags or _FIX_DEFAULT_MAP_METADATA_PATHS + t = field.type + while rust_paths and pa.types.is_dictionary(t): + t = t.value_type + + if pa.types.is_struct(t): + for i in range(t.num_fields): + child = t.field(i) child_path = f"{path}{DELIMITER}{child.name}" result.update(_collect_nested_field_metadata(child, child_path, flags)) elif ( - pa.types.is_list(field.type) - or pa.types.is_large_list(field.type) - or pa.types.is_fixed_size_list(field.type) + pa.types.is_list(t) + or pa.types.is_large_list(t) + or pa.types.is_fixed_size_list(t) ): element_path = f"{path}{DELIMITER}" - result.update(_collect_nested_field_metadata(field.type.value_field, element_path, flags)) - elif pa.types.is_map(field.type): + result.update(_collect_nested_field_metadata(t.value_field, element_path, flags)) + elif pa.types.is_map(t): element_path = f"{path}{DELIMITER}" - rust_paths = flags or _FIX_DEFAULT_MAP_METADATA_PATHS - element = field.type.field(0) if rust_paths else field.type.item_field + element = t.field(0) if rust_paths else t.item_field result.update(_collect_nested_field_metadata(element, element_path, flags)) return dict(sorted(result.items())) diff --git a/tests/_pyarrow_compat.py b/tests/_pyarrow_compat.py new file mode 100644 index 0000000..1b39b64 --- /dev/null +++ b/tests/_pyarrow_compat.py @@ -0,0 +1,22 @@ +"""Golden vectors that older pyarrow versions cannot decode from Arrow IPC. + +pyproject allows pyarrow >= 14. Decimal32/Decimal64 IPC needs pyarrow >= 19 and the +Utf8View/BinaryView types need pyarrow >= 16. Tests that decode these vectors mark them +as strict expected failures, or leave them out, on such versions only. +""" + +from __future__ import annotations + +import pyarrow as pa + +_NEEDS = { + "decimal32": ({"type_decimal32_schema_f0", "type_decimal64_negative_scale_schema_f0"}, "Decimal32/Decimal64"), + "string_view": ({"type_utf8_view_schema_f0", "type_binary_view_schema_f0"}, "Utf8View/BinaryView"), +} + +UNREADABLE_HERE: dict[str, str] = { + vid: f"pyarrow {pa.__version__} cannot read {what} IPC" + for feature, (ids, what) in _NEEDS.items() + if not hasattr(pa, feature) + for vid in ids +} diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py index 7a7c92b..54181f4 100644 --- a/tests/test_golden_parity_ordered.py +++ b/tests/test_golden_parity_ordered.py @@ -25,6 +25,7 @@ import pyarrow as pa import pytest +from _pyarrow_compat import UNREADABLE_HERE as _UNREADABLE_HERE from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester @@ -129,7 +130,7 @@ def test_fixture_is_well_formed() -> None: "meta_map_all_schema_f1_im1": "pyarrow drops map entries-field metadata on IPC read", } -_XFAIL_VECTORS = {**_KNOWN_DEFAULT_MODE_DIVERGENCES, **_PYARROW_UNREPRESENTABLE} +_XFAIL_VECTORS = {**_KNOWN_DEFAULT_MODE_DIVERGENCES, **_PYARROW_UNREPRESENTABLE, **_UNREADABLE_HERE} def _vector_params() -> list[Any]: diff --git a/tests/test_known_divergences.py b/tests/test_known_divergences.py index 3ded7d2..07c4989 100644 --- a/tests/test_known_divergences.py +++ b/tests/test_known_divergences.py @@ -21,6 +21,7 @@ import pyarrow as pa import pytest +from _pyarrow_compat import UNREADABLE_HERE from starfix.arrow_digester import ArrowDigester @@ -153,6 +154,8 @@ def test_flipping_switch_matches_rust_hash_schema(switches, vector_ids, monkeypa for name in switches: monkeypatch.setattr(ad, name, True) for vid in vector_ids: + if vid in UNREADABLE_HERE: + continue # this pyarrow cannot decode the vector (see _pyarrow_compat) vector = _golden_vector(vid) got = ArrowDigester.hash_schema(_schema_of(vector), include_metadata=vector["include_metadata"]) assert got.hex() == vector["expected_hash"], vid diff --git a/tests/test_lossless_fix_scope.py b/tests/test_lossless_fix_scope.py index ac2115d..e402e30 100644 --- a/tests/test_lossless_fix_scope.py +++ b/tests/test_lossless_fix_scope.py @@ -23,6 +23,7 @@ import pyarrow as pa import pytest +from _pyarrow_compat import UNREADABLE_HERE import starfix.arrow_digester as ad from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester @@ -57,6 +58,8 @@ def _vectors() -> list[dict[str, Any]]: with path.open(encoding="utf-8") as f: for v in json.load(f)["vectors"]: # Only vectors without the (retired) third flag describe the default layout. + if v["id"] in UNREADABLE_HERE: + continue # this pyarrow cannot decode the vector (see _pyarrow_compat) if not v.get("nested_validity", False): out.append({**v, "_file": path.name}) return out diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py index 8dde963..90c1d5c 100644 --- a/tests/test_ordered_hashing.py +++ b/tests/test_ordered_hashing.py @@ -316,6 +316,20 @@ def test_default_mode_still_rejects_these_types(self): with pytest.raises(NotImplementedError): ArrowDigester.hash_schema(pa.schema([pa.field("c", pa.null())])) + @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) + def test_metadata_paths_look_through_dictionaries(self, flags): + """Spec 2.2.1 paths are the 9.6 node paths, which look through dictionaries.""" + st = pa.struct([pa.field("a", pa.int32(), metadata={"u": "kg"})]) + schema = pa.schema([pa.field("d", pa.dictionary(pa.int32(), st), nullable=True)]) + dt = b'{"Struct":[{"data_type":"Int32","name":"a","nullable":true}]}' + if flags & 0x01: + phase1 = b'[{"data_type":' + dt + b',"name":"d","nullable":true}]' + else: + phase1 = b'{"d":{"data_type":' + dt + b',"nullable":true}}' + phase2 = b'{"fields":{"d/a":{"u":"kg"}}}' + got = ArrowDigester.hash_schema(schema, include_metadata=True, **opts(flags)) + assert got == V + sha(tag(flags), phase1, phase2) + def test_map_key_and_value_metadata_paths(self): key = pa.field("key", pa.utf8(), nullable=False, metadata={"role": "id"}) value = pa.field("value", pa.int32(), metadata={"unit": "kg"}) From 6dda4bf9082d6f9ce7282123e40e129ed94284bd Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:41:00 -0800 Subject: [PATCH 16/49] feat: hash format 2, written from the spec, behind _FORMAT_VERSION (ITL-898) src/starfix/_format2.py implements nauticalab/starfix byte-layout-spec format 2 (041b8f1, provisional): 12-byte header, canonical type JSON with the name-free Map form, Phase 1/2 keyed by node path, extension types (storage type; ARROW:extension:* re-added for registered types), the one rule (entry = validity, lengths, values; row count after the schema digest), hash_array, per-batch schema check, rejections in every mode. Data paths work on Arrow buffers (filter, flatten, bitmaps), linear in rows. tests/test_format2.py checks the 7 worked examples, every final hash the spec prints (examples 1 and 5, Map, FixedSizeList, non-ASCII hash_array), primitive forms, JSON text rules, metadata paths, invariants, rejections, streaming and extension types, byte for byte from the spec text. ArrowDigester dispatches to format 2 when _FORMAT_VERSION == 2 (still 1: nothing changes until the design is approved and the golden lands). Pending spec answers E1-E6 are marked PENDING in the code. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 552 ++++++++++++++++++++++++++++++++++ src/starfix/arrow_digester.py | 40 +++ tests/test_format2.py | 539 +++++++++++++++++++++++++++++++++ 3 files changed, 1131 insertions(+) create mode 100644 src/starfix/_format2.py create mode 100644 tests/test_format2.py diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py new file mode 100644 index 0000000..919b0fb --- /dev/null +++ b/src/starfix/_format2.py @@ -0,0 +1,552 @@ +"""Hash format 2 of the starfix Arrow logical hasher (ITL-898, provisional). + +Implements ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2) from the +specification alone. Section numbers below refer to that document. + +Pending spec decisions (marked ``PENDING`` in the code): E1 extension metadata of types +pyarrow registers in C++; E2/E3 nulls in non-nullable nodes; E4 unsupported data types +with zero rows; E5/E6 nested dictionary and extension values. +""" + +from __future__ import annotations + +import hashlib +import json +import struct +from typing import TYPE_CHECKING, Any + +import pyarrow as pa +import pyarrow.compute as pc + +if TYPE_CHECKING: + from collections.abc import Iterable + +FORMAT = 2 +VERSION_BYTES = FORMAT.to_bytes(3, "big") # Section 1: 24-bit big-endian format number +_HEADER_PREFIX = b"\x00starfix" + VERSION_BYTES + +ORDERED_COLUMNS = 0x01 +ORDERED_STRUCT_FIELDS = 0x02 + +_SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" +_U64 = struct.Struct(" int: + return (ORDERED_COLUMNS if ordered_columns else 0) | (ORDERED_STRUCT_FIELDS if ordered_struct_fields else 0) + + +def header(flags: int) -> bytes: + """Section 1: 0x00 || "starfix" || version || flags (12 bytes).""" + return _HEADER_PREFIX + bytes([flags]) + + +def _json(value: Any) -> str: + """Section 2.1 JSON text rules (serde_json compact form; keys sorted by code point).""" + return json.dumps(value, separators=(",", ":"), ensure_ascii=False, sort_keys=True) + + +# --------------------------------------------------------------------------- +# Types: unwrapping, rejection, canonical JSON (Sections 2.1, 7) +# --------------------------------------------------------------------------- + +def _is_extension(t: pa.DataType) -> bool: + return isinstance(t, pa.BaseExtensionType) + + +def _logical(t: pa.DataType) -> pa.DataType: + """Extension -> storage type, dictionary -> value type (repeatedly).""" + while True: + if _is_extension(t): + t = t.storage_type + elif pa.types.is_dictionary(t): + t = t.value_type + else: + return t + + +def _is_rejected_type(t: pa.DataType) -> bool: + checks = ("is_list_view", "is_large_list_view", "is_union", "is_run_end_encoded") + return any(getattr(pa.types, name, lambda _t: False)(t) for name in checks) + + +def _is_list(t: pa.DataType) -> bool: + return pa.types.is_list(t) or pa.types.is_large_list(t) + + +_UNITS = {"s": "Second", "ms": "Millisecond", "us": "Microsecond", "ns": "Nanosecond"} +_INTERVALS = {"month_interval": "YearMonth", "day_time_interval": "DayTime", "month_day_nano_interval": "MonthDayNano"} +_SIMPLE = { + "null": "Null", "bool": "Boolean", + "int8": "Int8", "int16": "Int16", "int32": "Int32", "int64": "Int64", + "uint8": "UInt8", "uint16": "UInt16", "uint32": "UInt32", "uint64": "UInt64", + "halffloat": "Float16", "float": "Float32", "double": "Float64", + "date32[day]": "Date32", "date64[ms]": "Date64", + "string": "LargeUtf8", "large_string": "LargeUtf8", "binary": "LargeBinary", "large_binary": "LargeBinary", + "string_view": "Utf8View", "binary_view": "BinaryView", +} + + +def type_value(t: pa.DataType, flags: int) -> Any: + """The canonical type JSON value of `t` (Section 2.1).""" + t = _logical(t) + if _is_rejected_type(t): + raise ValueError(f"Unsupported Arrow type for hashing: {t}") + if pa.types.is_struct(t): + children = [t.field(i) for i in range(t.num_fields)] + if not flags & ORDERED_STRUCT_FIELDS: + children.sort(key=lambda f: f.name) + return {"Struct": [_child(c, flags) for c in children]} + if _is_list(t): + return {"LargeList": _element(t.value_field, flags)} + if pa.types.is_fixed_size_list(t): + return {"FixedSizeList": [_element(t.value_field, flags), t.list_size]} + if pa.types.is_map(t): + return {"Map": { + "key": _element(t.key_field, flags), + "keys_sorted": t.keys_sorted, + "value": _element(t.item_field, flags), + }} + name = str(t) + if name in _SIMPLE: + return _SIMPLE[name] + if name in _INTERVALS: + return {"Interval": _INTERVALS[name]} + if pa.types.is_time32(t): + return {"Time32": _UNITS[t.unit]} + if pa.types.is_time64(t): + return {"Time64": _UNITS[t.unit]} + if pa.types.is_timestamp(t): + return {"Timestamp": [_UNITS[t.unit], t.tz]} + if pa.types.is_duration(t): + return {"Duration": _UNITS[t.unit]} + if pa.types.is_decimal(t): + return {f"Decimal{t.bit_width}": [t.precision, t.scale]} + if pa.types.is_fixed_size_binary(t): + return {"FixedSizeBinary": t.byte_width} + raise NotImplementedError(f"Unsupported Arrow type for hashing: {t}") + + +def _child(field: pa.Field, flags: int) -> dict: + return {"data_type": type_value(field.type, flags), "name": field.name, "nullable": field.nullable} + + +def _element(field: pa.Field, flags: int) -> dict: + return {"data_type": type_value(field.type, flags), "nullable": field.nullable} + + +def type_json(t: pa.DataType, flags: int) -> str: + return _json(type_value(t, flags)) + + +# --------------------------------------------------------------------------- +# Node paths (Sections 3.1, 7) and Phase 1 / Phase 2 (Sections 2.2, 2.3) +# --------------------------------------------------------------------------- + +def _join(parent: str, name: str) -> str: + return f"{parent}/{name}" if parent else name + + +def _children(field_type: pa.DataType, path: str) -> list[tuple[str, pa.Field]]: + """The child nodes of a node of this type, as (node path, field).""" + t = _logical(field_type) + if _is_rejected_type(t): + raise ValueError(f"Unsupported Arrow type for hashing: {t}") + if pa.types.is_struct(t): + return [(_join(path, t.field(i).name), t.field(i)) for i in range(t.num_fields)] + if _is_list(t) or pa.types.is_fixed_size_list(t): + return [(path + "/", t.value_field)] + if pa.types.is_map(t): + # Map nodes are p, p/, p//key, p//value; the entries field contributes nothing. + return [(path + "//key", t.key_field), (path + "//value", t.item_field)] + return [] + + +def _walk(root: Iterable[tuple[str, pa.Field]]) -> list[tuple[str, pa.Field]]: + """Every node below and including `root`, rejecting duplicate node paths (Section 7).""" + seen: set[str] = set() + out: list[tuple[str, pa.Field]] = [] + stack = list(reversed(list(root))) + while stack: + path, field = stack.pop() + claimed = [path] + t = _logical(field.type) + if pa.types.is_map(t): + claimed.append(path + "/") # the map's element node + for p in claimed: + if p in seen: + raise ValueError( + f"Ambiguous node path {p!r}: two schema nodes share one path " + "(duplicate names, or a name containing '/' that aliases another node)" + ) + seen.add(p) + out.append((path, field)) + stack.extend(reversed(_children(field.type, path))) + return out + + +def schema_nodes(schema: pa.Schema) -> list[tuple[str, pa.Field]]: + return _walk((schema.field(i).name, schema.field(i)) for i in range(len(schema))) + + +def phase1_json(schema: pa.Schema, flags: int) -> str: + """Section 2.2.""" + fields = [schema.field(i) for i in range(len(schema))] + if flags & ORDERED_COLUMNS: + return _json([_child(f, flags) for f in fields]) + return _json({f.name: {"data_type": type_value(f.type, flags), "nullable": f.nullable} for f in fields}) + + +def _decode(mapping) -> dict[str, str]: + if not mapping: + return {} + return { + (k.decode("utf-8") if isinstance(k, bytes) else k): (v.decode("utf-8") if isinstance(v, bytes) else v) + for k, v in mapping.items() + } + + +def _extension_metadata(t: pa.DataType) -> dict[str, str]: + """ARROW:extension:* keys of a registered extension type (pyarrow hides them). + + PENDING (E1): pyarrow's C++ canonical types have no __arrow_ext_serialize__; their + serialized metadata is what pyarrow exports for the type (its canonical + serialization), not necessarily the bytes that were stored. + """ + if not _is_extension(t): + return {} + if hasattr(t, "__arrow_ext_serialize__"): + serialized = t.__arrow_ext_serialize__() + else: + serialized = _exported_extension_metadata(t) + return {"ARROW:extension:name": t.extension_name, "ARROW:extension:metadata": serialized.decode("utf-8")} + + +def _exported_extension_metadata(t: pa.DataType) -> bytes: + """The serialized metadata pyarrow writes for an extension type (C data interface). + + Exporting a field to the Arrow C data interface (a fixed, documented ABI) carries the + ARROW:extension:name / ARROW:extension:metadata keys in ArrowSchema.metadata, encoded + as int32 count, then per pair int32 length + key bytes, int32 length + value bytes. + """ + import ctypes + + class _ArrowSchema(ctypes.Structure): + pass + + _ArrowSchema._fields_ = [ + ("format", ctypes.c_char_p), + ("name", ctypes.c_char_p), + ("metadata", ctypes.c_void_p), + ("flags", ctypes.c_int64), + ("n_children", ctypes.c_int64), + ("children", ctypes.c_void_p), + ("dictionary", ctypes.c_void_p), + ("release", ctypes.CFUNCTYPE(None, ctypes.c_void_p)), + ("private_data", ctypes.c_void_p), + ] + c_schema = _ArrowSchema() + pa.field("x", t)._export_to_c(ctypes.addressof(c_schema)) + try: + pairs: dict[bytes, bytes] = {} + if c_schema.metadata: + pos = c_schema.metadata + + def read_int32() -> int: + nonlocal pos + value = ctypes.c_int32.from_address(pos).value + pos += 4 + return value + + def read_bytes(n: int) -> bytes: + nonlocal pos + value = ctypes.string_at(pos, n) + pos += n + return value + + for _ in range(read_int32()): + key = read_bytes(read_int32()) + pairs[key] = read_bytes(read_int32()) + return pairs.get(b"ARROW:extension:metadata", b"") + finally: + if c_schema.release: + c_schema.release(ctypes.addressof(c_schema)) + + +def _field_metadata(field: pa.Field) -> dict[str, str]: + meta = _decode(field.metadata) + meta.update(_extension_metadata(field.type)) + return meta + + +def phase2_json(schema: pa.Schema) -> str | None: + """Section 2.3: metadata keyed by node path; None when there is none.""" + fields = {} + for path, field in schema_nodes(schema): + meta = _field_metadata(field) + if meta: + fields[path] = meta + doc: dict[str, Any] = {} + if fields: + doc["fields"] = fields + schema_meta = _decode(schema.metadata) + if schema_meta: + doc["schema"] = schema_meta + return _json(doc) if doc else None + + +def schema_key(schema: pa.Schema, include_metadata: bool, flags: int) -> tuple[str, str | None]: + return phase1_json(schema, flags), (phase2_json(schema) if include_metadata else None) + + +def schema_digest(schema: pa.Schema, include_metadata: bool, flags: int) -> bytes: + """Section 2.5.""" + schema_nodes(schema) # Section 7 rejections + phase1, phase2 = schema_key(schema, include_metadata, flags) + h = hashlib.sha256(header(flags)) + h.update(phase1.encode()) + if phase2 is not None: + h.update(phase2.encode()) + return h.digest() + + +# --------------------------------------------------------------------------- +# Entries (Section 3.2) +# --------------------------------------------------------------------------- + +class _Bits: + """Validity bits: u8 words, Lsb0, appended in bulk.""" + + __slots__ = ("_bytes", "_len") + + def __init__(self) -> None: + self._bytes = bytearray() + self._len = 0 + + def append_bitmap(self, bitmap: pa.Buffer, bit_offset: int, n: int) -> None: + if n: + raw = memoryview(bitmap)[bit_offset >> 3:(bit_offset + n + 7) >> 3] + self._append_int((int.from_bytes(raw, "little") >> (bit_offset & 7)) & ((1 << n) - 1), n) + + def append_true(self, n: int) -> None: + self._append_int((1 << n) - 1, n) + + def _append_int(self, value: int, n: int) -> None: + if n == 0: + return + shift = self._len & 7 + if shift: + value = (value << shift) | self._bytes.pop() + self._bytes += value.to_bytes((n + shift + 7) >> 3, "little") + self._len += n + + def entry_bytes(self) -> bytes: + return _U64.pack(self._len) + bytes(self._bytes) + + +class _Entry: + __slots__ = ("validity", "lengths", "values", "kind") + + def __init__(self, field: pa.Field) -> None: + t = _logical(field.type) + self.kind = "struct" if pa.types.is_struct(t) else "list" if _is_list(t) else "leaf" + self.validity = _Bits() if field.nullable else None + self.lengths = hashlib.sha256() if self.kind == "list" else None + self.values = hashlib.sha256() if self.kind == "leaf" else None + + def to_bytes(self) -> bytes: + out = b"" + if self.validity is not None: + out += self.validity.entry_bytes() + if self.lengths is not None: + out += self.lengths.digest() + if self.values is not None: + out += self.values.digest() + return out + + +def _resolve(arr: pa.Array) -> pa.Array: + """Extension arrays -> storage; dictionary arrays -> decoded values (repeatedly).""" + while True: + if isinstance(arr, pa.ExtensionArray): + arr = arr.storage + elif pa.types.is_dictionary(arr.type): + arr = arr.dictionary_decode() + else: + return arr + + +def _and(a: pa.Array | None, b: pa.Array | None) -> pa.Array | None: + if a is None: + return b + if b is None: + return a + return pc.and_(a, b) + + +_FIXED_WIDTH_CHECKS = ( + pa.types.is_integer, pa.types.is_floating, pa.types.is_date, pa.types.is_time, + pa.types.is_timestamp, pa.types.is_duration, pa.types.is_decimal, pa.types.is_fixed_size_binary, +) + + +def _value_width(t: pa.DataType) -> int | None: + if any(check(t) for check in _FIXED_WIDTH_CHECKS): + return t.byte_width if pa.types.is_fixed_size_binary(t) else t.bit_width // 8 + return None + + +def _hash_values(arr: pa.Array, digest) -> None: + """Section 3.2 leaf value bytes of every element of `arr` (already valid-only).""" + t = arr.type + n = len(arr) + if pa.types.is_boolean(t): + for start in range(0, n, _CHUNK): + chunk = pc.cast(arr.slice(start, _CHUNK), pa.uint8()) + digest.update(memoryview(chunk.buffers()[1])[chunk.offset:chunk.offset + len(chunk)]) + return + width = _value_width(t) + if width is not None: + if n: + raw = memoryview(arr.buffers()[1]) + digest.update(raw[arr.offset * width:(arr.offset + n) * width]) + return + if pa.types.is_string(t) or pa.types.is_large_string(t) or pa.types.is_binary(t) or pa.types.is_large_binary(t): + if n == 0: + return + large = pa.types.is_large_string(t) or pa.types.is_large_binary(t) + size = 8 if large else 4 + bufs = arr.buffers() + offsets = memoryview(bufs[1])[arr.offset * size:(arr.offset + n + 1) * size].cast("q" if large else "i") + data = memoryview(bufs[2]) if bufs[2] is not None else memoryview(b"") + for start in range(0, n, _CHUNK): + parts = [] + for i in range(start, min(start + _CHUNK, n)): + a, b = offsets[i], offsets[i + 1] + parts.append(_U64.pack(b - a)) + parts.append(data[a:b]) + digest.update(b"".join(parts)) + return + # PENDING (E4): Null, FixedSizeList, Map, Interval and view data are unsupported. + raise NotImplementedError(f"Hashing data of type {t} is not supported") + + +def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None, entries: dict) -> None: + """Feed the elements `arr` of the node `field` at `path` into its entry (Section 3.2). + + `enclosing` is the AND of the enclosing struct validities at this list level (None: + all valid). + """ + arr = _resolve(arr) + entry = entries[path] + own = arr.is_valid() if arr.null_count else None + if own is not None and not field.nullable: + # PENDING (E3): a non-nullable node holding nulls where its enclosing structs are valid. + bad = own if enclosing is None else pc.or_(own, pc.invert(enclosing)) + if not pc.all(bad).as_py(): + raise ValueError(f"Non-nullable field {path!r} contains nulls") + bits = _and(own, enclosing) + + if entry.validity is not None: + if bits is None: + entry.validity.append_true(len(arr)) + else: + entry.validity.append_bitmap(bits.buffers()[1], bits.offset, len(bits)) + + if entry.kind == "struct": + t = arr.type + for i in range(t.num_fields): + child = t.field(i) + _visit(child, arr.field(i), _join(path, child.name), bits, entries) + return + + valid = arr if bits is None else arr.filter(bits) + if entry.kind == "list": + if len(valid): + lengths = pc.cast(valid.value_lengths(), pa.uint64()) + entry.lengths.update(memoryview(lengths.buffers()[1])[lengths.offset * 8:(lengths.offset + len(lengths)) * 8]) + # Items of valid list values only; list boundaries reset struct validity. + _visit(arr.type.value_field, valid.flatten(), path + "/", None, entries) + return + + _hash_values(valid, entry.values) + + +def _new_entries(nodes: list[tuple[str, pa.Field]]) -> dict[str, _Entry]: + return {path: _Entry(field) for path, field in nodes} + + +def _finish_entries(entries: dict[str, _Entry]) -> bytes: + return b"".join(entries[path].to_bytes() for path in sorted(entries)) + + +# --------------------------------------------------------------------------- +# Public entry points (Sections 2.5, 3.3, 4, 5) +# --------------------------------------------------------------------------- + +class Digester: + """Streaming record-batch hasher (Section 3.3).""" + + def __init__( + self, + schema: pa.Schema, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> None: + self._flags = flags_of(ordered_columns, ordered_struct_fields) + self._include_metadata = include_metadata + self._schema_digest = schema_digest(schema, include_metadata, self._flags) + self._key = schema_key(schema, include_metadata, self._flags) + self._entries = _new_entries(schema_nodes(schema)) + self._rows = 0 + + def update(self, batch: pa.RecordBatch) -> None: + schema = batch.schema + schema_nodes(schema) # Section 7 + if schema_key(schema, self._include_metadata, self._flags) != self._key: + raise ValueError(_SCHEMA_MISMATCH) + for i in range(batch.num_columns): + field = schema.field(i) + _visit(field, batch.column(i), field.name, None, self._entries) + self._rows += batch.num_rows + + def finalize(self) -> bytes: + final = hashlib.sha256(self._schema_digest) + final.update(_U64.pack(self._rows)) + final.update(_finish_entries(self._entries)) + return VERSION_BYTES + final.digest() + + +def hash_schema(schema: pa.Schema, *, include_metadata: bool = False, ordered_columns: bool = False, + ordered_struct_fields: bool = False) -> bytes: + return VERSION_BYTES + schema_digest(schema, include_metadata, flags_of(ordered_columns, ordered_struct_fields)) + + +def hash_record_batch(batch: pa.RecordBatch, **options: bool) -> bytes: + d = Digester(batch.schema, **options) + d.update(batch) + return d.finalize() + + +def hash_table(table: pa.Table, **options: bool) -> bytes: + d = Digester(table.schema, **options) + for batch in table.to_batches(): + d.update(batch) + return d.finalize() + + +def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct_fields: bool = False) -> bytes: + """Section 4: the array is the node at path "" (nullable iff it has a null).""" + flags = flags_of(ordered_columns, ordered_struct_fields) + root = pa.field("", array.type, nullable=array.null_count > 0) + nodes = _walk([("", root)]) + entries = _new_entries(nodes) + _visit(root, array, "", None, entries) + final = hashlib.sha256(header(flags)) + final.update(type_json(array.type, flags).encode()) + final.update(_U64.pack(len(array))) + final.update(_finish_entries(entries)) + return VERSION_BYTES + final.digest() diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 5988ed7..01a719f 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -81,6 +81,12 @@ def _flags(ordered_columns: bool, ordered_struct_fields: bool, nested_validity: ) +def _reject_nested_validity(nested_validity: bool) -> None: + """Format 2 has no third option: its layout is always lossless (spec format 2, §1).""" + if nested_validity: + raise TypeError("nested_validity is not an option in hash format 2 (its layout is always lossless)") + + def _lossless(flags: int) -> bool: """Whether the lossless layout of spec 9.5 / 9.5.1 applies.""" return _LOSSLESS_BY_DEFAULT or bool(flags & _NESTED_VALIDITY) @@ -1078,6 +1084,18 @@ def __init__( Raises: ValueError: With any option on, if ``schema`` is rejected (spec 9.6). """ + if _FORMAT_2: + _reject_nested_validity(nested_validity) + from starfix import _format2 + + self._format2 = _format2.Digester( + schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + ) + return + self._format2 = None flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) if flags: _check_schema_node_paths(schema) @@ -1105,6 +1123,9 @@ def update(self, record_batch: pa.RecordBatch) -> None: (spec 9.6) or does not match the digester's schema under its options (spec 9.7). """ + if self._format2 is not None: + self._format2.update(record_batch) + return schema = record_batch.schema if self._flags: _check_schema_node_paths(schema) @@ -1128,6 +1149,8 @@ def update(self, record_batch: pa.RecordBatch) -> None: def finalize(self) -> bytes: """Consume the digester and return the versioned hash (spec Section 5).""" + if self._format2 is not None: + return self._format2.finalize() final_digest = hashlib.sha256() final_digest.update(self._schema_digest) for _path, entry in sorted(self._fields.items()): @@ -1173,6 +1196,16 @@ def hash_schema( Raises: ValueError: With any option on, if ``schema`` is rejected (spec 9.6). """ + if _FORMAT_2: + _reject_nested_validity(nested_validity) + from starfix import _format2 + + return _format2.hash_schema( + schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + ) flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) if flags: _check_schema_node_paths(schema) @@ -1310,6 +1343,13 @@ def hash_array( """ import pyarrow as pa + if _FORMAT_2: + _reject_nested_validity(nested_validity) + from starfix import _format2 + + return _format2.hash_array( + array, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields + ) flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) nv = _lossless(flags) diff --git a/tests/test_format2.py b/tests/test_format2.py new file mode 100644 index 0000000..7c4263a --- /dev/null +++ b/tests/test_format2.py @@ -0,0 +1,539 @@ +"""Hash format 2 (ITL-898), checked byte for byte against the specification. + +Spec: ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2, commit 041b8f1). Every +expected value is built here from the literal SHA-256 inputs in the spec, or is a final +hash the spec prints; never from the implementation under test. Cross-language values are +pinned separately by the Rust golden file once it lands. +""" + +from __future__ import annotations + +import hashlib +import struct + +import pyarrow as pa +import pytest + +from starfix import _format2 as f2 + +V = b"\x00\x00\x02" + + +def header(flags: int) -> bytes: + return bytes.fromhex("00 73 74 61 72 66 69 78 00 00 02".replace(" ", "")) + bytes([flags]) + + +def sha(*parts: bytes) -> bytes: + h = hashlib.sha256() + for p in parts: + h.update(p) + return h.digest() + + +def u64(n: int) -> bytes: + return struct.pack(" bytes: + return b"".join(struct.pack(" None: + assert f2.header(0x03) == header(0x03) + assert len(f2.header(0)) == 12 + assert f2.VERSION_BYTES == V + + +# ── Section 2.1: canonical type JSON examples with printed hashes ─────── + + +def test_map_example() -> None: + value = pa.struct([pa.field("z", pa.int32(), nullable=False), pa.field("a", pa.int32(), nullable=False)]) + schema = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.field("value", value, nullable=True)), nullable=True)]) + json_ = ( + b'{"m":{"data_type":{"Map":{"key":{"data_type":"LargeUtf8","nullable":false},"keys_sorted":false,' + b'"value":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":false},' + b'{"data_type":"Int32","name":"z","nullable":false}]},"nullable":true}}},"nullable":true}}' + ) + expected = "0000021c34e18fc2130624f527774ee7992b42234963037109d81715bbacd180adcf1f" + assert (V + sha(header(0), json_)).hex() == expected + assert f2.hash_schema(schema).hex() == expected + + +def test_fixed_size_list_example() -> None: + schema = pa.schema([pa.field("f", pa.list_(pa.field("item", pa.int32(), nullable=True), 2), nullable=False)]) + expected = "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc" + json_ = b'{"f":{"data_type":{"FixedSizeList":[{"data_type":"Int32","nullable":true},2]},"nullable":false}}' + assert (V + sha(header(0), json_)).hex() == expected + assert f2.hash_schema(schema).hex() == expected + + +def test_hash_array_non_ascii_example() -> None: + arr = pa.StructArray.from_arrays([pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32(), nullable=False)]) + expected = "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728" + assert f2.hash_array(arr).hex() == expected + + +def test_json_text_rules() -> None: + schema = pa.schema([pa.field("a\nb\x1b/\x7f\"\\é", pa.int8(), nullable=False)]) + name = '"a\\nb\\u001b/\x7f\\"\\\\é"'.encode() + json_ = b"{" + name + b':{"data_type":"Int8","nullable":false}}' + assert f2.hash_schema(schema) == V + sha(header(0), json_) + + +@pytest.mark.parametrize( + "factory, form", + [ + (lambda: pa.null(), '"Null"'), + (lambda: pa.bool_(), '"Boolean"'), + (lambda: pa.int8(), '"Int8"'), + (lambda: pa.uint64(), '"UInt64"'), + (lambda: pa.float16(), '"Float16"'), + (lambda: pa.date64(), '"Date64"'), + (lambda: pa.time32("s"), '{"Time32":"Second"}'), + (lambda: pa.time64("ns"), '{"Time64":"Nanosecond"}'), + (lambda: pa.timestamp("us", tz="UTC"), '{"Timestamp":["Microsecond","UTC"]}'), + (lambda: pa.timestamp("s"), '{"Timestamp":["Second",null]}'), + (lambda: pa.timestamp("ms", tz="+05:30"), '{"Timestamp":["Millisecond","+05:30"]}'), + (lambda: pa.duration("ms"), '{"Duration":"Millisecond"}'), + (lambda: pa.month_day_nano_interval(), '{"Interval":"MonthDayNano"}'), + (lambda: pa.decimal128(38, 10), '{"Decimal128":[38,10]}'), + (lambda: pa.decimal256(40, -3), '{"Decimal256":[40,-3]}'), + (lambda: pa.binary(16), '{"FixedSizeBinary":16}'), + (lambda: pa.utf8(), '"LargeUtf8"'), + (lambda: pa.large_binary(), '"LargeBinary"'), + (lambda: pa.dictionary(pa.int8(), pa.utf8(), ordered=True), '"LargeUtf8"'), + (lambda: pa.list_(pa.field("element", pa.int8(), nullable=False)), + '{"LargeList":{"data_type":"Int8","nullable":false}}'), + ], +) +def test_primitive_and_canonical_forms(factory, form) -> None: + schema = pa.schema([pa.field("c", factory(), nullable=True)]) + json_ = ('{"c":{"data_type":' + form + ',"nullable":true}}').encode() + assert f2.hash_schema(schema) == V + sha(header(0), json_) + + +# ── Section 9: worked examples ───────────────────────────────────────── + + +def test_example_1_record_batch() -> None: + schema = pa.schema([pa.field("a", pa.int32(), nullable=False), pa.field("b", pa.large_utf8(), nullable=True)]) + batch = pa.record_batch([pa.array([1, 2], pa.int32()), pa.array(["x", None], pa.large_utf8())], schema=schema) + schema_digest = sha( + header(0), b'{"a":{"data_type":"Int32","nullable":false},"b":{"data_type":"LargeUtf8","nullable":true}}' + ) + final = sha( + schema_digest, + u64(2), + sha(i32(1, 2)), + u64(2) + b"\x01", + sha(u64(1) + b"x"), + ) + assert (V + final).hex() == "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" + assert f2.hash_record_batch(batch) == V + final + + +def test_example_2_list() -> None: + t = pa.list_(pa.field("item", pa.int32(), nullable=True)) + schema = pa.schema([pa.field("c", t, nullable=True)]) + batch = pa.record_batch([pa.array([[1, None], None, []], t)], schema=schema) + final = sha( + f2.hash_schema(schema)[3:], + u64(3), + u64(3) + b"\x05", + sha(u64(2) + u64(0)), + u64(2) + b"\x01", + sha(i32(1)), + ) + assert f2.hash_record_batch(batch) == V + final + + +def test_example_3_nullable_struct() -> None: + s = pa.StructArray.from_arrays( + [pa.array([5, None, 1], pa.int32())], + fields=[pa.field("a", pa.int32(), nullable=True)], + mask=pa.array([True, False, False]), + ) + schema = pa.schema([pa.field("s", s.type, nullable=True)]) + batch = pa.record_batch([s], schema=schema) + final = sha( + f2.hash_schema(schema)[3:], + u64(3), + u64(3) + b"\x06", + u64(3) + b"\x04", + sha(i32(1)), + ) + assert f2.hash_record_batch(batch) == V + final + + +def test_example_4_list_of_nullable_struct() -> None: + st = pa.struct([pa.field("a", pa.int32(), nullable=True)]) + t = pa.list_(pa.field("item", st, nullable=True)) + schema = pa.schema([pa.field("l", t, nullable=False)]) + batch = pa.record_batch([pa.array([[None, {"a": 4}]], t)], schema=schema) + final = sha( + f2.hash_schema(schema)[3:], + u64(1), + sha(u64(2)), # "l": lengths + u64(2) + b"\x02", # "l/": validity [0,1] + # "l//a" is nullable: validity [0,1] (struct null ANDed), values [4] + u64(2) + b"\x02", + sha(i32(4)), + ) + assert f2.hash_record_batch(batch) == V + final + + +def test_example_4_as_printed_with_non_nullable_child() -> None: + """The spec prints "l//a" without validity: the child a is then non-nullable.""" + st = pa.struct([pa.field("a", pa.int32(), nullable=False)]) + t = pa.list_(pa.field("item", st, nullable=True)) + schema = pa.schema([pa.field("l", t, nullable=False)]) + arr = pa.ListArray.from_arrays( + pa.array([0, 2], pa.int32()), + pa.StructArray.from_arrays([pa.array([0, 4], pa.int32())], fields=list(st), mask=pa.array([True, False])), + ).cast(t) + batch = pa.record_batch([arr], schema=schema) + final = sha(f2.hash_schema(schema)[3:], u64(1), sha(u64(2)), u64(2) + b"\x02", sha(i32(4))) + assert f2.hash_record_batch(batch) == V + final + + +def test_example_5_hash_array() -> None: + expected = V + sha(header(0), b'"Int32"', u64(3), sha(i32(1, 2, 3))) + assert expected.hex() == "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" + assert f2.hash_array(pa.array([1, 2, 3], pa.int32())) == expected + boolean = V + sha(header(0), b'"Boolean"', u64(3), u64(3) + b"\x05", sha(b"\x01\x00")) + assert f2.hash_array(pa.array([True, None, False])) == boolean + + +def test_example_6_options() -> None: + schema = pa.schema([pa.field("b", pa.int32(), nullable=False), pa.field("a", pa.utf8(), nullable=True)]) + json_ = ( + b'[{"data_type":"Int32","name":"b","nullable":false},' + b'{"data_type":"LargeUtf8","name":"a","nullable":true}]' + ) + assert f2.hash_schema(schema, ordered_columns=True) == V + sha(header(0x01), json_) + + +def test_example_7_zero_columns() -> None: + batch = pa.RecordBatch.from_struct_array(pa.array([{}, {}, {}], pa.struct([]))) + assert batch.num_columns == 0 and batch.num_rows == 3 + assert f2.hash_record_batch(batch) == V + sha(sha(header(0), b"{}"), u64(3)) + + +# ── Sections 2.3, 2.4: metadata and names not hashed ─────────────────── + + +def test_phase2_map_value_metadata_path() -> None: + value = pa.field("value", pa.int32(), metadata={"unit": "kg"}) + schema = pa.schema([pa.field("m", pa.map_(pa.utf8(), value), nullable=True)]) + phase1 = ( + b'{"m":{"data_type":{"Map":{"key":{"data_type":"LargeUtf8","nullable":false},"keys_sorted":false,' + b'"value":{"data_type":"Int32","nullable":true}}},"nullable":true}}' + ) + assert f2.hash_schema(schema, include_metadata=True) == V + sha( + header(0), phase1, b'{"fields":{"m//value":{"unit":"kg"}}}' + ) + + +def test_phase2_paths_and_schema_metadata() -> None: + st = pa.struct([pa.field("x", pa.int8(), metadata={"k": "1"})]) + lt = pa.list_(pa.field("element", pa.int8(), metadata={"e": "2"})) + schema = pa.schema( + [pa.field("s", st, metadata={"c": "3"}), pa.field("l", lt), pa.field("d", pa.dictionary(pa.int8(), st))], + metadata={"z": "9", "a": "0"}, + ) + expected_phase2 = ( + b'{"fields":{"d/x":{"k":"1"},"l/":{"e":"2"},"s":{"c":"3"},"s/x":{"k":"1"}},"schema":{"a":"0","z":"9"}}' + ) + phase1 = f2.phase1_json(schema, 0).encode() + assert f2.hash_schema(schema, include_metadata=True) == V + sha(header(0), phase1, expected_phase2) + + +def test_include_metadata_without_metadata_is_invariant() -> None: + schema = pa.schema([pa.field("a", pa.int32())]) + assert f2.hash_schema(schema, include_metadata=True) == f2.hash_schema(schema) + + +@pytest.mark.parametrize( + "left, right", + [ + (pa.list_(pa.field("item", pa.int8())), pa.list_(pa.field("element", pa.int8()))), + (pa.dictionary(pa.int8(), pa.utf8()), pa.dictionary(pa.int32(), pa.utf8(), ordered=True)), + (pa.utf8(), pa.large_utf8()), + (pa.binary(), pa.large_binary()), + (pa.list_(pa.int8()), pa.large_list(pa.int8())), + ], +) +def test_names_and_physical_variants_not_hashed(left, right) -> None: + assert f2.hash_schema(pa.schema([pa.field("c", left)])) == f2.hash_schema(pa.schema([pa.field("c", right)])) + + +# ── Sections 3, 4: data layout rules ──────────────────────────────────── + + +def test_non_nullable_child_of_null_struct_contributes_nothing() -> None: + """Spec 3.2: elements whose (AND-ed) bit is 0 contribute no values (pending E2).""" + s = pa.StructArray.from_arrays( + [pa.array([1, 2, 3], pa.int32())], + fields=[pa.field("a", pa.int32(), nullable=False)], + mask=pa.array([False, True, False]), + ) + schema = pa.schema([pa.field("s", s.type, nullable=True)]) + batch = pa.record_batch([s], schema=schema) + final = sha(f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x05", sha(i32(1, 3))) + assert f2.hash_record_batch(batch) == V + final + + +def test_row_count_distinguishes_empty_structs() -> None: + def batch(n): + return pa.RecordBatch.from_arrays([pa.array([{}] * n, pa.struct([]))], names=["s"]) + + assert f2.hash_record_batch(batch(0)) != f2.hash_record_batch(batch(3)) + + +def test_entry_order_is_bytewise_node_path_order() -> None: + schema = pa.schema([pa.field("b", pa.int8(), nullable=False), pa.field("a", pa.int8(), nullable=False)]) + batch = pa.record_batch([pa.array([1], pa.int8()), pa.array([2], pa.int8())], schema=schema) + final = sha(f2.hash_schema(schema)[3:], u64(1), sha(b"\x02"), sha(b"\x01")) + assert f2.hash_record_batch(batch) == V + final + + +def test_leaf_value_bytes() -> None: + cases = [ + (pa.array([1.5], pa.float64()), struct.pack(" None: + s = pa.StructArray.from_arrays([pa.array([1, 2], pa.int8())], fields=[pa.field("x", pa.int8(), nullable=False)], + mask=pa.array([False, True])) + type_json = b'{"Struct":[{"data_type":"Int8","name":"x","nullable":false}]}' + assert f2.hash_array(s) == V + sha(header(0), type_json, u64(2), u64(2) + b"\x01", sha(b"\x01")) + lst = pa.array([[1, 2], [3]], pa.list_(pa.field("item", pa.int8(), nullable=False))) + type_json = b'{"LargeList":{"data_type":"Int8","nullable":false}}' + assert f2.hash_array(lst) == V + sha(header(0), type_json, u64(2), sha(u64(2) + u64(1)), sha(b"\x01\x02\x03")) + + +def test_hash_array_ordered_columns_changes_only_the_header() -> None: + arr = pa.array([1], pa.int8()) + assert f2.hash_array(arr, ordered_columns=True) == V + sha(header(0x01), b'"Int8"', u64(1), sha(b"\x01")) + + +# ── Invariants (Section 11) ───────────────────────────────────────────── + + +def _mixed_batch() -> pa.RecordBatch: + st = pa.struct([pa.field("z", pa.int32()), pa.field("a", pa.list_(pa.bool_()))]) + s = pa.array([{"z": 1, "a": [True]}, None, {"z": None, "a": None}, {"z": 4, "a": [False, None]}], st) + return pa.record_batch( + [pa.array(["x", None, "y", "z"]), s, pa.array([[[1]], None, [[2], None], []], pa.list_(pa.list_(pa.int64())))], + names=["b", "s", "l"], + ) + + +def test_i1_order_options() -> None: + batch = _mixed_batch() + reordered = batch.select([2, 1, 0]) + assert f2.hash_record_batch(batch) == f2.hash_record_batch(reordered) + assert f2.hash_record_batch(batch, ordered_columns=True) != f2.hash_record_batch(reordered, ordered_columns=True) + st_xy = pa.StructArray.from_arrays([pa.array([1]), pa.array([2])], names=["x", "y"]) + st_yx = pa.StructArray.from_arrays([pa.array([2]), pa.array([1])], names=["y", "x"]) + assert f2.hash_array(st_xy) == f2.hash_array(st_yx) + assert f2.hash_array(st_xy, ordered_struct_fields=True) != f2.hash_array(st_yx, ordered_struct_fields=True) + + +def test_i2_flag_values_never_coincide() -> None: + batch = pa.record_batch([pa.array([1])], names=["a"]) + hashes = { + f2.hash_record_batch(batch, ordered_columns=oc, ordered_struct_fields=osf) + for oc in (False, True) for osf in (False, True) + } + assert len(hashes) == 4 + + +def test_i4_batch_split_slicing_and_empty_batches() -> None: + batch = _mixed_batch() + whole = f2.hash_record_batch(batch) + d = f2.Digester(batch.schema) + d.update(batch.slice(0, 0)) + d.update(batch.slice(0, 1)) + d.update(batch.slice(1, 2)) + d.update(batch.slice(3)) + assert d.finalize() == whole + assert f2.hash_table(pa.Table.from_batches([batch.slice(0, 3), batch.slice(3)])) == whole + # adding a row changes the hash + longer = pa.Table.from_batches([batch, batch.slice(0, 1)]).combine_chunks().to_batches()[0] + assert f2.hash_record_batch(longer) != whole + + +def test_i3_physical_equivalence_in_data() -> None: + small = pa.record_batch([pa.array([["a"], None], pa.list_(pa.utf8()))], names=["c"]) + large = pa.record_batch([pa.array([["a"], None], pa.large_list(pa.large_utf8()))], names=["c"]) + assert f2.hash_record_batch(small) == f2.hash_record_batch(large) + + +# ── Section 7: rejected inputs (every mode) ───────────────────────────── + + +@pytest.mark.parametrize( + "schema", + [ + pa.schema([pa.field("a", pa.int8()), pa.field("a", pa.int8())]), + pa.schema([pa.field("s", pa.struct([pa.field("x", pa.int8()), pa.field("x", pa.int8())]))]), + pa.schema([pa.field("a/b", pa.int8()), pa.field("a", pa.struct([pa.field("b", pa.int8())]))]), + pa.schema([pa.field("x", pa.list_(pa.int8())), pa.field("x/", pa.int8())]), + pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.int8())), pa.field("m//key", pa.int8())]), + pa.schema([pa.field("u", pa.dense_union([pa.field("a", pa.int8())]))]), + pa.schema([pa.field("r", pa.run_end_encoded(pa.int32(), pa.int8()))]), + ], + ids=["dup_columns", "dup_children", "slash_alias", "list_alias", "map_alias", "union", "ree"], +) +def test_rejected_schemas(schema) -> None: + with pytest.raises(ValueError): + f2.hash_schema(schema) + with pytest.raises(ValueError): + f2.Digester(schema) + + +def test_list_view_rejected() -> None: + if not hasattr(pa, "list_view"): + pytest.skip("pyarrow without list_view") + with pytest.raises(ValueError): + f2.hash_schema(pa.schema([pa.field("v", pa.list_view(pa.int8()))])) + + +def test_slash_aliasing_nothing_is_accepted() -> None: + f2.hash_schema(pa.schema([pa.field("km/h", pa.float64()), pa.field("km", pa.int8())])) + + +def test_hash_array_root_path_is_claimed() -> None: + arr = pa.StructArray.from_arrays([pa.array([1])], fields=[pa.field("", pa.int64())]) + with pytest.raises(ValueError): + f2.hash_array(arr) + + +# ── Section 5: per-batch schema check ────────────────────────────────── + + +def test_streaming_check() -> None: + schema = pa.schema([pa.field("a", pa.int32()), pa.field("b", pa.utf8())]) + reordered = pa.record_batch([pa.array(["x"]), pa.array([1], pa.int32())], names=["b", "a"]) + f2.Digester(schema).update(reordered) + with pytest.raises(ValueError, match="does not match"): + f2.Digester(schema, ordered_columns=True).update(reordered) + with pytest.raises(ValueError, match="does not match"): + f2.Digester(schema).update(pa.record_batch([pa.array([1], pa.int64()), pa.array(["x"])], names=["a", "b"])) + large = pa.record_batch([pa.array([1], pa.int32()), pa.array(["x"], pa.large_utf8())], names=["a", "b"]) + f2.Digester(schema).update(large) + meta = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"}), pa.field("b", pa.utf8())]) + batch = pa.record_batch([pa.array([1], pa.int32()), pa.array(["x"])], schema=meta) + f2.Digester(schema).update(batch) # metadata ignored without include_metadata + with pytest.raises(ValueError, match="does not match"): + f2.Digester(schema, include_metadata=True).update(batch) + + +# ── Section 8: unsupported data ───────────────────────────────────────── + + +def test_unsupported_data_raises() -> None: + batch = pa.record_batch([pa.array([None, None], pa.null())], names=["n"]) + f2.hash_schema(batch.schema) + with pytest.raises(NotImplementedError): + f2.hash_record_batch(batch) + + +# ── Section 2.3: extension types (E1 pending for pyarrow's C++ built-in types) ── + + +class _Point(pa.ExtensionType): + def __init__(self, unit: str = "m") -> None: + self.unit = unit + super().__init__(pa.struct([pa.field("x", pa.float64())]), "starfix.test.point") + + def __arrow_ext_serialize__(self) -> bytes: + return ('{"unit":"%s"}' % self.unit).encode() + + @classmethod + def __arrow_ext_deserialize__(cls, storage_type, serialized): + import json as _json + + return cls(_json.loads(serialized)["unit"]) + + +@pytest.fixture +def point_type(): + pa.register_extension_type(_Point()) + yield _Point + pa.unregister_extension_type("starfix.test.point") + + +def _ipc_roundtrip(schema: pa.Schema, batches=()) -> tuple[pa.Schema, list]: + import io + + sink = io.BytesIO() + with pa.ipc.new_stream(sink, schema) as w: + for b in batches: + w.write_batch(b) + reader = pa.ipc.open_stream(io.BytesIO(sink.getvalue())) + return reader.schema, list(reader) + + +def test_registered_python_extension_type(point_type) -> None: + storage = pa.struct([pa.field("x", pa.float64())]) + schema = pa.schema([pa.field("p", point_type("km"), metadata={"other": "x"})]) + phase1 = b'{"p":{"data_type":{"Struct":[{"data_type":"Float64","name":"x","nullable":true}]},"nullable":true}}' + phase2 = b'{"fields":{"p":{"ARROW:extension:metadata":"{\\"unit\\":\\"km\\"}","ARROW:extension:name":"starfix.test.point","other":"x"}}}' + assert f2.hash_schema(schema, include_metadata=True) == V + sha(header(0), phase1, phase2) + # Without include_metadata an extension type hashes exactly like its storage type. + assert f2.hash_schema(schema) == f2.hash_schema(pa.schema([pa.field("p", storage)])) + # Data: the storage array is hashed. + storage_arr = pa.array([{"x": 1.0}, None], storage) + ext_arr = pa.ExtensionArray.from_storage(point_type("km"), storage_arr) + plain = pa.record_batch([storage_arr], names=["p"]) + ext = pa.record_batch([ext_arr], names=["p"]) + assert f2.hash_record_batch(ext) == f2.hash_record_batch(plain) + assert f2.hash_array(ext_arr) == f2.hash_array(storage_arr) + + +def test_registered_python_extension_type_after_ipc(point_type) -> None: + """pyarrow hides the two keys of a registered type; they are re-added from the type.""" + stored = pa.schema([pa.field("p", pa.struct([pa.field("x", pa.float64())]), metadata={ + "ARROW:extension:name": "starfix.test.point", "ARROW:extension:metadata": '{"unit":"km"}'})]) + seen, _ = _ipc_roundtrip(stored) + assert isinstance(seen.field(0).type, point_type) + assert f2.hash_schema(seen, include_metadata=True) == f2.hash_schema(stored, include_metadata=True) + + +def test_unregistered_extension_keys_hashed_verbatim() -> None: + schema = pa.schema([pa.field("q", pa.int32(), metadata={ + "ARROW:extension:name": "other.thing", "ARROW:extension:metadata": "v1"})]) + seen, _ = _ipc_roundtrip(schema) + phase2 = b'{"fields":{"q":{"ARROW:extension:metadata":"v1","ARROW:extension:name":"other.thing"}}}' + assert f2.hash_schema(seen, include_metadata=True) == V + sha(header(0), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) + + +def test_builtin_uuid_extension_with_canonical_metadata() -> None: + """arrow.uuid stored with an empty metadata value: exact (E1 covers other stored forms).""" + if not hasattr(pa, "uuid"): + pytest.skip("pyarrow without a registered arrow.uuid") + stored = pa.schema([pa.field("u", pa.binary(16), metadata={ + "ARROW:extension:name": "arrow.uuid", "ARROW:extension:metadata": ""})]) + batch = pa.record_batch([pa.array([b"\x01" * 16, None], pa.binary(16))], schema=stored) + seen, batches = _ipc_roundtrip(stored, [batch]) + assert f2.hash_schema(seen, include_metadata=True) == f2.hash_schema(stored, include_metadata=True) + assert f2.hash_record_batch(batches[0]) == f2.hash_record_batch(batch) From c217677f0259263a91448ebe386c09bacb3262ed Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:43:40 -0800 Subject: [PATCH 17/49] fix(format2): hash_array counts nulls on resolved dictionary values; offset tests (ITL-898) A valid dictionary key that points at a null dictionary value is a null element (pyarrow's DictionaryArray.null_count counts keys only), as Rust resolves it. Adds slicing tests at array offsets 7, 8, 9, 16, 63, 64, 65 for Boolean, Int32 and string leaves under a nullable struct and for a list of Booleans. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 8 ++++++-- tests/test_format2.py | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 919b0fb..71d3a3c 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -539,9 +539,13 @@ def hash_table(table: pa.Table, **options: bool) -> bytes: def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct_fields: bool = False) -> bytes: - """Section 4: the array is the node at path "" (nullable iff it has a null).""" + """Section 4: the array is the node at path "" (nullable iff it has a null). + + Nulls are counted on the resolved values: a valid dictionary key that points at a + null dictionary value is a null (pyarrow's DictionaryArray.null_count counts keys). + """ flags = flags_of(ordered_columns, ordered_struct_fields) - root = pa.field("", array.type, nullable=array.null_count > 0) + root = pa.field("", array.type, nullable=_resolve(array).null_count > 0) nodes = _walk([("", root)]) entries = _new_entries(nodes) _visit(root, array, "", None, entries) diff --git a/tests/test_format2.py b/tests/test_format2.py index 7c4263a..ef5251c 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -537,3 +537,42 @@ def test_builtin_uuid_extension_with_canonical_metadata() -> None: seen, batches = _ipc_roundtrip(stored, [batch]) assert f2.hash_schema(seen, include_metadata=True) == f2.hash_schema(stored, include_metadata=True) assert f2.hash_record_batch(batches[0]) == f2.hash_record_batch(batch) + + +# ── Review items from the Rust PR (dictionary nullability, offsets) ───── + + +def test_hash_array_dictionary_nullability_counts_resolved_nulls() -> None: + """A valid key pointing at a null dictionary value is a null element.""" + arr = pa.DictionaryArray.from_arrays(pa.array([0, 1], pa.int8()), pa.array(["a", None])) + assert arr.null_count == 0 # pyarrow counts index nulls only + expected = V + sha(header(0), b'"LargeUtf8"', u64(2), u64(2) + b"\x01", sha(u64(1) + b"a")) + assert f2.hash_array(arr) == expected + + +def _offset_cases(): + n = 200 + bools = [None if i % 5 == 0 else i % 3 == 0 for i in range(n)] + ints = [None if i % 7 == 0 else i for i in range(n)] + strs = [None if i % 4 == 0 else "s" * (i % 5) for i in range(n)] + mask = [i % 6 == 0 for i in range(n)] + st = pa.StructArray.from_arrays( + [pa.array(bools, pa.bool_()), pa.array(ints, pa.int32()), pa.array(strs)], + names=["b", "i", "s"], mask=pa.array(mask), + ) + lst = pa.array([None if i % 9 == 0 else bools[i:i + i % 4] for i in range(n)], pa.list_(pa.bool_())) + return st, lst + + +@pytest.mark.parametrize("offset", [7, 8, 9, 16, 63, 64, 65]) +def test_slices_at_bit_and_byte_boundaries(offset: int) -> None: + """Leaves under nullable containers at array offsets around byte/word boundaries.""" + st, lst = _offset_cases() + for arr in (st, lst): + sliced = arr.slice(offset, 50) + fresh = pa.array(sliced.to_pylist(), sliced.type) + assert sliced.offset == offset and fresh.offset == 0 + assert f2.hash_array(sliced) == f2.hash_array(fresh), (arr.type, offset) + b_sliced = pa.record_batch([sliced], names=["c"]) + b_fresh = pa.record_batch([fresh], names=["c"]) + assert f2.hash_record_batch(b_sliced) == f2.hash_record_batch(b_fresh), (arr.type, offset) From 02fd2bd22544aa51546be699c9fb681853cefc91 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:44:01 -0800 Subject: [PATCH 18/49] test(format2): deterministic scaling guards for list hashing (ITL-898, ITL-908) Ports the ITL-908 guards to format 2: hashing a list column never copies its shared values buffer (tracemalloc growth, isolated from caller tracing), and the number of node visits does not grow with the row count. Co-Authored-By: Claude Opus 5.5 --- tests/test_format2_scaling.py | 67 +++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 tests/test_format2_scaling.py diff --git a/tests/test_format2_scaling.py b/tests/test_format2_scaling.py new file mode 100644 index 0000000..16ff5ca --- /dev/null +++ b/tests/test_format2_scaling.py @@ -0,0 +1,67 @@ +"""Deterministic scaling guards for hash format 2 (ITL-908 regression, ported to format 2). + +Format 1 hashed list columns in quadratic time (each row copied the whole child values +buffer). These tests check memory and operation counts, not wall-clock time. +""" + +from __future__ import annotations + +import tracemalloc + +import pyarrow as pa + +from starfix import _format2 as f2 + + +def _list_table(rows: int, per_row: int) -> pa.Table: + values = pa.array(range(rows * per_row), pa.int64()) + offsets = pa.array(range(0, rows * per_row + 1, per_row), pa.int32()) + col = pa.ListArray.from_arrays(offsets, values) + return pa.table({"c": col}, schema=pa.schema([pa.field("c", col.type, nullable=False)])) + + +def test_list_hashing_never_copies_the_shared_values_buffer() -> None: + table = _list_table(rows=2_000, per_row=100) + buffer_size = table.column(0).chunk(0).values.nbytes + assert buffer_size == 1_600_000 + f2.hash_table(_list_table(rows=2, per_row=2)) # warm up lazy imports + + started_here = not tracemalloc.is_tracing() + if started_here: + tracemalloc.start() + try: + tracemalloc.reset_peak() + baseline, _ = tracemalloc.get_traced_memory() + f2.hash_table(table) + _, peak = tracemalloc.get_traced_memory() + finally: + if started_here: + tracemalloc.stop() + growth = peak - baseline + assert growth < buffer_size // 4, f"peak grew by {growth} bytes: the values buffer was copied" + + +def _nested_table(rows: int) -> pa.Table: + t = pa.list_(pa.field("item", pa.struct([("a", pa.int16()), ("b", pa.list_(pa.utf8())), ("c", pa.bool_())]))) + col = pa.array( + [None if i % 7 == 0 else [{"a": i, "b": ["x"] * (i % 3), "c": i % 2 == 0}] * (i % 4) for i in range(rows)], t + ) + return pa.table({"c": col}) + + +def test_traversal_count_does_not_grow_with_rows(monkeypatch) -> None: + calls = 0 + original = f2._visit + + def counting(*args, **kwargs): + nonlocal calls + calls += 1 + return original(*args, **kwargs) + + monkeypatch.setattr(f2, "_visit", counting) + counts = [] + for rows in (10, 10_000): + calls = 0 + f2.hash_table(_nested_table(rows)) + counts.append(calls) + assert counts[0] == counts[1], f"{counts[0]} visits for 10 rows, {counts[1]} for 10,000 rows" From b9e2964a1b46797cd08af6f76dc686e203b8938a Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:56:56 -0800 Subject: [PATCH 19/49] feat(format2): final spec deltas; final golden files; inputs of unmapped literals (ITL-898) - struct child node path is always p + "/" + name (spec 3.1, R7) - absent ARROW:extension:metadata hashed as "" (spec 2.3, E1) - data hashing of unsupported types rejected before hashing, any row count, ValueError (spec 7 item 3, E4) - tests/golden/format2_v0.5.json and format1_to_format2.json copied byte for byte from starfix f7aa441 (sha256 1b6102f4..., 9d40973c...) - tests/golden/python_literals_format1_inputs.json: the inputs of the 69 hand-coded format-1 literals of this repo that format1_to_format2.json does not cover, recovered by recording the calls that produce each literal (all 69 reproduce their format-1 value from the IPC), for Rust to supply the format-2 values Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 48 +- tests/golden/format1_to_format2.json | 1072 ++++++ tests/golden/format2_v0.5.json | 3278 +++++++++++++++++ .../python_literals_format1_inputs.json | 695 ++++ tests/test_format2.py | 58 +- 5 files changed, 5127 insertions(+), 24 deletions(-) create mode 100644 tests/golden/format1_to_format2.json create mode 100644 tests/golden/format2_v0.5.json create mode 100644 tests/golden/python_literals_format1_inputs.json diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 71d3a3c..ddc7c0d 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -3,9 +3,6 @@ Implements ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2) from the specification alone. Section numbers below refer to that document. -Pending spec decisions (marked ``PENDING`` in the code): E1 extension metadata of types -pyarrow registers in C++; E2/E3 nulls in non-nullable nodes; E4 unsupported data types -with zero rows; E5/E6 nested dictionary and extension values. """ from __future__ import annotations @@ -144,17 +141,14 @@ def type_json(t: pa.DataType, flags: int) -> str: # Node paths (Sections 3.1, 7) and Phase 1 / Phase 2 (Sections 2.2, 2.3) # --------------------------------------------------------------------------- -def _join(parent: str, name: str) -> str: - return f"{parent}/{name}" if parent else name - - def _children(field_type: pa.DataType, path: str) -> list[tuple[str, pa.Field]]: """The child nodes of a node of this type, as (node path, field).""" t = _logical(field_type) if _is_rejected_type(t): raise ValueError(f"Unsupported Arrow type for hashing: {t}") if pa.types.is_struct(t): - return [(_join(path, t.field(i).name), t.field(i)) for i in range(t.num_fields)] + # Section 3.1: always p + "/" + name (also when p or name is empty). + return [(f"{path}/{t.field(i).name}", t.field(i)) for i in range(t.num_fields)] if _is_list(t) or pa.types.is_fixed_size_list(t): return [(path + "/", t.value_field)] if pa.types.is_map(t): @@ -210,9 +204,10 @@ def _decode(mapping) -> dict[str, str]: def _extension_metadata(t: pa.DataType) -> dict[str, str]: """ARROW:extension:* keys of a registered extension type (pyarrow hides them). - PENDING (E1): pyarrow's C++ canonical types have no __arrow_ext_serialize__; their - serialized metadata is what pyarrow exports for the type (its canonical - serialization), not necessarily the bytes that were stored. + Python-defined ExtensionType subclasses serialize their stored bytes. pyarrow's + natively registered canonical types have no __arrow_ext_serialize__; their metadata + is what pyarrow exports for the type, its canonical serialization, and the spec + (Section 2.3) defines their hash only for that canonical stored form. """ if not _is_extension(t): return {} @@ -277,6 +272,9 @@ def read_bytes(n: int) -> bytes: def _field_metadata(field: pa.Field) -> dict[str, str]: meta = _decode(field.metadata) meta.update(_extension_metadata(field.type)) + # Section 2.3: an absent ARROW:extension:metadata is hashed as "" (absent == empty). + if "ARROW:extension:name" in meta: + meta.setdefault("ARROW:extension:metadata", "") return meta @@ -428,8 +426,7 @@ def _hash_values(arr: pa.Array, digest) -> None: parts.append(data[a:b]) digest.update(b"".join(parts)) return - # PENDING (E4): Null, FixedSizeList, Map, Interval and view data are unsupported. - raise NotImplementedError(f"Hashing data of type {t} is not supported") + raise ValueError(f"Hashing data of type {t} is not supported") # checked earlier (Section 7) def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None, entries: dict) -> None: @@ -442,7 +439,7 @@ def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None entry = entries[path] own = arr.is_valid() if arr.null_count else None if own is not None and not field.nullable: - # PENDING (E3): a non-nullable node holding nulls where its enclosing structs are valid. + # Section 7 item 4: a null in a non-nullable node not masked by an enclosing struct null. bad = own if enclosing is None else pc.or_(own, pc.invert(enclosing)) if not pc.all(bad).as_py(): raise ValueError(f"Non-nullable field {path!r} contains nulls") @@ -458,7 +455,7 @@ def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None t = arr.type for i in range(t.num_fields): child = t.field(i) - _visit(child, arr.field(i), _join(path, child.name), bits, entries) + _visit(child, arr.field(i), f"{path}/{child.name}", bits, entries) return valid = arr if bits is None else arr.filter(bits) @@ -473,6 +470,22 @@ def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None _hash_values(valid, entry.values) +def _is_unsupported_data(t: pa.DataType) -> bool: + """Section 8: types whose schema hashes but whose data does not.""" + return ( + pa.types.is_null(t) or pa.types.is_fixed_size_list(t) or pa.types.is_map(t) + or str(t) in _INTERVALS or str(t) in ("string_view", "binary_view") + ) + + +def _check_data_supported(nodes: list[tuple[str, pa.Field]]) -> None: + """Section 7 item 3: runs before any data is hashed, whatever the number of rows.""" + for path, field in nodes: + t = _logical(field.type) + if _is_unsupported_data(t): + raise ValueError(f"Hashing data of type {t} (node {path!r}) is not supported") + + def _new_entries(nodes: list[tuple[str, pa.Field]]) -> dict[str, _Entry]: return {path: _Entry(field) for path, field in nodes} @@ -500,7 +513,9 @@ def __init__( self._include_metadata = include_metadata self._schema_digest = schema_digest(schema, include_metadata, self._flags) self._key = schema_key(schema, include_metadata, self._flags) - self._entries = _new_entries(schema_nodes(schema)) + nodes = schema_nodes(schema) + _check_data_supported(nodes) + self._entries = _new_entries(nodes) self._rows = 0 def update(self, batch: pa.RecordBatch) -> None: @@ -547,6 +562,7 @@ def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct flags = flags_of(ordered_columns, ordered_struct_fields) root = pa.field("", array.type, nullable=_resolve(array).null_count > 0) nodes = _walk([("", root)]) + _check_data_supported(nodes) entries = _new_entries(nodes) _visit(root, array, "", None, entries) final = hashlib.sha256(header(flags)) diff --git a/tests/golden/format1_to_format2.json b/tests/golden/format1_to_format2.json new file mode 100644 index 0000000..710ff6a --- /dev/null +++ b/tests/golden/format1_to_format2.json @@ -0,0 +1,1072 @@ +{ + "description": "Every format-1 golden or pinned value of this repository and its format-2 value (ITL-898, hash format bump 00 00 01 -> 00 00 02). Every value moves. Entries with format2_vector refer to tests/golden/format2_v0.5.json (same input). format1_defects lists the format-1 information losses that affected that input (byte-layout spec Section 10).", + "entries": [ + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "no_metadata_include_false", + "format1_hash": "00000131f10e388ffb366939a37d877568320d681eb2c6e81793259274afd3b10ae38d", + "format2_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1", + "format2_vector": "no_metadata_include_false" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "schema_level_metadata", + "format1_hash": "00000185971192458c11308853f8647b688810b7efd3afb5e1a3811ebf1c449969b18d", + "format2_hash": "000002c2cd6a73cf9a5cf24ce01fd184b7485e55a2c443e543fd981bf32929fb0cf234", + "format2_vector": "schema_level_metadata" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "field_metadata_single_field", + "format1_hash": "000001d1490be52114b6a5284a89e91522b111f3e6ee1534edf2e472956f07360df020", + "format2_hash": "0000020b130367ff66564f4f9978ca3e506e3e305d12cb6ff6ae2c4fe747a2cc7bd5f2", + "format2_vector": "field_metadata_single_field" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "field_metadata_multiple_fields", + "format1_hash": "000001fdaa74e60eec18b816ac8e732f943fe405aaa9465ad3b788c083322b0bf16757", + "format2_hash": "000002e03369228220921177c5c578c461e3916b6ef44bb21e32c216ef6c0925429e88", + "format2_vector": "field_metadata_multiple_fields" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "schema_and_field_metadata", + "format1_hash": "000001dd9181cde304d1e39d424283c46d0b63126fa12e1272ce92ca34d7d4389dec65", + "format2_hash": "0000027eda76a93d2e60bc24c6eaee85eb53a24199dc58a9e15cfb483df94f2ecfef02", + "format2_vector": "schema_and_field_metadata" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "unicode_metadata", + "format1_hash": "00000155498f11ff0803127d60f8c6daa18b8c8dbb3411d2962e08ee0dfbce7054706b", + "format2_hash": "000002d82b81b3e7338563c258ad4df581c4033d24fa73ca8c533d943b2f6890e7c9bf", + "format2_vector": "unicode_metadata" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "key_reorder_canonical", + "format1_hash": "0000016a68d96d5c89d9b5de01d104c7ad1f51f9956bd8758691c9241ecacf32c701bf", + "format2_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e", + "format2_vector": "key_reorder_canonical" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "key_reorder_shuffled", + "format1_hash": "0000016a68d96d5c89d9b5de01d104c7ad1f51f9956bd8758691c9241ecacf32c701bf", + "format2_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e", + "format2_vector": "key_reorder_shuffled" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "empty_metadata_invariant", + "format1_hash": "00000131f10e388ffb366939a37d877568320d681eb2c6e81793259274afd3b10ae38d", + "format2_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1", + "format2_vector": "empty_metadata_invariant" + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "cols_ab_rb_f0", + "format1_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d", + "format2_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6", + "format2_vector": "cols_ab_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "cols_ba_rb_f0", + "format1_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d", + "format2_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6", + "format2_vector": "cols_ba_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "cols_ab_schema_f0", + "format1_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9", + "format2_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78", + "format2_vector": "cols_ab_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "cols_ba_schema_f0", + "format1_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9", + "format2_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78", + "format2_vector": "cols_ba_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "combo_ns_xy_f0", + "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", + "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_vector": "combo_ns_xy_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "combo_sn_xy_f0", + "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", + "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_vector": "combo_sn_xy_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "combo_ns_yx_f0", + "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", + "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_vector": "combo_ns_yx_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "combo_sn_yx_f0", + "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", + "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_vector": "combo_sn_yx_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nested_struct_ab_schema_f0", + "format1_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad", + "format2_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2", + "format2_vector": "nested_struct_ab_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nested_struct_ba_schema_f0", + "format1_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad", + "format2_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2", + "format2_vector": "nested_struct_ba_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "list_struct_ab_rb_f0", + "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", + "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_vector": "list_struct_ab_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "list_struct_ba_rb_f0", + "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", + "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_vector": "list_struct_ba_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "large_list_struct_ab_rb_f0", + "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", + "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_vector": "large_list_struct_ab_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "fsl_struct_ab_schema_f0", + "format1_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5", + "format2_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc", + "format2_vector": "fsl_struct_ab_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "fsl_struct_ba_schema_f0", + "format1_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5", + "format2_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc", + "format2_vector": "fsl_struct_ba_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "map_struct_ab_schema_f0", + "format1_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c", + "format2_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2", + "format2_vector": "map_struct_ab_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "map_struct_ba_schema_f0", + "format1_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c", + "format2_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2", + "format2_vector": "map_struct_ba_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "one_col_rb_f0", + "format1_hash": "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857", + "format2_hash": "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b", + "format2_vector": "one_col_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "one_col_schema_f0", + "format1_hash": "000001b7f25ba092def78ecd57c231765bac9d23a37ef04734462c1f50ec5880e7f204", + "format2_hash": "0000021e21972ae342e0d1df1e326a7b21effda3967fcbcdfa1e35b404878354093ad4", + "format2_vector": "one_col_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "one_col_array_f0", + "format1_hash": "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c", + "format2_hash": "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a", + "format2_vector": "one_col_array_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "ext_struct_xy_rb_f0_im1", + "format1_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb", + "format2_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a", + "format2_vector": "ext_struct_xy_rb_f0_im1", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "ext_struct_yx_rb_f0_im1", + "format1_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb", + "format2_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a", + "format2_vector": "ext_struct_yx_rb_f0_im1", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "zero_cols_0rows_rb_f0", + "format1_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6", + "format2_hash": "000002b2a0b24f3e5df2eee53e0db16967b5727624ba316c984d3e5ba250495e0cc8e7", + "format2_vector": "zero_cols_0rows_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "zero_cols_3rows_rb_f0", + "format1_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6", + "format2_hash": "00000245bae18d1db53b328b187930c2ed6f652be046f8156f30565ef09b22c10c8a08", + "format2_vector": "zero_cols_3rows_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_null_struct_rb_f0", + "format1_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9", + "format2_hash": "000002db84efc10bb100fb89bc3dd8d36572cb411b2871732479f26eed388229c3b2af", + "format2_vector": "nv_null_struct_rb_f0", + "format1_defects": [ + "nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_null_fields_rb_f0", + "format1_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9", + "format2_hash": "000002ae04d1306e82b99f8cfbc5c3d42d529b7f5e1e57eb728426c496781e93091027", + "format2_vector": "nv_null_fields_rb_f0", + "format1_defects": [ + "nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_rows3_rb_f0", + "format1_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a", + "format2_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd", + "format2_vector": "nv_rows3_rb_f0", + "format1_defects": [ + "nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_rows2_rb_f0", + "format1_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a", + "format2_hash": "000002ba8982cfb0a3a959a78134c6d90f9fb7ffacbb8a71a3764bc50dbd623ae0d7b7", + "format2_vector": "nv_rows2_rb_f0", + "format1_defects": [ + "nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_list_list_1row_rb_f0", + "format1_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006", + "format2_hash": "00000281c6c806d1945038ecebdfb5b3afa115fb8322d74c682d4984e7c35b2fb8ac11", + "format2_vector": "nv_list_list_1row_rb_f0", + "format1_defects": [ + "list_of_nullable_list" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_list_list_2rows_rb_f0", + "format1_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006", + "format2_hash": "000002a2c92a16669aac9a5e1312db5966e75d3a15bfef192e651424462ec955fb6438", + "format2_vector": "nv_list_list_2rows_rb_f0", + "format1_defects": [ + "list_of_nullable_list" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_list_null_elem_rb_f0", + "format1_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6", + "format2_hash": "000002759eb8659b32aa8437b39c041effd8bbef2ae68d7a5d6c5deae8df2559df5a8b", + "format2_vector": "nv_list_null_elem_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_list_null_fields_elem_rb_f0", + "format1_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6", + "format2_hash": "00000262e139b737f1bcebd138ac4e9a6dbadb9a8e7a9c24d93bcf7db418693323619e", + "format2_vector": "nv_list_null_fields_elem_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_array_rows3_f0", + "format1_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a", + "format2_hash": "0000025a437237556cf10c3516943f8c8137cd48a52cf16b1777262a0e36a2ec646c80", + "format2_vector": "nv_array_rows3_f0", + "format1_defects": [ + "nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "nv_array_rows2_f0", + "format1_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a", + "format2_hash": "000002e38a3d717443a885dd50d9f3cdf22d7cb1c69fa194a64a4168a384a7406e80e1", + "format2_vector": "nv_array_rows2_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "phys_dict_rb_f0", + "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", + "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_vector": "phys_dict_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "phys_utf8_rb_f0", + "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", + "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_vector": "phys_utf8_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "phys_large_utf8_rb_f0", + "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", + "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_vector": "phys_large_utf8_rb_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "array_struct_xy_f0", + "format1_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd", + "format2_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4", + "format2_vector": "array_struct_xy_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "array_struct_yx_f0", + "format1_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd", + "format2_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4", + "format2_vector": "array_struct_yx_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_1row_rb_f0", + "format1_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31", + "format2_hash": "000002ef402ce172daaef8d7b354c4a1f733117057a2da38cd0c1ae5f1900e891c34d4", + "format2_vector": "bool_1row_rb_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_3rows_rb_f0", + "format1_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31", + "format2_hash": "0000024edc7f8dd7034021d850b6485a80dc9ab5867f804c6299ed3fd8c166989aea29", + "format2_vector": "bool_3rows_rb_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_array_1_f0", + "format1_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005", + "format2_hash": "0000026ff0c8a2aea22b471ee082f0f9e66f30f9994b09ea2d3623c1355daf7ae74e88", + "format2_vector": "bool_array_1_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_array_2_f0", + "format1_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005", + "format2_hash": "000002e7fd44616d2602d1ea7db25f770f0d4e0905f935b65c6ecd412b82fa7cf40121", + "format2_vector": "bool_array_2_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_nullable_rb_f0", + "format1_hash": "0000012374ef8a63a8cfe593283ae0336f8d9ea5a84c534655acd6eff15636812d388b", + "format2_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45", + "format2_vector": "bool_nullable_rb_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "bool_nullable_stream_f0", + "format1_hash": "000001185dc35a80c8f2e12d34ceaa7062f09b6edbba7131bd7298752debea7e9c9d04", + "format2_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45", + "format2_vector": "bool_nullable_stream_f0", + "format1_defects": [ + "boolean_packing" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "names_schema_f0", + "format1_hash": "00000158f3ffc55d1fb210829f8ac71f1b4a29f45e70b120217fd17df22abb0eca1a9b", + "format2_hash": "000002423c1e37af8c6fa77dbb0c8df920f6af969fd6398a804fc2656e73488c0102ab", + "format2_vector": "names_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "names_array_struct_f0", + "format1_hash": "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c", + "format2_hash": "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728", + "format2_vector": "names_array_struct_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "names_array_struct_int8_f0", + "format1_hash": "000001e131c1f05f488566a32e4d387451a8998a54d2207416681782e7a2c0ff3affa9", + "format2_hash": "0000029bdeaab1cdeabaffbe83de8f6bc0f2b4698050d17d47ed3707705c490a3ca11e", + "format2_vector": "names_array_struct_int8_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "fsl_int_schema_f0", + "format1_hash": "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696", + "format2_hash": "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc", + "format2_vector": "fsl_int_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "list_kv_ab_rb_f0", + "format1_hash": "000001622d311ff5b38c734946fffc9088f1dc99bfe8e0cb04ccfda0e420aa8914f4dd", + "format2_hash": "000002a83e96153c214d6ed310666a91cc8c9e2dc8d885e8ef29eaa6d2fa3d2dee00b9", + "format2_vector": "list_kv_ab_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "list_kv_ba_rb_f0", + "format1_hash": "0000015dd41853de5c821a2f13436e7d1886bb606be477024b795d0993cf00f55df2b5", + "format2_hash": "00000247a75ef3e08557f7535e36cdc15aa9da00acd0e4c7d776c4758f9297c8ed2b06", + "format2_vector": "list_kv_ba_rb_f0", + "format1_defects": [ + "list_of_nullable_struct" + ] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_null_schema_f0", + "format1_hash": "000001450e51629d5bf2b2ef7ab0639e64238f7598446f0dbd0716e3d7f4b64b8c640c", + "format2_hash": "000002d62f819d0655f1ca1c0fb2709da2c2e21f3ab1593a405c1063e2dcc22fa10af5", + "format2_vector": "type_null_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_boolean_schema_f0", + "format1_hash": "000001f9913189cc32c79fb14c307c8eef776bfe6a5ac40a7ccc49a0461b5ee557e0d1", + "format2_hash": "000002bf1bb213a02678908892fe2ad319eb1805155337f8f72fc3266eaf99617183f2", + "format2_vector": "type_boolean_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_int8_schema_f0", + "format1_hash": "0000012b83e283d49b73e9069da9861fc1741adb391ce8f592220935a64344ada102a8", + "format2_hash": "000002f2b11ea2df5836e3377ba522c83e8d4796b76e6b9af836c908eb97ca1d9c9ee9", + "format2_vector": "type_int8_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_int16_schema_f0", + "format1_hash": "000001880d3e13346e5b9ee77784fc268e1627cf77e8b3411e11b46f6454c3510e381e", + "format2_hash": "000002fc7961c4b03e7a2a604e0c653b487b48b1bd13b2e2bfa616625ccd54d4380e04", + "format2_vector": "type_int16_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_int32_schema_f0", + "format1_hash": "00000127e2d4e9ff00877d5f7d23ed3881633983fc7aef3b006a96fedb859d128c3989", + "format2_hash": "000002f48ea32296b9c2e0cf348606101abdc2dbc4a3101cce917da7fec025241b46ac", + "format2_vector": "type_int32_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_int64_schema_f0", + "format1_hash": "000001b025613f15b5f393a4989ef73a15771a1102a55ef411a4b632aabade82a3d01b", + "format2_hash": "0000027a23f6870e469f67974b74770c0c4256977e36c80f4142071129c786faaeb546", + "format2_vector": "type_int64_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_uint8_schema_f0", + "format1_hash": "00000100824cb9155025aae789d5dd0df53c9c16c88deb0972fc9b1e863c39ec55acbd", + "format2_hash": "000002a5e423efe3ddad13f6c9d3da7093f44a9336879531fe36db98772ce70a23fc10", + "format2_vector": "type_uint8_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_uint16_schema_f0", + "format1_hash": "000001b0f78a84d6b3598e5526341cd4f4570bc0ec6e98718f4d5249b851c6152eabc7", + "format2_hash": "00000216568c9ca5484137a316794c1af7741ba2054d2352e728f2f260f5d27ca696b4", + "format2_vector": "type_uint16_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_uint32_schema_f0", + "format1_hash": "000001351c5bba858bc19d1b0e76c645616c137ab578e680a168263de0c183d881ebfe", + "format2_hash": "0000023cbc740e1382c5c1b0c5d6c4f8700c3c3fc38aa1e027f7332850987a53622f65", + "format2_vector": "type_uint32_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_uint64_schema_f0", + "format1_hash": "0000013f0e525838f78941dd7ebf1cf53a38aab1ce76083120f046e3c7d5d3a1d36674", + "format2_hash": "000002b338597d9c1f743d2b822b3ed4632632596ccadcc3dd63a3c34a8c4750b2adad", + "format2_vector": "type_uint64_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_float16_schema_f0", + "format1_hash": "0000014da58ec28052f47317cbc02b5af025698cb2c541ca0c0296a0f37098e1bc8393", + "format2_hash": "000002d594fa2f108350ff54de3b6c52c9aaf7e0205a9470db2431963052029c704557", + "format2_vector": "type_float16_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_float32_schema_f0", + "format1_hash": "000001b79ddc004ecda1cacf1ca4129c9339f87231e38b3feb324f37505fbb00448261", + "format2_hash": "0000020f83fab9cf3e29428d8a06c8ebf814ad97179430798696eca196deddd5785e64", + "format2_vector": "type_float32_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_float64_schema_f0", + "format1_hash": "0000018a4b885963f8e74a322a01627a43ace66eff8b29f9bffaae78d75026d6c338f0", + "format2_hash": "0000028212ede094399bb7b21174e93890d671bcd092a21bbf13a7699f45e635ab6b85", + "format2_vector": "type_float64_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_date32_schema_f0", + "format1_hash": "0000017067a187a25f7004d66cca4b06e7e3e319f7f71288a9fc42df603f092b6c7f4b", + "format2_hash": "0000024e1f6ad045cfba15f60e1d2e5f48194091885c578a9772e49fb108a8c53c3edd", + "format2_vector": "type_date32_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_date64_schema_f0", + "format1_hash": "000001eafdd4283792f22e1655bf61378bdc53de9f32d3b34cba20ee33349b6d215d27", + "format2_hash": "00000247f383c084cb2540482ef193d29b2797cbfdc00647d0149bba4abf15b9d5e51d", + "format2_vector": "type_date64_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_time32_s_schema_f0", + "format1_hash": "000001fedd3327155f022a4dd129ad3ed5afca9999f932498d991cc8efbb8e020052a2", + "format2_hash": "000002ba4c1ac02ac91418da73d12294a484feda0527423664c059676c605847d6c18c", + "format2_vector": "type_time32_s_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_time32_ms_schema_f0", + "format1_hash": "000001c2e1de3bcbf6a5a5faaec60dce7c65c5124061f0ccb97e7ef165a17a42b2fc4b", + "format2_hash": "00000240cb860fa8c49f36e13149eafe5e45bdae2c2f9be6fe6a571e85a76ddc223dd2", + "format2_vector": "type_time32_ms_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_time64_us_schema_f0", + "format1_hash": "000001228968561050acaeb788b5475feba508a6ea8234768429d0671bf0e62d58d71b", + "format2_hash": "000002a084f937c053322ca9690f6c1a40dd1675d7c010730c9fdcefa1911a5c6314a6", + "format2_vector": "type_time64_us_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_time64_ns_schema_f0", + "format1_hash": "0000018b7675631dcdbdaf3dfa91e3f3286f7211cf2193dcae672411b09afe4050fe59", + "format2_hash": "0000029d6c2cda4d46a9522b83168856482f149953428bd0f51b08384b764f198424af", + "format2_vector": "type_time64_ns_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_timestamp_s_naive_schema_f0", + "format1_hash": "0000019fe4c7746047294fd6a07264648cedf7f0e64f08a644d779c852d270dde089db", + "format2_hash": "000002410b6c31dbac2fabdb5893cf393be0fd7ce3ac603fa592b858608ba3582881ee", + "format2_vector": "type_timestamp_s_naive_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_timestamp_ms_utc_schema_f0", + "format1_hash": "00000196d90de77d3557403eb475d0f0d64774319117987aa1c588115c455666c597b5", + "format2_hash": "000002baca673fe3de658299ed83026512cf3980dd2c323a3fb9e304a206bbb9efe632", + "format2_vector": "type_timestamp_ms_utc_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_timestamp_us_offset_schema_f0", + "format1_hash": "000001c87d3b92444ee5a6b5e4e2f3bc098236ba7bcc9524ffe6e58cd012c3092bb922", + "format2_hash": "000002a63969413486c42e01fb9638f418f943b1e2749df379401a6db6174ece6c1bbd", + "format2_vector": "type_timestamp_us_offset_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_timestamp_ns_named_tz_schema_f0", + "format1_hash": "000001940af673c638fc1ff9aefe02078d47ad1713ba21d3916a1a87bdb0ead51afc5e", + "format2_hash": "00000292879787e87c84632b13219bebcde6c59ed735eb58044f3d7df937ffcb234a9d", + "format2_vector": "type_timestamp_ns_named_tz_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_duration_s_schema_f0", + "format1_hash": "0000019ef92ec048bd73719517bcdd78f1a52e57dd8d3ebbba8c3dbe689bf3473c8454", + "format2_hash": "000002c326fa8a3ae288735a556905748c1db265771accb49a63570baf1e9d8547911f", + "format2_vector": "type_duration_s_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_duration_ms_schema_f0", + "format1_hash": "0000015f844828d2b1cf182199ab026ac2903425f0f84898befe53f53b38a8468ae257", + "format2_hash": "000002b9bcfd0c6c9e97f81abe2b49da844b275f8712c81f8281b86e9943b3588c1aeb", + "format2_vector": "type_duration_ms_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_duration_us_schema_f0", + "format1_hash": "000001bc8e82b752d5d898ae332e360b8325e742b6d7359b6b6aed59ff21578b53141e", + "format2_hash": "000002325457512731593cd507ce3e7b011b9b7cca01dbd89e4f8920fb5994cf1d9d4a", + "format2_vector": "type_duration_us_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_duration_ns_schema_f0", + "format1_hash": "000001e881ee30b58bdaa77fbc333e13eb21a00d3ca4e96283f1eeb4062fb29995352f", + "format2_hash": "000002b73ed03cd62dd09e683c4059fbc97b46a742744f8720fb82aab81773efd787f1", + "format2_vector": "type_duration_ns_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_interval_year_month_schema_f0", + "format1_hash": "000001edfdb7dd18d6d1f1726bd0a820e82c13ba013ca920bd3d93d08530782119785b", + "format2_hash": "0000027209e6136116fc005f13f750a66837a8452c92912e147a54904f45255a18a1d3", + "format2_vector": "type_interval_year_month_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_interval_day_time_schema_f0", + "format1_hash": "000001ff900d6b57d11a3aed395b0a882a0cdf411450df8a497826e4cbdad57a41217f", + "format2_hash": "0000023aed3f6ad5f34d87f903ffb78bd76b8f289a61f8b60ee7902d9b981bbcc804c0", + "format2_vector": "type_interval_day_time_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_interval_month_day_nano_schema_f0", + "format1_hash": "000001b8ebd94791c839fcf2572f1abfe6584d39ff559624dc3362f6ff6a9b43bfd9b7", + "format2_hash": "000002a1ef89129cd30cf70f293c654a4f430bb84831156a0e26a82e2ce3b585a36297", + "format2_vector": "type_interval_month_day_nano_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_decimal32_schema_f0", + "format1_hash": "000001dd88bf3c39e96145f03d8fc9054089eb4dd8c437d74b1d4aa1b25b8e351e5c75", + "format2_hash": "000002dd15d65f2ad53b58d6f4275e9e02284c6b2b85a9bcfd57c9329d3378fe01b916", + "format2_vector": "type_decimal32_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_decimal64_negative_scale_schema_f0", + "format1_hash": "000001e16e0018ba784be83994c7a94db3071ab9c5462566161105d4ef8128105ed816", + "format2_hash": "0000020b8bd50d5e34cc66422d123c8ecad9985eaa5aab934706793d797b10ffdd7ef1", + "format2_vector": "type_decimal64_negative_scale_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_decimal128_schema_f0", + "format1_hash": "000001ebcc3afc437ac2f831005f29907440ae6d08ab647a04f974be15d44951326683", + "format2_hash": "00000230a8ad8ccebbb0f61cf11f600222fe8afda9bb33bb883b3a1dcbffd691626e83", + "format2_vector": "type_decimal128_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_decimal256_schema_f0", + "format1_hash": "0000017bf47db10e1322b3ebd6780afe01406dd3680654a3b77133f8139ebd4c987e04", + "format2_hash": "000002adaac773e79c05738edbf6511ca2e2b78e5fbca6ed34ce50cb30dd50638e3437", + "format2_vector": "type_decimal256_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_fixed_size_binary_schema_f0", + "format1_hash": "000001a1ed63688a1bfef27f1bb08ffbc85de0edc469fc74ca4a78b89d524c1524eaa4", + "format2_hash": "000002d7bb11b6df9b80954e3fd4bff19842697682f2092bd518e7866b51c4d82fab54", + "format2_vector": "type_fixed_size_binary_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_utf8_schema_f0", + "format1_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8", + "format2_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3", + "format2_vector": "type_utf8_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_large_utf8_schema_f0", + "format1_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8", + "format2_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3", + "format2_vector": "type_large_utf8_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_binary_schema_f0", + "format1_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5", + "format2_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e", + "format2_vector": "type_binary_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_large_binary_schema_f0", + "format1_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5", + "format2_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e", + "format2_vector": "type_large_binary_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_utf8_view_schema_f0", + "format1_hash": "000001c4f113df591f75ffe79c1da85c5000f0ade80eae214b97713872cab348800aa7", + "format2_hash": "00000227b6c1c19f55abb8f9c5397c44358179670b53e8cd0ac85c86a63efc077d3a45", + "format2_vector": "type_utf8_view_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "type_binary_view_schema_f0", + "format1_hash": "000001d212dca06f49287359b6359167ac3cc02782572c4463bb552297ae03a347b856", + "format2_hash": "00000269474d2dcf14686b5e68081944c59dd48e9723ec46045ef79de008d9ee75a565", + "format2_vector": "type_binary_view_schema_f0", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_map_value_schema_f0_im1", + "format1_hash": "0000018e90e39f63cff9891fa1536def277ab7c2545567c51cecf37e765e75f0609789", + "format2_hash": "000002f2ccfa54107bbf578a64ac6f09bf31d7c5eaab288c3b7003f8c0135d83928694", + "format2_vector": "meta_map_value_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_map_key_schema_f0_im1", + "format1_hash": "00000197b0e3e6528d52a065864a687be4a19b4197dfb62a4ca9915c6b7d3e6bd31ee7", + "format2_hash": "000002b509290043f950377512a8c5d20d712ae470307a40f7be188e2acc048d52a444", + "format2_vector": "meta_map_key_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_map_entries_schema_f0_im1", + "format1_hash": "00000138559b12d08a2cd6fc073ad2f98a22d75737b580905227d99207851c25e89951", + "format2_hash": "000002a2ea4c3e7aac3494e11cb4a863c257897c6fe24338111019718bb80f191e8f69", + "format2_vector": "meta_map_entries_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_map_all_schema_f0_im1", + "format1_hash": "0000017f5cbc6a8a7a9e6f8b06fdb33a8689f413b5034a80e41451cc7d3e50d648dbaf", + "format2_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727", + "format2_vector": "meta_map_all_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_struct_child_schema_f0_im1", + "format1_hash": "0000013ad8bf07377e7c14cdf271b6626b203a28f2295391ef0e9ac21d40d99bd0473a", + "format2_hash": "0000021bad8bde5a431b6ffdc4b426a99a2a753e1f877876bfa4f0dcfe6acd8380d258", + "format2_vector": "meta_struct_child_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_list_element_schema_f0_im1", + "format1_hash": "00000138cb63f6c736f44536dbc3c1cef7a81d6caa89a68a35db9ef4fcb04a82cfe91f", + "format2_hash": "0000022aa3f2d31d47e16368a06eef1caf2733b78453a3de28ee37db44e63f68ef0deb", + "format2_vector": "meta_list_element_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "released starfix 0.4.0 crate (reference vectors)", + "id": "meta_fsl_element_schema_f0_im1", + "format1_hash": "00000167f097bbffcd5ab67297252711a30106996ce8d0d7940e91ceab68b69c07023a", + "format2_hash": "0000023e3eb301b7a8196190729dcec01c5456493177faef4790e9433a61796acc78ce", + "format2_vector": "meta_fsl_element_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "tests/arrow_digester.rs", + "id": "binary_array_hashing", + "format1_hash": "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57", + "format2_hash": "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" + }, + { + "source": "tests/arrow_digester.rs", + "id": "boolean_array_hashing", + "format1_hash": "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b", + "format2_hash": "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing", + "format1_hash": "0000014f015bd5c4b6ce6e939a8c890333f3e110c2c28ef8014aafd352f8373791e547", + "format2_hash": "000002e83147c84038cb72cb3cc8e24e651e0491028c449cfe7f2a9d51ded84391ca40" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing", + "format1_hash": "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa", + "format2_hash": "000002f4db00404adc309eaa3c23518b36b56a44659edc0a4c4dbbddea90449cf90413" + }, + { + "source": "tests/arrow_digester.rs", + "id": "int32_array_hashing", + "format1_hash": "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138", + "format2_hash": "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" + }, + { + "source": "tests/arrow_digester.rs", + "id": "list_array_hashing", + "format1_hash": "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c", + "format2_hash": "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" + }, + { + "source": "tests/arrow_digester.rs", + "id": "record_batch_hashing", + "format1_hash": "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0", + "format2_hash": "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" + }, + { + "source": "tests/arrow_digester.rs", + "id": "schema", + "format1_hash": "0000012ac1decf89ab7e337d5df56bafd330f7e9a761953c58c39d5a3a8c49f6dfd4ff", + "format2_hash": "000002b4d7f0bc024ebf3eed85a31c1168c1f3cf60d88adf54e912550cf907af25db94" + }, + { + "source": "tests/arrow_digester.rs", + "id": "string_array_hashing", + "format1_hash": "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c", + "format2_hash": "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + }, + { + "source": "tests/arrow_digester.rs", + "id": "time32_array_hashing", + "format1_hash": "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc", + "format2_hash": "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" + }, + { + "source": "tests/arrow_digester.rs", + "id": "time64_array_hashing", + "format1_hash": "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26", + "format2_hash": "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b", + "format2_hash": "00000252859a0dad006bac78dd1ba3fa17fde43bfa2af9cc95bdd08b6611da1691f012" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing", + "format1_hash": "000001dc08c7b9c583edecec36bc5dee21cd2edec9f402a651014fea5f8834d16ad737", + "format2_hash": "00000226d3b5c66b1fa3b3de097542369f89b2717f3026c778ce17d57817fbf2fec8f0" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing", + "format1_hash": "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c", + "format2_hash": "000002767dcb630f550d41da343f63fb308d1e2ce97e68306f988573178da666fb156f" + }, + { + "source": "tests/arrow_digester.rs", + "id": "schema", + "format1_hash": "0000011d2c77a01beb74029cb2a71fe52eac4ac3ef7b31b55df717fc8098dee73735cf", + "format2_hash": "000002b32e24cda163bcece18d19af32944a15142b99880e14a6552aab28c1da84e858" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5", + "format2_hash": "000002f6dcd4d91471e975d86257785c15f0d8e120a84b45f163378e913d10935f1ec9" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing", + "format1_hash": "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e", + "format2_hash": "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing", + "format1_hash": "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a", + "format2_hash": "00000267a46b80b8577b61b24e665edbe71f78d6af7170305cbe0b348ca07a1b2874d9" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e", + "format2_hash": "00000209c1c989349caa973563a880521cbcaaa4e62ccc77f380e69f0fc57c639b4bfa" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing", + "format1_hash": "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b", + "format2_hash": "00000265d49688aae1ade659148d969f4fd703fa688fd7e3dcbe3c00d5e7ef2ae50720" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0", + "format2_hash": "0000021d86082dfda0e2f0449320c2acd853756d79dc3080cf1ee14327c7c9f2201480" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30", + "format2_hash": "0000028fa5d6fbc775327e0c766cab77a00991dc87cf7ac7d45f875d049559b55cbb3e" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842", + "format2_hash": "000002c0d0e86c4e7ff759ad83bf887cf5b20f2b662ceeeba5865ed1f5353b6b7a9445" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3", + "format2_hash": "000002148a265e62ae6878931d8d3316c4aec43f50da2e688d83bfe62901c3703e6b4f" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796", + "format2_hash": "00000292c1b50fa17e537e6afb5903cce37b5b28b03088e6ec3e23c346d9adafb071a7" + }, + { + "source": "src/arrow_digester_core.rs (raw digest, no prefix)", + "id": "nested_fields", + "format1_hash": "9b52ad7430dea81b35f14a04d828b2424080fbc210570081c6e6cb62b6566c42", + "format2_hash": "8038c003912adbecc339cd6b1c1e9a62f59dc68a684c00cc1b29cff72d193361" + } + ] +} diff --git a/tests/golden/format2_v0.5.json b/tests/golden/format2_v0.5.json new file mode 100644 index 0000000..2ab5937 --- /dev/null +++ b/tests/golden/format2_v0.5.json @@ -0,0 +1,3278 @@ +{ + "version": "0.5", + "format": 2, + "generated_by": "cargo run --bin emit_golden_format2", + "vectors": [ + { + "id": "cols_ab_rb_f0", + "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" + }, + { + "id": "cols_ba_rb_f0", + "description": "Same data, columns b,a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" + }, + { + "id": "cols_ab_schema_f0", + "description": "Schema [a, b]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78" + }, + { + "id": "cols_ba_schema_f0", + "description": "Schema [b, a]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78" + }, + { + "id": "cols_ab_rb_f1", + "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002fd2f35d37a40f06e04e40249b7276576fbb1531b5e73f2f8f1d72a8fa919dbac" + }, + { + "id": "cols_ba_rb_f1", + "description": "Same data, columns b,a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e9b67dfcd80328c4f0b1c8ba2c4249aab468221b444b57fdd8332cf32b806456" + }, + { + "id": "cols_ab_schema_f1", + "description": "Schema [a, b]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c0270743d441e19e40a9cb9c096122994f1b5855c1a8f792b1f7dcbbad3e1fda" + }, + { + "id": "cols_ba_schema_f1", + "description": "Schema [b, a]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026043b19dae69df86d76daf5a24c6aa30d040ff9765102f37a6e7f40edf4907f3" + }, + { + "id": "cols_ba_stream_f1", + "description": "Stream of the cols_ba data split into two batches, ordered_columns", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002e9b67dfcd80328c4f0b1c8ba2c4249aab468221b444b57fdd8332cf32b806456" + }, + { + "id": "combo_ns_xy_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + }, + { + "id": "combo_sn_xy_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + }, + { + "id": "combo_ns_yx_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + }, + { + "id": "combo_sn_yx_f0", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + }, + { + "id": "combo_ns_xy_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000299b420126277e1c35db38e343ae507eadbad5444d2298bf04dcffedb832bbfd5" + }, + { + "id": "combo_sn_xy_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002902e074f42ee3a1fb4f1bfc5796350923529b16425db919ade5495e86f800cfc" + }, + { + "id": "combo_ns_yx_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000299b420126277e1c35db38e343ae507eadbad5444d2298bf04dcffedb832bbfd5" + }, + { + "id": "combo_sn_yx_f1", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002902e074f42ee3a1fb4f1bfc5796350923529b16425db919ade5495e86f800cfc" + }, + { + "id": "combo_ns_xy_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000257a9e2653caa2af9e1109882560fb987ff41232a5635d26830281f9d72417144" + }, + { + "id": "combo_sn_xy_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000257a9e2653caa2af9e1109882560fb987ff41232a5635d26830281f9d72417144" + }, + { + "id": "combo_ns_yx_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000255754414ebe823c9b0e4fc4db6a5e764043a54a3aa5723425440e54cd0921c5a" + }, + { + "id": "combo_sn_yx_f2", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000255754414ebe823c9b0e4fc4db6a5e764043a54a3aa5723425440e54cd0921c5a" + }, + { + "id": "combo_ns_xy_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b60dcf77a903bb7f3f15da8e6e3c4d204eabc525e9df8196294f8b22e9fcd5e1" + }, + { + "id": "combo_sn_xy_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024e7c431a7ca9e214fde4ad9863e82afe27dc5bcbd0b84b9533946fa3f8bcece6" + }, + { + "id": "combo_ns_yx_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f47e306bb3a3af19b2f5014534dd5859df55ceed4328be3ec371c15f3fdbae2b" + }, + { + "id": "combo_sn_yx_f3", + "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002171397f6490e1ab445bf0ca56c6290acd75cc091295d6ac80e12656f55d91c48" + }, + { + "id": "nested_struct_ab_schema_f0", + "description": "s: Struct>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2" + }, + { + "id": "nested_struct_ba_schema_f0", + "description": "s: Struct> (only the inner level permuted)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2" + }, + { + "id": "list_struct_ab_rb_f0", + "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + }, + { + "id": "list_struct_ba_rb_f0", + "description": "Same, struct fields declared b, a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + }, + { + "id": "large_list_struct_ab_rb_f0", + "description": "Same as list_struct_ab with LargeList", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + }, + { + "id": "fsl_struct_ab_schema_f0", + "description": "f: FixedSizeList, 2> (schema only: data unsupported)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc" + }, + { + "id": "fsl_struct_ba_schema_f0", + "description": "f: FixedSizeList, 2>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc" + }, + { + "id": "map_struct_ab_schema_f0", + "description": "m: Map> (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2" + }, + { + "id": "map_struct_ba_schema_f0", + "description": "m: Map>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2" + }, + { + "id": "nested_struct_ab_schema_f2", + "description": "s: Struct>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002d32d17fc90639336690608e3ed79d49ddcfed560a3ce6c841407afde83d0969c" + }, + { + "id": "nested_struct_ba_schema_f2", + "description": "s: Struct> (only the inner level permuted)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000249b92b055ce95a9c6abf84c1b7e2a8c2746149966a41dcfbf9d1ece44e507291" + }, + { + "id": "list_struct_ab_rb_f2", + "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002be3f261e757e47d19ac6cf63c86a698e458c183dba3019c7a30d7709b3bae179" + }, + { + "id": "list_struct_ba_rb_f2", + "description": "Same, struct fields declared b, a", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e3144a68d34997bea027c96823733d42a3c3ffa0d53412f10170e213f851ab22" + }, + { + "id": "large_list_struct_ab_rb_f2", + "description": "Same as list_struct_ab with LargeList", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002be3f261e757e47d19ac6cf63c86a698e458c183dba3019c7a30d7709b3bae179" + }, + { + "id": "fsl_struct_ab_schema_f2", + "description": "f: FixedSizeList, 2> (schema only: data unsupported)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002019f912d8bfa8199312c5210150fce6dc1e7bf8173201fb2a1074e0a225f4a3c" + }, + { + "id": "fsl_struct_ba_schema_f2", + "description": "f: FixedSizeList, 2>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002925dc2273e700e690d7b5e5f9b0f8760be4b21557765871b04d0e85c33e12ed6" + }, + { + "id": "map_struct_ab_schema_f2", + "description": "m: Map> (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002a18ed04210f29c9b171da2dd6bd635442be7e0c8785e9d21ab87b1b4207dec3d" + }, + { + "id": "map_struct_ba_schema_f2", + "description": "m: Map>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000021cff4e9ecfc52c3cb6d9acd9b02241b3a8340b708b626b2342f319b5a62c8fd9" + }, + { + "id": "one_col_rb_f0", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b" + }, + { + "id": "one_col_schema_f0", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "0000021e21972ae342e0d1df1e326a7b21effda3967fcbcdfa1e35b404878354093ad4" + }, + { + "id": "one_col_array_f0", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" + }, + { + "id": "one_col_rb_f1", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002d212f8b185b21b800f584b38910145a4b81ee7f276f71830d9001f61f78c71e4" + }, + { + "id": "one_col_schema_f1", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000002bfaa329e4ab9a16f95370d38879da26bc40860ca84d59a2364d53cffb6a07baf" + }, + { + "id": "one_col_array_f1", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025afda948e8a8efb2e0976f237c06dc00555ed6ca69ec8abf21f43179d14009d7" + }, + { + "id": "one_col_rb_f2", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022b4b208408375278f5f1eee9b66a9cdbbe2e158af35b936e8410bd20951c3f15" + }, + { + "id": "one_col_schema_f2", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000002f300e48cd58d3abc1a35b0df83ed620acff982922d68192c945094bdc8a2cd2e" + }, + { + "id": "one_col_array_f2", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b6f8dedb0f20b24c40ea03ec391ccc7656bf9d428b550b1c9f1cc7e92309a73b" + }, + { + "id": "one_col_rb_f3", + "description": "One column v: Int32 [1, 2, 3]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022a57199ec1d348f8a03cc5ff16823af138262dafe9e94c2c0ef575730471fb78" + }, + { + "id": "one_col_schema_f3", + "description": "Schema [v: Int32]", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", + "expected_hash": "000002bf9151fa730fbdb16eb1e4da8dc110d4cb6635ed25da37ae2fcf46365b777650" + }, + { + "id": "one_col_array_f3", + "description": "hash_array of Int32 [1, 2, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000283a0a8b132c33bd58c78b2536fe801bd033d7e03c40147f3e5f395872629acbc" + }, + { + "id": "plain_schema_f1_im0", + "description": "Schema [b, a] without metadata, include_metadata=false", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f8d23756dd1ca8ee57511dbfe1c3cb087d8732fd9c4d8a72256ed4af45592387" + }, + { + "id": "plain_schema_f1_im1", + "description": "Same, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f8d23756dd1ca8ee57511dbfe1c3cb087d8732fd9c4d8a72256ed4af45592387" + }, + { + "id": "meta_schema_f1_im1", + "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002493eba96d0e764e218f4072f621d0b9ecfe22daac21d561f842e0eafc1260bf5" + }, + { + "id": "plain_schema_f3_im0", + "description": "Schema [b, a] without metadata, include_metadata=false", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000257d9dd9d561c4232e2d07269004f9db141adc853c5ad944f7ec9b31b4ecadc65" + }, + { + "id": "plain_schema_f3_im1", + "description": "Same, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000257d9dd9d561c4232e2d07269004f9db141adc853c5ad944f7ec9b31b4ecadc65" + }, + { + "id": "meta_schema_f3_im1", + "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f8d5fbb2a37aee3411400a0696f42373a09225c4e85013dc5bfa70bbd74e970e" + }, + { + "id": "ext_struct_xy_rb_f0_im1", + "description": "Extension type (metadata) over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a" + }, + { + "id": "ext_struct_yx_rb_f0_im1", + "description": "Extension type over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a" + }, + { + "id": "ext_struct_xy_rb_f2_im1", + "description": "Extension type (metadata) over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000211f3efef88ef314c928160341ce1df3cea468b4b905671f0fb8debd04126523e" + }, + { + "id": "ext_struct_yx_rb_f2_im1", + "description": "Extension type over Struct storage, include_metadata=true", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029f008ce8fc460ce82e719a84f32d630363563e017ccf3e2814acdbef4e451fc0" + }, + { + "id": "empty_stream_f1", + "description": "Schema [b, a], zero batches, ordered_columns", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024addf88e806e549394af82afebcb8f7b03e3d67769216814464d7342b7e70362" + }, + { + "id": "zero_row_rb_f1", + "description": "Schema [b, a], one batch with zero rows, ordered_columns", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAADAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024addf88e806e549394af82afebcb8f7b03e3d67769216814464d7342b7e70362" + }, + { + "id": "zero_cols_0rows_rb_f0", + "description": "Zero columns, 0 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b2a0b24f3e5df2eee53e0db16967b5727624ba316c984d3e5ba250495e0cc8e7" + }, + { + "id": "zero_cols_3rows_rb_f0", + "description": "Zero columns, 3 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000245bae18d1db53b328b187930c2ed6f652be046f8156f30565ef09b22c10c8a08" + }, + { + "id": "zero_cols_0rows_rb_f1", + "description": "Zero columns, 0 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000028d3e59d17471807ff6d8794816c2556c15d96f707d991fe0af4838eeccc52ba1" + }, + { + "id": "zero_cols_3rows_rb_f1", + "description": "Zero columns, 3 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002bc2b2a94f2edadb19e438ce5c0bddbba813bf3b945767126e2a36c2ab48d8aa7" + }, + { + "id": "leaf_nulls_rb_f3", + "description": "Nullable leaves with nulls and an all-null Int32 column, flags 3", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAABwAAAANAAAAAQAAACs////EAAAABgAAAAAAAECFAAAAJz///8gAAAAAAAAAQAAAAABAAAAegAAANj///8YAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGEAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAACAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c0b1052c44299def8c050e5dc3036737551bdb2aba6cc0defebbe5a0b39693f3" + }, + { + "id": "nv_null_struct_rb_f0", + "description": "s: Struct? rows [{a:1}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002db84efc10bb100fb89bc3dd8d36572cb411b2871732479f26eed388229c3b2af" + }, + { + "id": "nv_null_fields_rb_f0", + "description": "s: Struct? rows [{a:1}, {a:null}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ae04d1306e82b99f8cfbc5c3d42d529b7f5e1e57eb728426c496781e93091027" + }, + { + "id": "nv_rows3_rb_f0", + "description": "s: Struct? rows [{a:1}, null, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + }, + { + "id": "nv_rows2_rb_f0", + "description": "s: Struct? rows [{a:1}, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ba8982cfb0a3a959a78134c6d90f9fb7ffacbb8a71a3764bc50dbd623ae0d7b7" + }, + { + "id": "nv_list_list_1row_rb_f0", + "description": "c: List?> one row [[1], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000281c6c806d1945038ecebdfb5b3afa115fb8322d74c682d4984e7c35b2fb8ac11" + }, + { + "id": "nv_list_list_2rows_rb_f0", + "description": "c: List?> two rows [[1]], [[2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a2c92a16669aac9a5e1312db5966e75d3a15bfef192e651424462ec955fb6438" + }, + { + "id": "nv_list_null_elem_rb_f0", + "description": "l: List?> one row [null, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002759eb8659b32aa8437b39c041effd8bbef2ae68d7a5d6c5deae8df2559df5a8b" + }, + { + "id": "nv_list_null_fields_elem_rb_f0", + "description": "l: List?> one row [{a:null}, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000262e139b737f1bcebd138ac4e9a6dbadb9a8e7a9c24d93bcf7db418693323619e" + }, + { + "id": "nv_null_struct_rb_f3", + "description": "s: Struct? rows [{a:1}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f781933978ce32299ef7591304c4874fd80fbd044858c558cdeda41aee960cf8" + }, + { + "id": "nv_null_fields_rb_f3", + "description": "s: Struct? rows [{a:1}, {a:null}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000262c2ceab507d05a742a70bd04e99a30dcca2832b27bb91d21956ac827cc3e17d" + }, + { + "id": "nv_rows3_rb_f3", + "description": "s: Struct? rows [{a:1}, null, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000027bc8d972783ed84371e0396f6414883927de8b45ddb69819c42195942f32d8ac" + }, + { + "id": "nv_rows2_rb_f3", + "description": "s: Struct? rows [{a:1}, {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c225743b59aff3372d541db2f35a17b4d4432cb7c467eb251f83ed27926e3d84" + }, + { + "id": "nv_list_list_1row_rb_f3", + "description": "c: List?> one row [[1], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024be9127d5b421c42e6960135981628f13c4750a89ebff4492cc6a87daafaa6d9" + }, + { + "id": "nv_list_list_2rows_rb_f3", + "description": "c: List?> two rows [[1]], [[2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b14609a3a15d9b4ac1cad514416809d66dd755c11d3559fd29fc021e3dc1d64e" + }, + { + "id": "nv_list_null_elem_rb_f3", + "description": "l: List?> one row [null, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002766b2b94169e0ef73a59814a47706df329da0a8e8f987fde2ccf74436799cec5" + }, + { + "id": "nv_list_null_fields_elem_rb_f3", + "description": "l: List?> one row [{a:null}, {a:4}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028e489475ea979dcc6cc663fb1f31ddbf87a8706d3d2b5f5091b2f099d88ff431" + }, + { + "id": "nv_nested_structs_rb_f0", + "description": "o: Struct?>? with nulls at both levels", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e7bd89d9f653eae5fa33dd933472baacdc180e17580a067776476042525a2c1b" + }, + { + "id": "nv_nested_structs_rb_f3", + "description": "o: Struct?>? with nulls at both levels", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000279f0bd3373da8205c1f529f766d2ea9e411c4240ecb5bfae8b9cdf9b5e67c44a" + }, + { + "id": "nv_rows3_stream_f0", + "description": "nv_rows3 data split into two batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + }, + { + "id": "nv_array_rows3_f0", + "description": "hash_array of Struct [{a:1}, null, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025a437237556cf10c3516943f8c8137cd48a52cf16b1777262a0e36a2ec646c80" + }, + { + "id": "nv_array_rows2_f0", + "description": "hash_array of Struct [{a:1}, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e38a3d717443a885dd50d9f3cdf22d7cb1c69fa194a64a4168a384a7406e80e1" + }, + { + "id": "nv_array_rows3_f3", + "description": "hash_array of Struct [{a:1}, null, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025998218109dc90a6abe2a1b53ab9e149fd6d765fc63f75b83e8b5c4108def858" + }, + { + "id": "nv_array_rows2_f3", + "description": "hash_array of Struct [{a:1}, {a:3}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002bd633876ba1380b3d9454d6e93959a608953eb173652156d636d11952111bae9" + }, + { + "id": "phys_dict_rb_f0", + "description": "[z: Int32, d: Dictionary]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + }, + { + "id": "phys_utf8_rb_f0", + "description": "[z: Int32, d: Utf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + }, + { + "id": "phys_large_utf8_rb_f0", + "description": "[z: Int32, d: LargeUtf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + }, + { + "id": "phys_dict_rb_f3", + "description": "[z: Int32, d: Dictionary]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + }, + { + "id": "phys_utf8_rb_f3", + "description": "[z: Int32, d: Utf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + }, + { + "id": "phys_large_utf8_rb_f3", + "description": "[z: Int32, d: LargeUtf8] same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + }, + { + "id": "array_struct_xy_f0", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4" + }, + { + "id": "array_struct_yx_f0", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4" + }, + { + "id": "array_struct_xy_f2", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002477608cc8f61796978d5e863bfa56ba6b7b8620aee386bc93c6b007d2b110911" + }, + { + "id": "array_struct_yx_f2", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ec8d4e01557a6e80f126a91049699f00ae90bdf0e38a9ba49095e635e90942a7" + }, + { + "id": "array_struct_xy_f3", + "description": "hash_array of Struct [{1,true},{2,false}]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027222886512d91f93ff578714967bffe25099e787ca277eebfab052900c93b774" + }, + { + "id": "array_struct_yx_f3", + "description": "Same, fields declared y, x", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002a393af972e9dd3225c50181bc1fd8b4e84f499baeed9c0f759a6cb6a384ec451" + }, + { + "id": "array_list_struct_f2", + "description": "hash_array of List?> with a null row", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000023ae35e8ff85e58f481d0121aba6a098eef05dd939754a4d4d3e5079912e1ac8a" + }, + { + "id": "array_list_struct_f3", + "description": "hash_array of List?> with a null row", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b32296f9475c4a92e605084e9091b7f11a3a0220a89aacb4e0e53964c1ed19e0" + }, + { + "id": "combo_sn_yx_3rows_rb_f3", + "description": "Columns s, n; struct y, x; 3 rows (Boolean field y); both order options on", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002223743a17543e2cafaa8fe33b3ec42cd45391ed2f6cd370d03d626e8b0d88468" + }, + { + "id": "combo_sn_yx_3rows_stream_f3", + "description": "Same data as two batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "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", + "expected_hash": "000002223743a17543e2cafaa8fe33b3ec42cd45391ed2f6cd370d03d626e8b0d88468" + }, + { + "id": "bool_1row_rb_f0", + "description": "b: Boolean non-null [true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ef402ce172daaef8d7b354c4a1f733117057a2da38cd0c1ae5f1900e891c34d4" + }, + { + "id": "bool_3rows_rb_f0", + "description": "b: Boolean non-null [true, false, false]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000024edc7f8dd7034021d850b6485a80dc9ab5867f804c6299ed3fd8c166989aea29" + }, + { + "id": "bool_array_1_f0", + "description": "hash_array of Boolean [true]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026ff0c8a2aea22b471ee082f0f9e66f30f9994b09ea2d3623c1355daf7ae74e88" + }, + { + "id": "bool_array_2_f0", + "description": "hash_array of Boolean [true, false]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002e7fd44616d2602d1ea7db25f770f0d4e0905f935b65c6ecd412b82fa7cf40121" + }, + { + "id": "bool_1row_rb_f3", + "description": "b: Boolean non-null [true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027b575c88cd22fbdddb8944d4774af3b0ab66cbcdece5510a394881932ac64a85" + }, + { + "id": "bool_3rows_rb_f3", + "description": "b: Boolean non-null [true, false, false]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026b64b994a93b6ecab6b739afb3584b04bb228518144138b91df0cd77f9193fb5" + }, + { + "id": "bool_array_1_f3", + "description": "hash_array of Boolean [true]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002bb184a7f992ecf751cb1d32c00360eb32ca6015f3eaa7f4b62926f839894f9ce" + }, + { + "id": "bool_array_2_f3", + "description": "hash_array of Boolean [true, false]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022bfab5ca77eb2d9831200ddca6994409f75ae68d7558757a5b53183b2f0e4217" + }, + { + "id": "bool_nullable_rb_f0", + "description": "b: Boolean nullable [true, null, false, true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45" + }, + { + "id": "bool_nullable_stream_f0", + "description": "Same as two batches [true] + [null, false, true]", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45" + }, + { + "id": "bool_nullable_rb_f3", + "description": "b: Boolean nullable [true, null, false, true]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002a07b77e36c7d66633230f1a9204bcfea6a5456d77bb84da747c084d790a5e321" + }, + { + "id": "bool_nullable_stream_f3", + "description": "Same as two batches [true] + [null, false, true]", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002a07b77e36c7d66633230f1a9204bcfea6a5456d77bb84da747c084d790a5e321" + }, + { + "id": "names_schema_f0", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "000002423c1e37af8c6fa77dbb0c8df920f6af969fd6398a804fc2656e73488c0102ab" + }, + { + "id": "names_array_struct_f0", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728" + }, + { + "id": "names_schema_f1", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "00000208fcc9eae81e4072d484bda90504f7ec75253b050722e0b001829a46cc2c9756" + }, + { + "id": "names_array_struct_f1", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000022a408eab093882422f42e11eef4d01a9705bb3b49a8932dc0005d8976e839e00" + }, + { + "id": "names_schema_f3", + "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", + "expected_hash": "000002b6b15853f87b8e68918955cb1ebce961f5da388f2f98e91e9d41bfb3a929e94a" + }, + { + "id": "names_array_struct_f3", + "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000254b2c8adca9a81bd352340688113ac024f0f541898586a236c7d446929360dd1" + }, + { + "id": "names_array_struct_int8_f0", + "description": "hash_array of Struct<é: Int8 non-null> [{é: 1}], default options", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029bdeaab1cdeabaffbe83de8f6bc0f2b4698050d17d47ed3707705c490a3ca11e" + }, + { + "id": "fsl_int_schema_f0", + "description": "f: FixedSizeList (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc" + }, + { + "id": "fsl_int_schema_f1", + "description": "f: FixedSizeList (schema only)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026c0f3381c1659e4c0fc37d0e00d11b2c901b4ee97efc81fbab85bdabc0ab5c05" + }, + { + "id": "list_kv_ab_rb_f0", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002a83e96153c214d6ed310666a91cc8c9e2dc8d885e8ef29eaa6d2fa3d2dee00b9" + }, + { + "id": "list_kv_ba_rb_f0", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000247a75ef3e08557f7535e36cdc15aa9da00acd0e4c7d776c4758f9297c8ed2b06" + }, + { + "id": "list_kv_ab_rb_f1", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c698e900b998f58ae155ac23d899c5bcb337098a7cf50dfdafc8c73c1988da48" + }, + { + "id": "list_kv_ba_rb_f1", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000216d4dd6267ab5ce6a72315a1af3fc2d894dde4a45fed41396842e7f3cd7f7289" + }, + { + "id": "list_kv_ab_rb_f2", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000020ad24b15e8ffa67e671bfb59c8f0fd39292d925fe85a81b5e84c2fc2e444bf88" + }, + { + "id": "list_kv_ba_rb_f2", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002592d2eebd2c4906930f49d7807a1a9932ac1a809c1b56d04b915501bb586b0d2" + }, + { + "id": "list_kv_ab_rb_f3", + "description": "kv: List> one row [{a,1},{b,2}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f552cc5c5e5f7eb7994925045315f306437340586f9f7832b5280fe614620b91" + }, + { + "id": "list_kv_ba_rb_f3", + "description": "Same elements in reverse order [{b,2},{a,1}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002dd17ed9dbd6f16c24eb8ae3a70b1937e3a3d87a1ed71afea21131a6dd962a8be" + }, + { + "id": "type_null_schema_f0", + "description": "Schema [c: Null nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQEQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002d62f819d0655f1ca1c0fb2709da2c2e21f3ab1593a405c1063e2dcc22fa10af5" + }, + { + "id": "type_boolean_schema_f0", + "description": "Schema [c: Boolean nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002bf1bb213a02678908892fe2ad319eb1805155337f8f72fc3266eaf99617183f2" + }, + { + "id": "type_int8_schema_f0", + "description": "Schema [c: Int8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000002f2b11ea2df5836e3377ba522c83e8d4796b76e6b9af836c908eb97ca1d9c9ee9" + }, + { + "id": "type_int16_schema_f0", + "description": "Schema [c: Int16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000002fc7961c4b03e7a2a604e0c653b487b48b1bd13b2e2bfa616625ccd54d4380e04" + }, + { + "id": "type_int32_schema_f0", + "description": "Schema [c: Int32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000002f48ea32296b9c2e0cf348606101abdc2dbc4a3101cce917da7fec025241b46ac" + }, + { + "id": "type_int64_schema_f0", + "description": "Schema [c: Int64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "0000027a23f6870e469f67974b74770c0c4256977e36c80f4142071129c786faaeb546" + }, + { + "id": "type_uint8_schema_f0", + "description": "Schema [c: UInt8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a5e423efe3ddad13f6c9d3da7093f44a9336879531fe36db98772ce70a23fc10" + }, + { + "id": "type_uint16_schema_f0", + "description": "Schema [c: UInt16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000216568c9ca5484137a316794c1af7741ba2054d2352e728f2f260f5d27ca696b4" + }, + { + "id": "type_uint32_schema_f0", + "description": "Schema [c: UInt32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023cbc740e1382c5c1b0c5d6c4f8700c3c3fc38aa1e027f7332850987a53622f65" + }, + { + "id": "type_uint64_schema_f0", + "description": "Schema [c: UInt64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b338597d9c1f743d2b822b3ed4632632596ccadcc3dd63a3c34a8c4750b2adad" + }, + { + "id": "type_float16_schema_f0", + "description": "Schema [c: Float16 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAAFAAAAAAAAQMQAAAABAAEAAQAAAAAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002d594fa2f108350ff54de3b6c52c9aaf7e0205a9470db2431963052029c704557" + }, + { + "id": "type_float32_schema_f0", + "description": "Schema [c: Float32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000020f83fab9cf3e29428d8a06c8ebf814ad97179430798696eca196deddd5785e64" + }, + { + "id": "type_float64_schema_f0", + "description": "Schema [c: Float64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000028212ede094399bb7b21174e93890d671bcd092a21bbf13a7699f45e635ab6b85" + }, + { + "id": "type_date32_schema_f0", + "description": "Schema [c: Date32 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024e1f6ad045cfba15f60e1d2e5f48194091885c578a9772e49fb108a8c53c3edd" + }, + { + "id": "type_date64_schema_f0", + "description": "Schema [c: Date64 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000247f383c084cb2540482ef193d29b2797cbfdc00647d0149bba4abf15b9d5e51d" + }, + { + "id": "type_time32_s_schema_f0", + "description": "Schema [c: Time32(Second) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002ba4c1ac02ac91418da73d12294a484feda0527423664c059676c605847d6c18c" + }, + { + "id": "type_time32_ms_schema_f0", + "description": "Schema [c: Time32(Millisecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000240cb860fa8c49f36e13149eafe5e45bdae2c2f9be6fe6a571e85a76ddc223dd2" + }, + { + "id": "type_time64_us_schema_f0", + "description": "Schema [c: Time64(Microsecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAgBAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "000002a084f937c053322ca9690f6c1a40dd1675d7c010730c9fdcefa1911a5c6314a6" + }, + { + "id": "type_time64_ns_schema_f0", + "description": "Schema [c: Time64(Nanosecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "0000029d6c2cda4d46a9522b83168856482f149953428bd0f51b08384b764f198424af" + }, + { + "id": "type_timestamp_s_naive_schema_f0", + "description": "Schema [c: Timestamp(Second, None) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQoYAAAAAAAAAAQABAAEAAAAAAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002410b6c31dbac2fabdb5893cf393be0fd7ce3ac603fa592b858608ba3582881ee" + }, + { + "id": "type_timestamp_ms_utc_schema_f0", + "description": "Schema [c: Timestamp(Millisecond, Some(\"UTC\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQokAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAEAAwAAAFVUQwABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002baca673fe3de658299ed83026512cf3980dd2c323a3fb9e304a206bbb9efe632" + }, + { + "id": "type_timestamp_us_offset_schema_f0", + "description": "Schema [c: Timestamp(Microsecond, Some(\"+05:30\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQooAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAIABgAAACswNTozMAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002a63969413486c42e01fb9638f418f943b1e2749df379401a6db6174ece6c1bbd" + }, + { + "id": "type_timestamp_ns_named_tz_schema_f0", + "description": "Schema [c: Timestamp(Nanosecond, Some(\"America/New_York\")) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQo0AAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAMAEAAAAEFtZXJpY2EvTmV3X1lvcmsAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000292879787e87c84632b13219bebcde6c59ed735eb58044f3d7df937ffcb234a9d" + }, + { + "id": "type_duration_s_schema_f0", + "description": "Schema [c: Duration(Second) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002c326fa8a3ae288735a556905748c1db265771accb49a63570baf1e9d8547911f" + }, + { + "id": "type_duration_ms_schema_f0", + "description": "Schema [c: Duration(Millisecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARIQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b9bcfd0c6c9e97f81abe2b49da844b275f8712c81f8281b86e9943b3588c1aeb" + }, + { + "id": "type_duration_us_schema_f0", + "description": "Schema [c: Duration(Microsecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002325457512731593cd507ce3e7b011b9b7cca01dbd89e4f8920fb5994cf1d9d4a" + }, + { + "id": "type_duration_ns_schema_f0", + "description": "Schema [c: Duration(Nanosecond) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAwABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b73ed03cd62dd09e683c4059fbc97b46a742744f8720fb82aab81773efd787f1" + }, + { + "id": "type_interval_year_month_schema_f0", + "description": "Schema [c: Interval(YearMonth) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQsQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000027209e6136116fc005f13f750a66837a8452c92912e147a54904f45255a18a1d3" + }, + { + "id": "type_interval_day_time_schema_f0", + "description": "Schema [c: Interval(DayTime) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAQABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023aed3f6ad5f34d87f903ffb78bd76b8f289a61f8b60ee7902d9b981bbcc804c0" + }, + { + "id": "type_interval_month_day_nano_schema_f0", + "description": "Schema [c: Interval(MonthDayNano) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a1ef89129cd30cf70f293c654a4f430bb84831156a0e26a82e2ce3b585a36297" + }, + { + "id": "type_decimal32_schema_f0", + "description": "Schema [c: Decimal32(9, 2) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAAAgAAAAAgAAAAkAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002dd15d65f2ad53b58d6f4275e9e02284c6b2b85a9bcfd57c9329d3378fe01b916" + }, + { + "id": "type_decimal64_negative_scale_schema_f0", + "description": "Schema [c: Decimal64(18, -3) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAABAAAAA/f///xIAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000020b8bd50d5e34cc66422d123c8ecad9985eaa5aab934706793d797b10ffdd7ef1" + }, + { + "id": "type_decimal128_schema_f0", + "description": "Schema [c: Decimal128(38, 10) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQccAAAAAAAAAAgADAAIAAQACAAAAAoAAAAmAAAAAQAAAGMAAAD/////AAAAAA==", + "expected_hash": "00000230a8ad8ccebbb0f61cf11f600222fe8afda9bb33bb883b3a1dcbffd691626e83" + }, + { + "id": "type_decimal256_schema_f0", + "description": "Schema [c: Decimal256(76, 0) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQcgAAAAAAAAAAAACgAMAAgAAAAEAAoAAAAAAQAATAAAAAEAAABjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002adaac773e79c05738edbf6511ca2e2b78e5fbca6ed34ce50cb30dd50638e3437" + }, + { + "id": "type_fixed_size_binary_schema_f0", + "description": "Schema [c: FixedSizeBinary(16) nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002d7bb11b6df9b80954e3fd4bff19842697682f2092bd518e7866b51c4d82fab54" + }, + { + "id": "type_utf8_schema_f0", + "description": "Schema [c: Utf8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3" + }, + { + "id": "type_large_utf8_schema_f0", + "description": "Schema [c: LargeUtf8 nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3" + }, + { + "id": "type_binary_schema_f0", + "description": "Schema [c: Binary nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e" + }, + { + "id": "type_large_binary_schema_f0", + "description": "Schema [c: LargeBinary nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARMQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e" + }, + { + "id": "type_utf8_view_schema_f0", + "description": "Schema [c: Utf8View nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000227b6c1c19f55abb8f9c5397c44358179670b53e8cd0ac85c86a63efc077d3a45" + }, + { + "id": "type_binary_view_schema_f0", + "description": "Schema [c: BinaryView nullable], default options", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARcQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000269474d2dcf14686b5e68081944c59dd48e9723ec46045ef79de008d9ee75a565" + }, + { + "id": "meta_map_value_schema_f0_im1", + "description": "m: Map, metadata on the value field (path m//value)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f2ccfa54107bbf578a64ac6f09bf31d7c5eaab288c3b7003f8c0135d83928694" + }, + { + "id": "meta_map_key_schema_f0_im1", + "description": "m: Map, metadata on the key field (path m//key)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b509290043f950377512a8c5d20d712ae470307a40f7be188e2acc048d52a444" + }, + { + "id": "meta_map_entries_schema_f0_im1", + "description": "m: Map, metadata on the entries field (path m/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002a2ea4c3e7aac3494e11cb4a863c257897c6fe24338111019718bb80f191e8f69" + }, + { + "id": "meta_map_all_schema_f0_im1", + "description": "m: Map, metadata on entries, key and value", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", + "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + }, + { + "id": "meta_struct_child_schema_f0_im1", + "description": "s: Struct, metadata on a struct child (path s/a)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000021bad8bde5a431b6ffdc4b426a99a2a753e1f877876bfa4f0dcfe6acd8380d258" + }, + { + "id": "meta_list_element_schema_f0_im1", + "description": "l: List, metadata on the element field (path l/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022aa3f2d31d47e16368a06eef1caf2733b78453a3de28ee37db44e63f68ef0deb" + }, + { + "id": "meta_fsl_element_schema_f0_im1", + "description": "f: FixedSizeList, metadata on the element field (path f/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", + "expected_hash": "0000023e3eb301b7a8196190729dcec01c5456493177faef4790e9433a61796acc78ce" + }, + { + "id": "meta_map_value_schema_f1_im1", + "description": "m: Map, metadata on the value field (path m//value)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e76732f144114761329c7194b5d716c1b164f9fd57d4da254f863afb630c51cf" + }, + { + "id": "meta_map_key_schema_f1_im1", + "description": "m: Map, metadata on the key field (path m//key)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000025611a6f49df4c4e65a895f2209dcfe7b6e957cd41b2e7085274f6e6b1dccf68b" + }, + { + "id": "meta_map_entries_schema_f1_im1", + "description": "m: Map, metadata on the entries field (path m/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029051855dd7d48ad692cb5ffecf76ffb4509e295b6d066a8530b3f8aa24110de3" + }, + { + "id": "meta_map_all_schema_f1_im1", + "description": "m: Map, metadata on entries, key and value", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", + "expected_hash": "0000025b1546156ad74adefaf9a90a7934731b3e7aaf1fc7554ad9ed31b631dfd31711" + }, + { + "id": "meta_struct_child_schema_f1_im1", + "description": "s: Struct, metadata on a struct child (path s/a)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000028eefb9d2aac3ca46e0063567f507b88597c200263316433ee0a3ab7c0a455a83" + }, + { + "id": "meta_list_element_schema_f1_im1", + "description": "l: List, metadata on the element field (path l/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000029865426d25592eb80b7c223b9ad2688b557e6aab5963c5788bed1ccdc42fc5ea" + }, + { + "id": "meta_fsl_element_schema_f1_im1", + "description": "f: FixedSizeList, metadata on the element field (path f/)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": true, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", + "expected_hash": "00000207a7f6f53345f59a6236f6e097b592ed2ee311ee3fdb45aabee1add7f63d0801" + }, + { + "id": "no_metadata_include_false", + "description": "Schema {id: Int64, name: LargeUtf8}, no metadata, include_metadata=false", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAA/////wAAAAA=", + "expected_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1" + }, + { + "id": "schema_level_metadata", + "description": "Schema-level metadata {version: 2}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAA0AAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAAAyAAAABwAAAHZlcnNpb24AAQAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAABAAAAAAAAAAQAAAAACAAAAaWQAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c2cd6a73cf9a5cf24ce01fd184b7485e55a2c443e543fd981bf32929fb0cf234" + }, + { + "id": "field_metadata_single_field", + "description": "Single field x: Int32 with metadata {unit: kg}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000020b130367ff66564f4f9978ca3e506e3e305d12cb6ff6ae2c4fe747a2cc7bd5f2" + }, + { + "id": "field_metadata_multiple_fields", + "description": "Two fields x:{unit:kg}, y:{unit:m}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACIAAAAGAAAAAAAEgAaABQAAAATAAgAAAAMAAQAEgAAADAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAeQAAAAEAAAAEAAAAkP///wgAAAAMAAAAAQAAAG0AAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002e03369228220921177c5c578c461e3916b6ef44bb21e32c216ef6c0925429e88" + }, + { + "id": "schema_and_field_metadata", + "description": "Schema metadata {version:1} + field metadata {unit:kg}, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAsAAAAAQAAAAQAAACE////CAAAAAwAAAABAAAAMQAAAAcAAAB2ZXJzaW9uAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027eda76a93d2e60bc24c6eaee85eb53a24199dc58a9e15cfb483df94f2ecfef02" + }, + { + "id": "unicode_metadata", + "description": "Field metadata with emoji and CJK keys/values, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAALAAAABgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAEAAAAZGF0YQAAAAACAAAAOAAAAAQAAADY////CAAAABQAAAAJAAAA5pel5pys6KqeAAAABgAAAOS4reaWhwAACAAMAAgABAAIAAAACAAAABQAAAAJAAAAdmFsdWVf4pyTAAAADgAAAGVtb2ppX2tleV/wn5SRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002d82b81b3e7338563c258ad4df581c4033d24fa73ca8c533d943b2f6890e7c9bf" + }, + { + "id": "key_reorder_canonical", + "description": "Field metadata {alpha,beta,gamma} inserted in alphabetical order, include_metadata=true", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAMAAABUAAAAKAAAAAQAAADA////CAAAAAwAAAABAAAAMwAAAAUAAABnYW1tYQAAAOD///8IAAAADAAAAAEAAAAyAAAABAAAAGJldGEAAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAMQAAAAUAAABhbHBoYQAAAP////8AAAAA", + "expected_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e" + }, + { + "id": "key_reorder_shuffled", + "description": "Same metadata {alpha,beta,gamma} with shuffled HashMap input — arrow-ipc normalises key order before FlatBuffers encoding, so expected_hash equals key_reorder_canonical", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAMAAABUAAAAKAAAAAQAAADA////CAAAAAwAAAABAAAAMwAAAAUAAABnYW1tYQAAAOD///8IAAAADAAAAAEAAAAyAAAABAAAAGJldGEAAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAMQAAAAUAAABhbHBoYQAAAP////8AAAAA", + "expected_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e" + }, + { + "id": "empty_metadata_invariant", + "description": "Schema with no metadata — hash(include_metadata=false) must equal hash(include_metadata=true)", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAA/////wAAAAA=", + "expected_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1" + }, + { + "id": "name_list_item_rb_f0_im1", + "description": "l: List [[1, 2]], include_metadata", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAyQAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAAAQAAAHUAAAABAAAAbAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000283422b18f431bd7741e5ba6cbf89ff3a21193b7e139680d5459c4dcba7832418" + }, + { + "id": "name_list_element_rb_f0_im1", + "description": "Same with the element field named 'element'", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAyQAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABwAAAGVsZW1lbnQAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAAAQAAAHUAAAABAAAAbAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000283422b18f431bd7741e5ba6cbf89ff3a21193b7e139680d5459c4dcba7832418" + }, + { + "id": "name_map_standard_schema_f0_im1", + "description": "m: Map with entries/key/value names and key/value metadata", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARE4AQAAAQAAABgAAAAg////EAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAAA38AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAnP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGlkAAAEAAAAcm9sZQAAAAAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + }, + { + "id": "name_map_custom_schema_f0_im1", + "description": "Same with names kv/k/v", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAREwAQAAAQAAABgAAAAk////EAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAAA34AAAAAgAAAJQAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA0AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAAQAAACc////CAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAASABgAFAAAABMACAAAAAwABAASAAAAKAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAABAAAAawAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAaWQAAAQAAAByb2xlAAAAAAIAAABrdgAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + }, + { + "id": "name_map_entries_meta_schema_f0_im1", + "description": "Same with metadata on the entries field", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", + "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + }, + { + "id": "name_dict_int8_rb_f0", + "description": "d: Dictionary [p, q, p]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAQAAAADQAAAAAAAAFEAAAADQAAAAIAAgAAAAEAAgAAAAMAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABAAEAAQAAAABAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAADAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b95312b46f1b45bbf80d43dbea467cc0f3341aed8e31b3c0b3532ff27e0e8c2d" + }, + { + "id": "name_dict_int32_ordered_rb_f0", + "description": "d: Dictionary [p, q, p], field marked dict ordered", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAaABQAAAAPAAQAEAAIABAAAABIAAAAPAAAAAAAAAUUAAAAPAAAAAAACgAMAAAACAAHAAoAAAAAAAABDAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQABAAEAAAAAQAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAADAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002b95312b46f1b45bbf80d43dbea467cc0f3341aed8e31b3c0b3532ff27e0e8c2d" + }, + { + "id": "ext_uuid_rb_f0_im0", + "description": "u: arrow.uuid extension (registered in pyarrow) over FixedSizeBinary(16)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAAB1AAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + }, + { + "id": "ext_uuid_storage_rb_f0_im0", + "description": "Same data as plain FixedSizeBinary(16)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAdQAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + }, + { + "id": "ext_point_rb_f0_im0", + "description": "p: example.point extension (unregistered) over Int32", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAcAAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA0AAABleGFtcGxlLnBvaW50AAAAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAUAAAACgAAAHsiZGltcyI6MX0AABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + }, + { + "id": "ext_point_storage_rb_f0_im0", + "description": "Same data as plain Int32", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + }, + { + "id": "ext_uuid_rb_f0_im1", + "description": "u: arrow.uuid extension (registered in pyarrow) over FixedSizeBinary(16)", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAAB1AAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022010d79ac4e8927002e34b59113123c9a7fd7c6eb163fb99e00e53f894200592" + }, + { + "id": "ext_uuid_storage_rb_f0_im1", + "description": "Same data as plain FixedSizeBinary(16)", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAdQAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + }, + { + "id": "ext_point_rb_f0_im1", + "description": "p: example.point extension (unregistered) over Int32", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAcAAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA0AAABleGFtcGxlLnBvaW50AAAAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAUAAAACgAAAHsiZGltcyI6MX0AABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027e3a814a74f801c73faebfca7c556d8de3f238e3bf889f6970d73fcb05c1510a" + }, + { + "id": "ext_point_storage_rb_f0_im1", + "description": "Same data as plain Int32", + "method": "hash_record_batch", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + }, + { + "id": "empty_struct_1row_rb_f0", + "description": "e: Struct<> non-null, 1 row", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA0QAAAAAAAAAAQABAAEAAAAAQAAAGUAAAAAAAAAAAAAAAAAAAD/////eAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002be4b2b6cc8d07d170e65ef733c5fb0a1815debbb7e5359e7fbe3d7c0c3061a6d" + }, + { + "id": "empty_struct_2rows_rb_f0", + "description": "e: Struct<> non-null, 2 rows", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA0QAAAAAAAAAAQABAAEAAAAAQAAAGUAAAAAAAAAAAAAAAAAAAD/////eAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002ebda3848a7c2967e0de3d1be8074588fb46d03e6198015e97dbb21ca5c69090a" + }, + { + "id": "nested_null_inner_list_rb_f0", + "description": "c: List?> one row [[1], null, [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002bb8a3a08b13b4b69360bf7bbe98cfdb3ade364d346d382833a32d5a8da4693d5" + }, + { + "id": "nested_empty_inner_list_rb_f0", + "description": "Same with an empty inner list instead of null: [[1], [], [2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f9a5269ea92b74cd7989fe86e996deb25a29f642b9593ece125da69d88fac58e" + }, + { + "id": "depth4_rb_f0", + "description": "d: List?>?>?> with nulls at every level", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAzYAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAABDawAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAEMhAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABAAAAGl0ZW0AAAAAAQAAAHYAAAAEAAAAaXRlbQAAAAABAAAAZAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABAAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002d3b145fa59fb21f4d8ba08d7e106467deb7a34c8f0d3bf1337a8535e941bd800" + }, + { + "id": "depth4_rb_f3", + "description": "Same, both order options", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": true, + "ordered_struct_fields": true, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAzYAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAABDawAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAEMhAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABAAAAGl0ZW0AAAAAAQAAAHYAAAAEAAAAaXRlbQAAAAABAAAAZAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABAAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ec115c0ea4fb82a4ffb8bb08f832aa9e2e43c39733a200d6a05408972fab3899" + }, + { + "id": "list_in_struct_rb_f0", + "description": "s: Struct?>? rows [{l:[1]}, {l:null}, null]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDYQAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000232db5d9adfd7fff17cef5441b385214fb327d12959c91740b07a75408ac436d4" + }, + { + "id": "null_list_slot_with_values_rb_f0", + "description": "l: List? rows [[1], null (slot covers 98, 99), [4]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAGIAAABjAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002e85d0e5a5b04ff2164ff8f57d98f1c7aebfb6bc689d1d06d91764af79f64702b" + }, + { + "id": "null_list_slot_empty_rb_f0", + "description": "l: List? rows [[1], null (empty slot), [4]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002e85d0e5a5b04ff2164ff8f57d98f1c7aebfb6bc689d1d06d91764af79f64702b" + }, + { + "id": "struct_null_hides_5_rb_f0", + "description": "s: Struct? rows [{a:1}, null (a=5 underneath), {a:3}]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + }, + { + "id": "struct_null_hides_6_rb_f0", + "description": "Same with a=6 underneath the null struct", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + }, + { + "id": "empty_list_rb_f0", + "description": "l: List? one row []", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024fcb565252f9418a8eed4b700cb58a0bf30917b787bb30f43a451c4c0ec0511a" + }, + { + "id": "null_list_rb_f0", + "description": "l: List? one row null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023f7fff0c51cc55ba029e93647178320eb86822c0f906dbb48983bacedd19508e" + }, + { + "id": "dict_null_unused_dup_rb_f0", + "description": "v: Dictionary with a null key, a key to a null value, an unused and a duplicated value", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAAEAAAAAAAAECEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAUAAAAAAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAYwAAAAAAAAAeAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000226c56c574822d3dcea32d8ad6066970e38d4d203319ef234350283e35bf069b0" + }, + { + "id": "dict_null_unused_dup_plain_rb_f0", + "description": "v: Int64 with the same logical values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAACAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000226c56c574822d3dcea32d8ad6066970e38d4d203319ef234350283e35bf069b0" + }, + { + "id": "dict_same_keys_other_values_rb_f0", + "description": "Same keys, dictionary value 10 replaced by 11", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAAEAAAAAAAAECEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAUAAAAAAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAAAAAAYwAAAAAAAAAeAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002bfe6f457dc24215c98f6b0a115b02551c7f061a7ced4163034baf7e78eb8a009" + }, + { + "id": "list_dict_rb_f0", + "description": "l: List?> rows of 2 and 3 items", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAlP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAHAAAAAwAAAAAAAAMfAAAAAEAAAAcAAAABAAEAAQAAAAQABgAFAAOAA8ABAAQAAgAEAAAADgAAABAAAAAAAABAhAAAAA4AAAACAAIAAAABAAIAAAABAAAAPT///8gAAAAAAAAAQgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAGMAAAAAAAAAHgAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABQAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002df102beda16264a918f04162e0eb6b2efc0f14b1029657ba996ce60bd39aeec1" + }, + { + "id": "list_plain_rb_f0", + "description": "l: List with the same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACgAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002df102beda16264a918f04162e0eb6b2efc0f14b1029657ba996ce60bd39aeec1" + }, + { + "id": "list_dict_sliced_rb_f0", + "description": "Row 1 of list_dict, as a slice (non-zero offsets)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAlP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAHAAAAAwAAAAAAAAMfAAAAAEAAAAcAAAABAAEAAQAAAAQABgAFAAOAA8ABAAQAAgAEAAAADgAAABAAAAAAAABAhAAAAA4AAAACAAIAAAABAAIAAAABAAAAPT///8gAAAAAAAAAQgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAGMAAAAAAAAAHgAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000216640c77eda7d4ca8ea6cfb8e5116a03f0107e49b01297ef030a02476797c10d" + }, + { + "id": "list_plain_sliced_rb_f0", + "description": "Row 1 of list_plain, as a slice", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000216640c77eda7d4ca8ea6cfb8e5116a03f0107e49b01297ef030a02476797c10d" + }, + { + "id": "list_struct_dict_rb_f0", + "description": "l: List>>", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAdP///wQAAAABAAAABAAAAOD///8YAAAADAAAAAAAAAy0AAAAAQAAABgAAADQ////EAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAA14AAAAAQAAABwAAAAEAAQABAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAAEAAAAAAAAADEAAAADgAAAAIAAgAAAAEAAgAAAAMAAAACAAKAAQACQAIAAAAIAAAAAABBgAIAAYABgAAAAAAAgAAAAAAAQAAAGYAAAAEAAAAaXRlbQAAAAABAAAAbAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgPwAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAgAAAAAAAAAAAAAAAwAAAAIAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000268f11f1c1d2b9ee547edc62e0ebbb71d7712d16b95c1b30041a10707f83bf9cd" + }, + { + "id": "list_struct_plain_rb_f0", + "description": "l: List> with the same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAAADJAAAAABAAAAGAAAAND///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADVQAAAABAAAAHAAAAAQABAAEAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAZgAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAAAAADgPwAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000268f11f1c1d2b9ee547edc62e0ebbb71d7712d16b95c1b30041a10707f83bf9cd" + }, + { + "id": "list_list_dict_rb_f0", + "description": "l: List?>?>", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAaP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAMsAAAAAEAAAAYAAAAfP///xAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEMdAAAAAEAAAAYAAAArP///xAAGAAUAA4ADwAEABAACAAQAAAAQAAAADQAAAAAAAEFEAAAADQAAAAIAAgAAAAEAAgAAAAMAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABAAEAAQAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAMAAAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAACwAAAAQAAAAAgAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAATAAAABAAAAABAAAAAAAAAAAAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024158ce1007c65d355cf1644d32abe212f8236f8d21ea58a9320b70ff800010e9" + }, + { + "id": "list_list_plain_rb_f0", + "description": "l: List?> with the same values", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAx4AAAAAQAAAAgAAAC0////4P///xgAAAAMAAAAAAABDEwAAAABAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAUAAAAAAAAAIABAAAAAAAAAwAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eXgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024158ce1007c65d355cf1644d32abe212f8236f8d21ea58a9320b70ff800010e9" + }, + { + "id": "dict_of_struct_array_f0", + "description": "hash_array of Dictionary>", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAACwAAAAAAAANEAAAAHQAAAAIAAgAAAAEAAgAAAAEAAAAwP///yAAAAAAAAABAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAAPAAAABAAAAACAAAAAAAAAAAAAAACAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e3a21f5303e4921a2492cfbed2a4fb1562ef08040f22b80add07c74c4a6004fb" + }, + { + "id": "dict_of_struct_plain_array_f0", + "description": "hash_array of the equivalent Struct", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002e3a21f5303e4921a2492cfbed2a4fb1562ef08040f22b80add07c74c4a6004fb" + }, + { + "id": "dict_key_to_null_array_f0", + "description": "hash_array of Dictionary [5, null] where the null comes from the dictionary values", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAAEAAAAAAAAACEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000216a7d4c93bef3b7a6ac5af47a534c5fe0f5e9cbdd7629d688e4b01a8405d724b" + }, + { + "id": "dict_key_to_null_plain_array_f0", + "description": "hash_array of Int64 [5, null]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAgAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000216a7d4c93bef3b7a6ac5af47a534c5fe0f5e9cbdd7629d688e4b01a8405d724b" + }, + { + "id": "ext_custom_python_schema_f0_im1", + "description": "orcapod.ndarray-style extension with metadata {\"version\":1} over LargeBinary", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAKAAAABgAAAAMAAAAAAABExAAAAAAAAAABAAEAAQAAAABAAAAZQAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA8AAABvcmNhcG9kLm5kYXJyYXkAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAYAAAADQAAAHsidmVyc2lvbiI6MX0AAAAYAAAAQVJST1c6ZXh0ZW5zaW9uOm1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025c65180626b6f291abd2cdfa7e333bd2fa22a49c756725f065f40d42747620c5" + }, + { + "id": "ext_uuid_name_only_schema_f0_im1", + "description": "arrow.uuid with ARROW:extension:name only", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAABlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAFAAAAAoAAABhcnJvdy51dWlkAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002807125ef2f793c11e3c015a8eeafcec037c3e9d96963cd5d6570d289ec71f2fe" + }, + { + "id": "ext_uuid_empty_metadata_schema_f0_im1", + "description": "arrow.uuid with ARROW:extension:metadata = \"\"", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAABlAAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002807125ef2f793c11e3c015a8eeafcec037c3e9d96963cd5d6570d289ec71f2fe" + }, + { + "id": "ext_tensor_canonical_schema_f0_im1", + "description": "arrow.fixed_shape_tensor with canonical metadata {\"shape\":[2,2]} over FixedSizeList (schema only)", + "method": "hash_schema", + "include_metadata": true, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAeAAAACAAAAAMAAAAAAABEGAAAAABAAAAJAAAAAAABgAIAAQABgAAAAQAAAAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAQAAABpdGVtAAAAAAEAAABlAAAAAgAAAFgAAAAEAAAAuP///wgAAAAkAAAAGAAAAGFycm93LmZpeGVkX3NoYXBlX3RlbnNvcgAAAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAACAAMAAgABAAIAAAACAAAABgAAAAPAAAAeyJzaGFwZSI6WzIsMl19ABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ddd4ba9ee78b849167c70d47425c15ee3def845916ee62655d5756e98e844733" + }, + { + "id": "empty_name_child_schema_f0", + "description": "s: Struct<\"\": Int32>", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAAAAAAAAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024398254f34467d369ac87ee50160490a036583014f473c59672af76289f26f20" + }, + { + "id": "empty_name_column_schema_f0", + "description": "[\"\": Struct, x: Int32] (child path \"/x\", column \"x\")", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAALD///8QAAAAGAAAAAAAAAIUAAAAoP///yAAAAAAAAABAAAAAAEAAAB4AAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002399b32197aaa8b631b1f0c6fb96284ebd93604410755ed454b446027d2b008b0" + }, + { + "id": "struct_nonnull_child_rb_f0", + "description": "s: Struct? rows [{a:1}, null, {a:3}] (spec worked example)", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + } + ], + "relations": [ + { + "kind": "equal", + "ids": [ + "cols_ab_rb_f0", + "cols_ba_rb_f0" + ], + "why": "column order ignored by default" + }, + { + "kind": "different", + "ids": [ + "cols_ab_rb_f1", + "cols_ba_rb_f1" + ], + "why": "ordered_columns: column order is part of the hash" + }, + { + "kind": "equal", + "ids": [ + "cols_ab_schema_f0", + "cols_ba_schema_f0" + ], + "why": "schema: column order ignored by default" + }, + { + "kind": "different", + "ids": [ + "cols_ab_schema_f1", + "cols_ba_schema_f1" + ], + "why": "schema: ordered_columns" + }, + { + "kind": "equal", + "ids": [ + "cols_ba_stream_f1", + "cols_ba_rb_f1" + ], + "why": "batch-split independence in ordered mode" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f0", + "combo_sn_xy_f0", + "combo_ns_yx_f0", + "combo_sn_yx_f0" + ], + "why": "flags 0: no order matters" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f1", + "combo_ns_yx_f1" + ], + "why": "flags 1: struct order ignored" + }, + { + "kind": "equal", + "ids": [ + "combo_sn_xy_f1", + "combo_sn_yx_f1" + ], + "why": "flags 1: struct order ignored" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f1", + "combo_sn_xy_f1" + ], + "why": "flags 1: column order matters" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_xy_f2", + "combo_sn_xy_f2" + ], + "why": "flags 2: column order ignored" + }, + { + "kind": "equal", + "ids": [ + "combo_ns_yx_f2", + "combo_sn_yx_f2" + ], + "why": "flags 2: column order ignored" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f2", + "combo_ns_yx_f2" + ], + "why": "flags 2: struct order matters" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f3", + "combo_sn_xy_f3", + "combo_ns_yx_f3", + "combo_sn_yx_f3" + ], + "why": "flags 3: both orders matter" + }, + { + "kind": "different", + "ids": [ + "combo_ns_xy_f0", + "combo_ns_xy_f1", + "combo_ns_xy_f2", + "combo_ns_xy_f3" + ], + "why": "the four combinations are domain separated" + }, + { + "kind": "equal", + "ids": [ + "nested_struct_ab_schema_f0", + "nested_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "nested_struct_ab_schema_f2", + "nested_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f0", + "list_struct_ba_rb_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "list_struct_ab_rb_f2", + "list_struct_ba_rb_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "fsl_struct_ab_schema_f0", + "fsl_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "fsl_struct_ab_schema_f2", + "fsl_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "map_struct_ab_schema_f0", + "map_struct_ba_schema_f0" + ], + "why": "struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "map_struct_ab_schema_f2", + "map_struct_ba_schema_f2" + ], + "why": "ordered_struct_fields applies at this depth" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f2", + "large_list_struct_ab_rb_f2" + ], + "why": "List and LargeList agree in ordered mode" + }, + { + "kind": "equal", + "ids": [ + "list_struct_ab_rb_f0", + "large_list_struct_ab_rb_f0" + ], + "why": "List and LargeList agree by default" + }, + { + "kind": "different", + "ids": [ + "one_col_rb_f0", + "one_col_rb_f1", + "one_col_rb_f2", + "one_col_rb_f3" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "different", + "ids": [ + "one_col_schema_f0", + "one_col_schema_f1", + "one_col_schema_f2", + "one_col_schema_f3" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "different", + "ids": [ + "one_col_array_f0", + "one_col_array_f1", + "one_col_array_f2", + "one_col_array_f3" + ], + "why": "every flag value is domain separated, even when order cannot matter" + }, + { + "kind": "equal", + "ids": [ + "plain_schema_f1_im0", + "plain_schema_f1_im1" + ], + "why": "empty-metadata invariant holds within each mode" + }, + { + "kind": "different", + "ids": [ + "plain_schema_f1_im1", + "meta_schema_f1_im1" + ], + "why": "metadata counts within each mode" + }, + { + "kind": "equal", + "ids": [ + "plain_schema_f3_im0", + "plain_schema_f3_im1" + ], + "why": "empty-metadata invariant holds within each mode" + }, + { + "kind": "different", + "ids": [ + "plain_schema_f3_im1", + "meta_schema_f3_im1" + ], + "why": "metadata counts within each mode" + }, + { + "kind": "equal", + "ids": [ + "ext_struct_xy_rb_f0_im1", + "ext_struct_yx_rb_f0_im1" + ], + "why": "extension storage struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "ext_struct_xy_rb_f2_im1", + "ext_struct_yx_rb_f2_im1" + ], + "why": "extension storage struct order counts with ordered_struct_fields" + }, + { + "kind": "equal", + "ids": [ + "empty_stream_f1", + "zero_row_rb_f1" + ], + "why": "a zero-row batch contributes nothing" + }, + { + "kind": "different", + "ids": [ + "zero_cols_0rows_rb_f0", + "zero_cols_3rows_rb_f0" + ], + "why": "format 2 hashes the row count, also of a zero-column table" + }, + { + "kind": "different", + "ids": [ + "zero_cols_0rows_rb_f1", + "zero_cols_3rows_rb_f1" + ], + "why": "format 2 hashes the row count, also of a zero-column table" + }, + { + "kind": "different", + "ids": [ + "zero_cols_0rows_rb_f0", + "zero_cols_0rows_rb_f1" + ], + "why": "zero-column table is still domain separated" + }, + { + "kind": "different", + "ids": [ + "nv_null_struct_rb_f0", + "nv_null_fields_rb_f0" + ], + "why": "v0.5 fix: these collided in v0.4.0" + }, + { + "kind": "different", + "ids": [ + "nv_null_struct_rb_f3", + "nv_null_fields_rb_f3" + ], + "why": "v0.5 fix, also with both order options on" + }, + { + "kind": "different", + "ids": [ + "nv_rows3_rb_f0", + "nv_rows2_rb_f0" + ], + "why": "v0.5 fix: these collided in v0.4.0" + }, + { + "kind": "different", + "ids": [ + "nv_rows3_rb_f3", + "nv_rows2_rb_f3" + ], + "why": "v0.5 fix, also with both order options on" + }, + { + "kind": "different", + "ids": [ + "nv_list_list_1row_rb_f0", + "nv_list_list_2rows_rb_f0" + ], + "why": "v0.5 fix: these collided in v0.4.0" + }, + { + "kind": "different", + "ids": [ + "nv_list_list_1row_rb_f3", + "nv_list_list_2rows_rb_f3" + ], + "why": "v0.5 fix, also with both order options on" + }, + { + "kind": "different", + "ids": [ + "nv_list_null_elem_rb_f0", + "nv_list_null_fields_elem_rb_f0" + ], + "why": "v0.5 fix: these collided in v0.4.0" + }, + { + "kind": "different", + "ids": [ + "nv_list_null_elem_rb_f3", + "nv_list_null_fields_elem_rb_f3" + ], + "why": "v0.5 fix, also with both order options on" + }, + { + "kind": "equal", + "ids": [ + "nv_rows3_stream_f0", + "nv_rows3_rb_f0" + ], + "why": "batch-split independence with nullable struct rows" + }, + { + "kind": "different", + "ids": [ + "nv_array_rows3_f0", + "nv_array_rows2_f0" + ], + "why": "v0.5 fix: hash_array counts null struct rows (v0.4.0 dropped them)" + }, + { + "kind": "different", + "ids": [ + "nv_array_rows3_f3", + "nv_array_rows2_f3" + ], + "why": "v0.5 fix, also with both order options on" + }, + { + "kind": "equal", + "ids": [ + "phys_dict_rb_f0", + "phys_utf8_rb_f0", + "phys_large_utf8_rb_f0" + ], + "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" + }, + { + "kind": "equal", + "ids": [ + "phys_dict_rb_f3", + "phys_utf8_rb_f3", + "phys_large_utf8_rb_f3" + ], + "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" + }, + { + "kind": "equal", + "ids": [ + "array_struct_xy_f0", + "array_struct_yx_f0" + ], + "why": "hash_array: struct order ignored by default" + }, + { + "kind": "different", + "ids": [ + "array_struct_xy_f2", + "array_struct_yx_f2" + ], + "why": "hash_array: ordered_struct_fields" + }, + { + "kind": "different", + "ids": [ + "array_struct_xy_f3", + "array_struct_yx_f3" + ], + "why": "hash_array: ordered_struct_fields with ordered_columns" + }, + { + "kind": "equal", + "ids": [ + "combo_sn_yx_3rows_rb_f3", + "combo_sn_yx_3rows_stream_f3" + ], + "why": "batch-split independence with both order options on (v0.5 Boolean fix)" + }, + { + "kind": "different", + "ids": [ + "bool_1row_rb_f0", + "bool_3rows_rb_f0" + ], + "why": "v0.5 fix: trailing false Boolean rows are counted (v0.4.0 lost them)" + }, + { + "kind": "different", + "ids": [ + "bool_array_1_f0", + "bool_array_2_f0" + ], + "why": "v0.5 fix: hash_array counts trailing false values" + }, + { + "kind": "different", + "ids": [ + "bool_1row_rb_f3", + "bool_3rows_rb_f3" + ], + "why": "v0.5 fix: trailing false Boolean rows are counted (v0.4.0 lost them)" + }, + { + "kind": "different", + "ids": [ + "bool_array_1_f3", + "bool_array_2_f3" + ], + "why": "v0.5 fix: hash_array counts trailing false values" + }, + { + "kind": "equal", + "ids": [ + "bool_nullable_rb_f0", + "bool_nullable_stream_f0" + ], + "why": "v0.5 fix: Boolean columns are batch-split independent (v0.4.0 was not)" + }, + { + "kind": "equal", + "ids": [ + "bool_nullable_rb_f3", + "bool_nullable_stream_f3" + ], + "why": "v0.5 fix: Boolean columns are batch-split independent (v0.4.0 was not)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f0", + "list_kv_ba_rb_f0" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f1", + "list_kv_ba_rb_f1" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f2", + "list_kv_ba_rb_f2" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "different", + "ids": [ + "list_kv_ab_rb_f3", + "list_kv_ba_rb_f3" + ], + "why": "list element order is part of the hash in every mode (starfix never sorts lists)" + }, + { + "kind": "equal", + "ids": [ + "type_utf8_schema_f0", + "type_large_utf8_schema_f0" + ], + "why": "Utf8 and LargeUtf8 share the canonical form" + }, + { + "kind": "equal", + "ids": [ + "type_binary_schema_f0", + "type_large_binary_schema_f0" + ], + "why": "Binary and LargeBinary share the canonical form" + }, + { + "kind": "different", + "ids": [ + "type_utf8_schema_f0", + "type_utf8_view_schema_f0" + ], + "why": "Utf8View is not canonicalized" + }, + { + "kind": "different", + "ids": [ + "meta_map_value_schema_f0_im1", + "meta_map_key_schema_f0_im1", + "meta_map_entries_schema_f0_im1", + "meta_map_all_schema_f0_im1" + ], + "why": "metadata on the map's entries, key and value fields is recorded at distinct paths" + }, + { + "kind": "equal", + "ids": [ + "name_list_item_rb_f0_im1", + "name_list_element_rb_f0_im1" + ], + "why": "the list element field name is not hashed" + }, + { + "kind": "equal", + "ids": [ + "name_map_standard_schema_f0_im1", + "name_map_custom_schema_f0_im1", + "name_map_entries_meta_schema_f0_im1" + ], + "why": "map entries/key/value names and the entries field's metadata are not hashed (pyarrow cannot observe them)" + }, + { + "kind": "equal", + "ids": [ + "name_dict_int8_rb_f0", + "name_dict_int32_ordered_rb_f0" + ], + "why": "dictionary index type and ordered flag are not hashed" + }, + { + "kind": "equal", + "ids": [ + "ext_uuid_rb_f0_im0", + "ext_uuid_storage_rb_f0_im0" + ], + "why": "without include_metadata an extension type hashes as its storage type" + }, + { + "kind": "equal", + "ids": [ + "ext_point_rb_f0_im0", + "ext_point_storage_rb_f0_im0" + ], + "why": "without include_metadata an extension type hashes as its storage type" + }, + { + "kind": "different", + "ids": [ + "ext_uuid_rb_f0_im1", + "ext_uuid_storage_rb_f0_im1" + ], + "why": "with include_metadata both ARROW:extension:* keys are hashed" + }, + { + "kind": "different", + "ids": [ + "ext_point_rb_f0_im1", + "ext_point_storage_rb_f0_im1" + ], + "why": "with include_metadata both ARROW:extension:* keys are hashed" + }, + { + "kind": "different", + "ids": [ + "empty_struct_1row_rb_f0", + "empty_struct_2rows_rb_f0" + ], + "why": "format 2 hashes the row count" + }, + { + "kind": "different", + "ids": [ + "nested_null_inner_list_rb_f0", + "nested_empty_inner_list_rb_f0" + ], + "why": "a null list differs from an empty list, also when nested" + }, + { + "kind": "equal", + "ids": [ + "null_list_slot_with_values_rb_f0", + "null_list_slot_empty_rb_f0" + ], + "why": "values under a null list are not hashed" + }, + { + "kind": "equal", + "ids": [ + "struct_null_hides_5_rb_f0", + "struct_null_hides_6_rb_f0" + ], + "why": "values under a null struct are not hashed (non-nullable child: no validity bits, no values)" + }, + { + "kind": "different", + "ids": [ + "empty_list_rb_f0", + "null_list_rb_f0" + ], + "why": "an empty list differs from a null list" + }, + { + "kind": "equal", + "ids": [ + "dict_null_unused_dup_rb_f0", + "dict_null_unused_dup_plain_rb_f0" + ], + "why": "a dictionary hashes as its logical values" + }, + { + "kind": "different", + "ids": [ + "dict_null_unused_dup_rb_f0", + "dict_same_keys_other_values_rb_f0" + ], + "why": "same index pattern, different values" + }, + { + "kind": "equal", + "ids": [ + "list_dict_rb_f0", + "list_plain_rb_f0" + ], + "why": "dictionary equals plain inside a list" + }, + { + "kind": "equal", + "ids": [ + "list_dict_sliced_rb_f0", + "list_plain_sliced_rb_f0" + ], + "why": "dictionary equals plain inside a sliced list" + }, + { + "kind": "equal", + "ids": [ + "list_struct_dict_rb_f0", + "list_struct_plain_rb_f0" + ], + "why": "dictionary equals plain inside a struct inside a list" + }, + { + "kind": "equal", + "ids": [ + "list_list_dict_rb_f0", + "list_list_plain_rb_f0" + ], + "why": "dictionary equals plain two lists deep" + }, + { + "kind": "equal", + "ids": [ + "dict_of_struct_array_f0", + "dict_of_struct_plain_array_f0" + ], + "why": "a dictionary of structs hashes as its decoded structs" + }, + { + "kind": "equal", + "ids": [ + "dict_key_to_null_array_f0", + "dict_key_to_null_plain_array_f0" + ], + "why": "hash_array nullability counts logical nulls after decoding the dictionary" + }, + { + "kind": "equal", + "ids": [ + "ext_uuid_name_only_schema_f0_im1", + "ext_uuid_empty_metadata_schema_f0_im1" + ], + "why": "an absent ARROW:extension:metadata equals an empty one" + } + ] +} diff --git a/tests/golden/python_literals_format1_inputs.json b/tests/golden/python_literals_format1_inputs.json new file mode 100644 index 0000000..0b8ce9a --- /dev/null +++ b/tests/golden/python_literals_format1_inputs.json @@ -0,0 +1,695 @@ +{ + "description": "Inputs of starfix-python's hand-coded format-1 test literals that format1_to_format2.json does not cover, recovered by recording the calls that produce each literal (ITL-898). Each entry's format1_hash is reproduced by starfix-python 0.4 from ipc_b64 with the given method; Rust is asked to add each input's format-2 value.", + "entries": [ + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestTemporalTypes::test_date64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEIEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////4gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAACgAAAAAAAAAAAAKABgADAAEAAgACgAAADwAAAAQAAAABAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAAAAAAEAAAAEAAAAAAAAAAEAAAAAAAAACwAAAAAAAAAAAAAAAAAAAACc7xJ+AQAAAAAAAAAAAAAApNn6//////////8AAAAA", + "format1_hash": "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_schema_only", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4gFAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAABgAAAAsBQAA4AQAAJwEAABoBAAAOAQAAAQEAADUAwAAoAMAAHADAAA4AwAACAMAANgCAACsAgAAdAIAAEACAAD8AQAAxAEAAJgBAABkAQAAOAEAAAgBAACoAAAARAAAAAQAAABE+///AAABBxAAAAAkAAAABAAAAAAAAAAKAAAAZGVjaW1hbDEyOAAACAAMAAQACAAIAAAAJgAAAAUAAACA+///AAABFRQAAAAgAAAABAAAAAEAAAAYAAAACgAAAGxhcmdlX2xpc3QAAHj7//+w+///AAABAhAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAADo+///AAAAASAAAADg+///AAABDBQAAAAcAAAABAAAAAEAAAAUAAAABAAAAGxpc3QAAAAA1Pv//wz8//8AAAECEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAET8//8AAAABIAAAADz8//8AAAEUEAAAABwAAAAEAAAAAAAAAAoAAABsYXJnZV91dGY4AAAw/P//aPz//wAAAQUQAAAAGAAAAAQAAAAAAAAABAAAAHV0ZjgAAAAAWPz//5D8//8AAAETEAAAACAAAAAEAAAAAAAAAAwAAABsYXJnZV9iaW5hcnkAAAAAiPz//8D8//8AAAEEEAAAABgAAAAEAAAAAAAAAAYAAABiaW5hcnkAALD8//8w/f//AAAACRAAAAAcAAAABAAAAAAAAAALAAAAdGltZTY0X25hbm8AyP///wAAAwBAAAAAZP3//wAAAAkQAAAAKAAAAAQAAAAAAAAADAAAAHRpbWU2NF9taWNybwAAAAAIAAwABgAIAAgAAAAAAAIAQAAAAKT9//8AAAAJEAAAACAAAAAEAAAAAAAAAA0AAAB0aW1lMzJfbWlsbGlzAAAAVP3//9T9//8AAAAJEAAAACAAAAAEAAAAAAAAAA0AAAB0aW1lMzJfc2Vjb25kAAAAUv///wAAAAAI/v//AAAACBAAAAAYAAAABAAAAAAAAAAGAAAAZGF0ZTY0AACw/f//MP7//wAAAAgQAAAAGAAAAAQAAAAAAAAABgAAAGRhdGUzMgAApv///wAAAABc/v//AAAAAxAAAAAYAAAABAAAAAAAAAAHAAAAZmxvYXQ2NADS////AAACAIj+//8AAAADEAAAACAAAAAEAAAAAAAAAAcAAABmbG9hdDMyAAAABgAIAAYABgAAAAAAAQC8/v//AAAAAhAAAAAYAAAABAAAAAAAAAAGAAAAdWludDY0AADu/v//QAAAAOj+//8AAAACEAAAABgAAAAEAAAAAAAAAAUAAABpbnQ2NAAAANj+//8AAAABQAAAABj///8AAAACEAAAABgAAAAEAAAAAAAAAAYAAAB1aW50MzIAAEr///8gAAAARP///wAAAAIQAAAAGAAAAAQAAAAAAAAABQAAAGludDMyAAAANP///wAAAAEgAAAAdP///wAAAAIQAAAAGAAAAAQAAAAAAAAABgAAAHVpbnQxNgAApv///xAAAACg////AAAAAhAAAAAYAAAABAAAAAAAAAAFAAAAaW50MTYAAACQ////AAAAARAAAADQ////AAAAAhAAAAAcAAAABAAAAAAAAAAFAAAAdWludDgABgAIAAQABgAAAAgAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAIAAAAAQAAAAAAAAABAAAAGludDgAAAAACAAMAAgABwAIAAAAAAAAAQgAAAAQABQACAAGAAcADAAAABAAEAAAAAAAAQYQAAAAHAAAAAQAAAAAAAAABAAAAGJvb2wAAAAABAAEAAQAAAD/////AAAAAA==", + "format1_hash": "0000010e62b3f3317d25413b7a4dc6e7a8a6e7c73a73c513cdbe9f9b1f5e5ec56f0e94" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_record_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4gFAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAABgAAAAsBQAA4AQAAJwEAABoBAAAOAQAAAQEAADUAwAAoAMAAHADAAA4AwAACAMAANgCAACsAgAAdAIAAEACAAD8AQAAxAEAAJgBAABkAQAAOAEAAAgBAACoAAAARAAAAAQAAABE+///AAABBxAAAAAkAAAABAAAAAAAAAAKAAAAZGVjaW1hbDEyOAAACAAMAAQACAAIAAAAJgAAAAUAAACA+///AAABFRQAAAAgAAAABAAAAAEAAAAYAAAACgAAAGxhcmdlX2xpc3QAAHj7//+w+///AAABAhAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAADo+///AAAAASAAAADg+///AAABDBQAAAAcAAAABAAAAAEAAAAUAAAABAAAAGxpc3QAAAAA1Pv//wz8//8AAAECEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAET8//8AAAABIAAAADz8//8AAAEUEAAAABwAAAAEAAAAAAAAAAoAAABsYXJnZV91dGY4AAAw/P//aPz//wAAAQUQAAAAGAAAAAQAAAAAAAAABAAAAHV0ZjgAAAAAWPz//5D8//8AAAETEAAAACAAAAAEAAAAAAAAAAwAAABsYXJnZV9iaW5hcnkAAAAAiPz//8D8//8AAAEEEAAAABgAAAAEAAAAAAAAAAYAAABiaW5hcnkAALD8//8w/f//AAAACRAAAAAcAAAABAAAAAAAAAALAAAAdGltZTY0X25hbm8AyP///wAAAwBAAAAAZP3//wAAAAkQAAAAKAAAAAQAAAAAAAAADAAAAHRpbWU2NF9taWNybwAAAAAIAAwABgAIAAgAAAAAAAIAQAAAAKT9//8AAAAJEAAAACAAAAAEAAAAAAAAAA0AAAB0aW1lMzJfbWlsbGlzAAAAVP3//9T9//8AAAAJEAAAACAAAAAEAAAAAAAAAA0AAAB0aW1lMzJfc2Vjb25kAAAAUv///wAAAAAI/v//AAAACBAAAAAYAAAABAAAAAAAAAAGAAAAZGF0ZTY0AACw/f//MP7//wAAAAgQAAAAGAAAAAQAAAAAAAAABgAAAGRhdGUzMgAApv///wAAAABc/v//AAAAAxAAAAAYAAAABAAAAAAAAAAHAAAAZmxvYXQ2NADS////AAACAIj+//8AAAADEAAAACAAAAAEAAAAAAAAAAcAAABmbG9hdDMyAAAABgAIAAYABgAAAAAAAQC8/v//AAAAAhAAAAAYAAAABAAAAAAAAAAGAAAAdWludDY0AADu/v//QAAAAOj+//8AAAACEAAAABgAAAAEAAAAAAAAAAUAAABpbnQ2NAAAANj+//8AAAABQAAAABj///8AAAACEAAAABgAAAAEAAAAAAAAAAYAAAB1aW50MzIAAEr///8gAAAARP///wAAAAIQAAAAGAAAAAQAAAAAAAAABQAAAGludDMyAAAANP///wAAAAEgAAAAdP///wAAAAIQAAAAGAAAAAQAAAAAAAAABgAAAHVpbnQxNgAApv///xAAAACg////AAAAAhAAAAAYAAAABAAAAAAAAAAFAAAAaW50MTYAAACQ////AAAAARAAAADQ////AAAAAhAAAAAcAAAABAAAAAAAAAAFAAAAdWludDgABgAIAAQABgAAAAgAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAIAAAAAQAAAAAAAAABAAAAGludDgAAAAACAAMAAgABwAIAAAAAAAAAQgAAAAQABQACAAGAAcADAAAABAAEAAAAAAAAQYQAAAAHAAAAAQAAAAAAAAABAAAAGJvb2wAAAAABAAEAAQAAAD/////eAUAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAGAEAAAAAAAAAAAoAGAAMAAQACAAKAAAAnAMAABAAAAABAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAABAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAACAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAABAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAAOAAAAAAAAAAIAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAgAAAAAAAAASAAAAAAAAAAAAAAAAAAAAEgAAAAAAAAABAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAIAAAAAAAAAFgAAAAAAAAAAAAAAAAAAABYAAAAAAAAAAQAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAACAAAAAAAAABoAAAAAAAAAAAAAAAAAAAAaAAAAAAAAAAEAAAAAAAAAHAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAQAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAACAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAIgAAAAAAAAAAAAAAAAAAACIAAAAAAAAAAgAAAAAAAAAkAAAAAAAAAAFAAAAAAAAAJgAAAAAAAAAAAAAAAAAAACYAAAAAAAAABAAAAAAAAAAqAAAAAAAAAAGAAAAAAAAALAAAAAAAAAAAAAAAAAAAACwAAAAAAAAAAgAAAAAAAAAuAAAAAAAAAAFAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAABAAAAAAAAAA0AAAAAAAAAALAAAAAAAAAOAAAAAAAAAAAAAAAAAAAADgAAAAAAAAAAgAAAAAAAAA6AAAAAAAAAAAAAAAAAAAAOgAAAAAAAAACAAAAAAAAADwAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAgAAAAAAAAACAEAAAAAAAAAAAAAAAAAAAgBAAAAAAAAEAAAAAAAAAAAAAAAGgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAZAAAAAAAAABkAAAAAAAAAOgDAAAAAAAA6AMAAAAAAACghgEAAAAAAKCGAQAAAAAAAADAPwAAAAAAAAAAAAD4PzFKAAAAAAAAAJzvEn4BAAAQDgAAAAAAAIDuNgAAAAAAAKST1gAAAAAAoLgwRgMAAAAAAAAFAAAAZGF0YTEAAAAAAAAAAAAAAAYAAAAAAAAAbGFyZ2UxAAAAAAAABQAAAHRleHQxAAAAAAAAAAAAAAALAAAAAAAAAGxhcmdlX3RleHQxAAAAAAAAAAAAAgAAAAEAAAACAAAAAAAAAAAAAAACAAAAAAAAAAUAAAAGAAAA0go/Tu7gc8P2D+mOAQAAAP////8AAAAA", + "format1_hash": "0000010f8bb471cb34975f20c4b221abff1a90b2d98f24217a2257e3298ee3d4e9f9c4" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_d_non_nullable_binary", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEEEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABgAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAAAgAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgAAAAAAAABoaQAAAAAAAP////8AAAAA", + "format1_hash": "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestTemporalTypes::test_date32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEIEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABgAGAAAAAAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAGAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAALAAAAAAAAAAAAAAAxSgAAAAAAAP//////////AAAAAA==", + "format1_hash": "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint8", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABAAGAAAACAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAEAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAALAAAAAAAAAAABAP8AAAAA/////wAAAAA=", + "format1_hash": "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestTemporalTypes::test_time64_nanoseconds", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEJEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAGAAgACAAAAAAAAwBAAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAoAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAQAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAgAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAA0AAAAAAAAAAMqaOwAAAAAAAAAAAAAAAADyBSoBAAAAAAAAAAAAAAD/////AAAAAA==", + "format1_hash": "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint16", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABAAGAAAAEAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAEAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAALAAAAAAAAAAAA6AMAAP///////wAAAAA=", + "format1_hash": "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABAAGAAAAQAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAKAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAMqaOwAAAAAAAAAAAAAAAP///////////////wAAAAA=", + "format1_hash": "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestStructTypes::test_struct_with_nullable_children", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////+AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAnP///wAAAA0YAAAAHAAAAAQAAAACAAAAXAAAACAAAAABAAAAcwAAAMz///8QABQACAAGAAcADAAAABAAEAAAAAAAAQYQAAAAGAAAAAQAAAAAAAAAAQAAAGIAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAABAAAAYQAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP/////YAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAgAAAAAAAAAAAACgAYAAwABAAIAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAABAAAAAAAAAAAAAAADAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAD/////AAAAAA==", + "format1_hash": "0000015f1992c5f9130aaa64aa1360e53ddd00b427855ae02e380f534a629353135680" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int16", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAEQAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAQAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAQAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAA0AAAAAAAAA6AMAABj8/3//////AAAAAA==", + "format1_hash": "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAIAAYABwAMAAAAEAAQAAAAAAABFBAAAAAcAAAABAAAAAAAAAAEAAAAbmFtZQAAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAADAAAAYWdlAAgADAAIAAcACAAAAAAAAAEgAAAA/////8gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADAAAAAAAAAAAAAKABgADAAEAAgACgAAAGwAAAAQAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAABAAAAAAAAABAAAAAAAAAAGAAAAAAAAAAoAAAAAAAAAAUAAAAAAAAAAAAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAABkAAAAeAAAAAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAABQAAAAAAAABBbGljZQAAAP////8AAAAA", + "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAFAAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAoAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAQAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAgAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAA0AAAAAAAAAQEIPAAAAAAAAAAAAAAAAAMC98P//////AAAAAAAAAAD/////AAAAAA==", + "format1_hash": "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int8", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAEIAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAQAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAQAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAA0AAAAAAAAAAQD/fwAAAAD/////AAAAAA==", + "format1_hash": "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_n_list_of_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEVFAAAABwAAAAEAAAAAQAAABQAAAAFAAAAaXRlbXMAAACo////pP///wAAAA0YAAAAIAAAAAQAAAACAAAAVAAAABQAAAAEAAAAaXRlbQAAAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABQAAAGxhYmVsAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABQAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAIAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAMAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAACAAAAAAAAAASAAAAAAAAAADAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAGFiYwAAAAAA/////wAAAAA=", + "format1_hash": "0000019c9cc6230a42e646a475ec1c8125fe396dcace351d64ff6e63e8f53d329c4895" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestTemporalTypes::test_time32_milliseconds", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEJEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////4gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABgAAAAAAAAAAAAKABgADAAEAAgACgAAADwAAAAQAAAABAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAEAAAAEAAAAAAAAAAEAAAAAAAAADQAAAAAAAABAQg8AAAAAAEBLTAAAAAAA/////wAAAAA=", + "format1_hash": "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEDEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABgAGAAAAAAACAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAKAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAANAAAAAAAAAAAAAAAAAPg/AAAAAAAAAAAfhetRuB4JwAAAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABAAGAAAAIAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAGAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAALAAAAAAAAAAAAAABAQg8AAAAAAP//////////AAAAAA==", + "format1_hash": "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_i_empty_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAIAAYABwAMAAAAEAAQAAAAAAABBhAAAAAYAAAABAAAAAAAAAABAAAAYgAAAAQABAAEAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAABhAAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_k_struct_column", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////9gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAApP///wAAAA0YAAAAIAAAAAQAAAACAAAAVAAAABQAAAAGAAAAcGVyc29uAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABAAAAG5hbWUAAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAwAAAGFnZQAIAAwACAAHAAgAAAAAAAABIAAAAAAAAAD/////6AAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAKAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAfAAAABAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAGAAAAAAAAAAgAAAAAAAAAAgAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAZAAAAHgAAAAAAAAAAAAAABQAAAAAAAAAIAAAAAAAAAEFsaWNlQm9i/////wAAAAA=", + "format1_hash": "000001e3516302d68fd1fc4860fa4b7e0d4a6d60d500a9d7ccae79e445c5980021e4ec" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_o_nested_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAASP///wAAAA0YAAAAHAAAAAQAAAACAAAAsAAAABAAAAABAAAAcwAAAND///90////AAAADRgAAAAkAAAABAAAAAIAAABIAAAAGAAAAAYAAABuZXN0ZWQAAAQABAAEAAAAqP///wAAAAIQAAAAFAAAAAQAAAAAAAAAAQAAAHEAAACY////AAAAASAAAADU////AAAAAhAAAAAUAAAABAAAAAAAAAABAAAAcAAAAMT///8AAAABIAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAABAAAAYQAAAAgADAAIAAcACAAAAAAAAAEgAAAA/////ygBAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABgAAAAAAAAAAAAKABgADAAEAAgACgAAAJwAAAAQAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAFAAAAAAAAAAeAAAAAAAAAP////8AAAAA", + "format1_hash": "000001e732b8458782d9a331722698883617eec7cd1492028947b4ce3e97c7d6201550" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_bool", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEGEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////4gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABAAAAAAAAAAAAAKABgADAAEAAgACgAAADwAAAAQAAAABAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAEAAAAAAAAAAAAAAAEAAAAEAAAAAAAAAAEAAAAAAAAACwAAAAAAAAAJAAAAAAAAAP////8AAAAA", + "format1_hash": "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_f_utf8_equivalence", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEFEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABAAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAYWIAAAAAAAD/////AAAAAA==", + "format1_hash": "000001f14d076ffc02533c6560f867b86cde7e15b1a0ac5a892b53697a609191cf307f" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEDEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABgAGAAAAAAABAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAGAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAEAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAANAAAAAAAAAAAAwD8AAAAAw/VIwAAAAAD/////AAAAAA==", + "format1_hash": "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_e_column_order_independence", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAIAAYABwAMAAAAEAAQAAAAAAABBhAAAAAYAAAABAAAAAAAAAABAAAAeQAAAAQABAAEAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAAB4AAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////7gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABAAAAAAAAAAAAAKABgADAAEAAgACgAAAFwAAAAQAAAAAQAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAACgAAAAAAAAABAAAAAAAAAP////8AAAAA", + "format1_hash": "000001f68bf6319f8ec4aa938e52dd911974348289fbdfb9b5ebed5e14e239a6d8a3a9" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestBinaryVariedSizes::test_binary_varied_sizes", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEEEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADgAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAABQAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAABgAAAAAAAAAIAAAAAAAAAASAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAABsAAAAAAAAAAAAAABAAAAAQAAAAEAAAABEAAAASAAAAAAECAwQFBgcICQoLDA0OD/8AAAAAAAAA/////wAAAAA=", + "format1_hash": "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_int32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAYAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAQAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAABAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "format1_hash": "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////+gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEVFAAAABwAAAAEAAAAAQAAABQAAAAFAAAAYXJyYXkAAADU////0P///wAAABUUAAAAIAAAAAQAAAABAAAAKAAAAAQAAABpdGVtAAAAAAQABAAEAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAACAAAAAEAAAAAAAAAAQAAABpdGVtAAAAAAgADAAIAAcACAAAAAAAAAEgAAAA/////+gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAAFgAAAAAAAAAAAAKABgADAAEAAgACgAAAHwAAAAQAAAAAgAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAGAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAKAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAAAAAAADAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAMAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAP////8AAAAA", + "format1_hash": "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListOfStruct::test_list_of_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEVFAAAABwAAAAEAAAAAQAAABQAAAAFAAAAYXJyYXkAAACo////pP///wAAAA0YAAAAIAAAAAQAAAACAAAAVAAAABQAAAAEAAAAaXRlbQAAAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABAAAAG5hbWUAAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABYAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAIAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAQAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAACgAAAAAAAAAUAAAAAAAAAAEAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAAYWJjZAAAAAD/////AAAAAA==", + "format1_hash": "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAAAQAQAAZAAAAAQAAAAM////AAABFRQAAAAgAAAABAAAAAEAAAAYAAAACAAAAHJlYWRpbmdzAAAAAAT///98////AAAAAxAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAABu////AAABAKj///8AAAANGAAAACAAAAAEAAAAAgAAAFAAAAAUAAAABgAAAGNvb3JkcwAAYP///9j///8AAAADEAAAABQAAAAEAAAAAAAAAAMAAABsb24Axv///wAAAgAQABQACAAAAAcADAAAABAAEAAAAAAAAAMQAAAAHAAAAAQAAAAAAAAAAwAAAGxhdAAAAAYACAAGAAYAAAAAAAIAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABwAAAAEAAAAAAAAAAQAAABuYW1lAAAAAAQABAAEAAAAAAAAAP////94AQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAACgAAAAAAAAAAAACgAYAAwABAAIAAoAAADcAAAAEAAAAAMAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAgAAAAAAAAACgAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAGAAAAAAAAABIAAAAAAAAAAAAAAAAAAAASAAAAAAAAAAYAAAAAAAAAGAAAAAAAAAAAQAAAAAAAABoAAAAAAAAACAAAAAAAAAAiAAAAAAAAAAAAAAAAAAAAIgAAAAAAAAAFAAAAAAAAAAAAAAABgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAgAAAAAAAABBQwAAAAAAAJqZmZmZWURAAAAAAAAAQUAAAAAAAMBJQAAAAAAAgFLAzczMzMyMXcCamZmZmZm5vwUAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAAABQAAAAAAAAAAAIA/AAAAQAAAQEAAAIBAAACgQAAAAAD/////AAAAAA==", + "format1_hash": "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_string", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAACgAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAACAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "format1_hash": "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_bool_false", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEGEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////4gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAAAgAAAAAAAAAAAAKABgADAAEAAgACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "format1_hash": "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAAAQAQAAZAAAAAQAAAAM////AAABFRQAAAAgAAAABAAAAAEAAAAYAAAACAAAAHJlYWRpbmdzAAAAAAT///98////AAAAAxAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAABu////AAABAKj///8AAAANGAAAACAAAAAEAAAAAgAAAFAAAAAUAAAABgAAAGNvb3JkcwAAYP///9j///8AAAADEAAAABQAAAAEAAAAAAAAAAMAAABsb24Axv///wAAAgAQABQACAAAAAcADAAAABAAEAAAAAAAAAMQAAAAHAAAAAQAAAAAAAAAAwAAAGxhdAAAAAYACAAGAAYAAAAAAAIAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABwAAAAEAAAAAAAAAAQAAABuYW1lAAAAAAQABAAEAAAAAAAAAP////8AAAAA", + "format1_hash": "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////0ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAENGAAAACAAAAAEAAAAAgAAAEQAAAAUAAAABQAAAGFycmF5AAAAgP///3z///8AAAACEAAAABQAAAAEAAAAAAAAAAEAAAB4AAAAbP///wAAAAEgAAAAqP///wAAAA0YAAAAIAAAAAQAAAACAAAAUAAAABQAAAAFAAAAaW5uZXIAAADc////2P///wAAABQQAAAAGAAAAAQAAAAAAAAAAQAAAHoAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAABAAAAeQAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////84AQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAwAAAAAAAAAAAACgAYAAwABAAIAAoAAACsAAAAEAAAAAIAAAAAAAAAAAAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAGAAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAKAAAAAAAAAAAAAAAAAAAACgAAAAAAAAACAAAAAAAAAAAAAAABQAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAABhYgAAAAAAAAUAAAAGAAAA/////wAAAAA=", + "format1_hash": "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestNullableStructHashArray::test_nullable_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////+AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAENGAAAACAAAAAEAAAAAgAAAFAAAAAUAAAABQAAAGFycmF5AAAA3P///9j///8AAAAUEAAAABgAAAAEAAAAAAAAAAEAAABiAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAQAAAGEAAAAIAAwACAAHAAgAAAAAAAABIAAAAP/////oAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABAAAAAAAAAAAAACgAYAAwABAAIAAoAAAB8AAAAEAAAAAMAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAgAAAAAAAAADgAAAAAAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAUAAAAAAAAACgAAABQAAAAeAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAeHl6AAAAAAD/////AAAAAA==", + "format1_hash": "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAAAIAQAAXAAAAAQAAAB8////AAABFRQAAAAcAAAABAAAAAEAAAAUAAAABAAAAHRhZ3MAAAAARP///6j///8AAAEUEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAGz///9o////AAAADRgAAAAgAAAABAAAAAIAAABYAAAAJAAAAAQAAABtZXRhAAAAAJz///8QABQACAAGAAcADAAAABAAEAAAAAAAAQIQAAAAGAAAAAQAAAAAAAAABQAAAHZhbHVlAAAAnP///wAAAAEgAAAA2P///wAAABQQAAAAGAAAAAQAAAAAAAAAAwAAAGtleQAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAFAAAAAAAAAAP////8AAAAA", + "format1_hash": "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestStructEmptyBatch::test_struct_empty_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////wgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAaP///wAAAA0cAAAAJAAAAAQAAAADAAAAkAAAAEgAAAAUAAAABgAAAHBlcnNvbgAAZP///5z///8AAAADEAAAABwAAAAEAAAAAAAAAAUAAABzY29yZQAGAAgABgAGAAAAAAACAMz///8AAAACEAAAABwAAAAEAAAAAAAAAAMAAABhZ2UACAAMAAgABwAIAAAAAAAAASAAAAAQABQACAAAAAcADAAAABAAEAAAAAAAABQQAAAAHAAAAAQAAAAAAAAABAAAAG5hbWUAAAAABAAEAAQAAAD/////AAAAAA==", + "format1_hash": "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestBatchAllNullColumn::test_batch_all_null_column", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAIAAYABwAMAAAAEAAQAAAAAAABFBAAAAAcAAAABAAAAAAAAAAFAAAAdmFsdWUAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAEgAAAA/////8gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADgAAAAAAAAAAAAKABgADAAEAAgACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAABAAAAAAAAABgAAAAAAAAAIAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAADAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAAAIAQAAXAAAAAQAAAB8////AAABFRQAAAAcAAAABAAAAAEAAAAUAAAABAAAAHRhZ3MAAAAARP///6j///8AAAEUEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAGz///9o////AAAADRgAAAAgAAAABAAAAAIAAABYAAAAJAAAAAQAAABtZXRhAAAAAJz///8QABQACAAGAAcADAAAABAAEAAAAAAAAQIQAAAAGAAAAAQAAAAAAAAABQAAAHZhbHVlAAAAnP///wAAAAEgAAAA2P///wAAABQQAAAAGAAAAAQAAAAAAAAAAwAAAGtleQAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAFAAAAAAAAAAP////+IAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAACAAAAAAAAAAAAACgAYAAwABAAIAAoAAADsAAAAEAAAAAIAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAYAAAAAAAAACgAAAAAAAAABAAAAAAAAAAwAAAAAAAAAAEAAAAAAAAAOAAAAAAAAAAIAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAABgAAAAAAAAAWAAAAAAAAAAAAAAAAAAAAFgAAAAAAAAAIAAAAAAAAAB4AAAAAAAAAAYAAAAAAAAAAAAAAAYAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAABkAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAazFrMgAAAAABAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAABgAAAAAAAAB0MXQydDMAAP////8AAAAA", + "format1_hash": "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_nullable_inner_field", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA1P///wAAARUUAAAAHAAAAAQAAAABAAAAJAAAAAUAAABhcnJheQAAAJj///8QABQACAAGAAcADAAAABAAEAAAAAAAAQ0YAAAAIAAAAAQAAAACAAAAVAAAABQAAAAEAAAAaXRlbQAAAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABQAAAGxhYmVsAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABYAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAIAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAQAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAACgAAAAAAAAAUAAAAAAAAAAEAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAAYWJjZAAAAAD/////AAAAAA==", + "format1_hash": "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAYP///wAAAA0YAAAAIAAAAAQAAAACAAAAmAAAABQAAAAGAAAAcmVjb3JkAADU////0P///wAAAQwUAAAAIAAAAAQAAAABAAAAKAAAAAQAAAB0YWdzAAAAAAQABAAEAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAMT///8AAAABIAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAEgAAAA/////wAAAAA=", + "format1_hash": "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestNullableStructBatch::test_nullable_struct_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////+AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAENGAAAABwAAAAEAAAAAgAAAEwAAAAQAAAAAQAAAHMAAADc////2P///wAAAAYQAAAAGAAAAAQAAAAAAAAAAQAAAGIAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAABAAAAYQAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP/////YAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAgAAAAAAAAAAAACgAYAAwABAAIAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAABAAAAAAAAAAAAAAADAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAABQAAAAAAAAABAAAAAgAAAAMAAAAAAAAABQAAAAAAAAD/////AAAAAA==", + "format1_hash": "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////9gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///wAAABUUAAAAGAAAAAQAAAABAAAAEAAAAAMAAABjb2wA1P///9D///8AAAAVFAAAACAAAAAEAAAAAQAAACgAAAAEAAAAaXRlbQAAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAgAAAABAAAAAAAAAAEAAAAaXRlbQAAAAAIAAwACAAHAAgAAAAAAAABIAAAAAAAAAD/////AAAAAA==", + "format1_hash": "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_string", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAACAAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAALAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAAAAABoZWxsbyB3b3JsZAAAAAAA/////wAAAAA=", + "format1_hash": "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestNonNullableList::test_list_non_nullable", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA0P///wAAAQwUAAAAIAAAAAQAAAABAAAAKAAAAAUAAABhcnJheQAAAAQABAAEAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAQAAABpdGVtAAAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////+4AAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAoAAAAAAAAAAAACgAYAAwABAAIAAoAAABcAAAAEAAAAAMAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABgAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAYAAAABAAAAAgAAAAMAAAAEAAAABQAAAAYAAAD/////AAAAAA==", + "format1_hash": "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_int32_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////9wAAAAEAAAAAAACgAOAAYABQAIAAoAAAAAAwQAEAAAAAAACgAMAAAABAAIAAoAAAAwAAAABAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "format1_hash": "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////9gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///wAAABUUAAAAGAAAAAQAAAABAAAAEAAAAAMAAABjb2wA1P///9D///8AAAAVFAAAACAAAAAEAAAAAQAAACgAAAAEAAAAaXRlbQAAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAgAAAABAAAAAAAAAAEAAAAaXRlbQAAAAAIAAwACAAHAAgAAAAAAAABIAAAAAAAAAD/////6AAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAWAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAfAAAABAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAoAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAABgAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAFAAAAAAAAAAYAAAAAAAAAAQAAAAIAAAADAAAABAAAAAUAAAAGAAAA/////wAAAAA=", + "format1_hash": "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_non_nullable_inner_field", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEVFAAAABwAAAAEAAAAAQAAABQAAAAFAAAAYXJyYXkAAACo////pP///wAAAA0YAAAAIAAAAAQAAAACAAAAVAAAABQAAAAEAAAAaXRlbQAAAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABQAAAGxhYmVsAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABYAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAIAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAQAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAACgAAAAAAAAAUAAAAAAAAAAEAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAEAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAAYWJjZAAAAAD/////AAAAAA==", + "format1_hash": "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestSchema4LevelNestedStruct::test_schema_4_level_nested_struct", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////ygBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAWP///wAAAA0UAAAAHAAAAAQAAAABAAAAFAAAAAQAAAByb290AAAAAIj///+E////AAAADRQAAAAYAAAABAAAAAEAAAAQAAAAAgAAAGwxAACw////rP///wAAAA0UAAAAGAAAAAQAAAABAAAAEAAAAAIAAABsMgAA2P///9T///8AAAANFAAAABwAAAAEAAAAAQAAACQAAAACAAAAbDMAAAQABAAEAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAACAAAAAEAAAAAAAAAAQAAABsZWFmAAAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////8AAAAA", + "format1_hash": "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestSchemaListOfStructWithList::test_schema_list_of_struct_with_list", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////2gBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAATP///wAAARUUAAAAHAAAAAQAAAABAAAAFAAAAAYAAABldmVudHMAAET///9A////AAAADRwAAAAkAAAABAAAAAMAAAC4AAAAfAAAABQAAAAEAAAAaXRlbQAAAAB4////rP///wAAARUUAAAAHAAAAAQAAAABAAAAFAAAAAQAAAB0YWdzAAAAAKT///+g////AAAAFBAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAADM////EAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABgAAAAEAAAAAAAAAAMAAABtc2cABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAHRzAAAIAAwACAAHAAgAAAAAAAABQAAAAAAAAAD/////AAAAAA==", + "format1_hash": "0000017f5258ff48e85b2a63cd1a29590ff3bfca39bf718365200ad74a8232bb654ec6" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAADQAAAAlAAAAAQAAABM////AAAADRgAAAAcAAAABAAAAAIAAABAAAAAEAAAAAEAAAB6AAAAfP///7D///8AAAEDEAAAABgAAAAEAAAAAAAAAAEAAABiAAYACAAGAAYAAAAAAAIApP///wAAAAYQAAAAFAAAAAQAAAAAAAAAAQAAAGEAAADM////EAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABgAAAAEAAAAAAAAAAEAAAB5AAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAQAAAHgAAAAIAAwACAAHAAgAAAAAAAABIAAAAAAAAAD/////AAAAAA==", + "format1_hash": "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestNullableListStructNullableChildren::test_nullable_list_struct_nullable_children_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAApP///wAAARUUAAAAHAAAAAQAAAABAAAAFAAAAAUAAABpdGVtcwAAAJj///+U////AAAADRgAAAAgAAAABAAAAAIAAABkAAAAJAAAAAQAAABpdGVtAAAAAMj///8QABQACAAGAAcADAAAABAAEAAAAAAAARQQAAAAHAAAAAQAAAAAAAAABQAAAGxhYmVsAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABgAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAIAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAYAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAMAAAAAAAAADAAAAAAAAAAAQAAAAAAAAA4AAAAAAAAACAAAAAAAAAAWAAAAAAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAgAAAAAAAABhYwAAAAAAAP////8AAAAA", + "format1_hash": "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestFloatSpecialValues::test_float64_special_values", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEDEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAGAAgABgAGAAAAAAACAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAKAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAAFAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAQAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAD4fwAAAAAAAPB/AAAAAAAA8P8AAAAAAAAAAAAAAAAAAACA/////wAAAAA=", + "format1_hash": "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema_hash", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAMAAADQAAAAlAAAAAQAAABM////AAAADRgAAAAcAAAABAAAAAIAAABAAAAAEAAAAAEAAAB6AAAAfP///7D///8AAAEDEAAAABgAAAAEAAAAAAAAAAEAAABiAAYACAAGAAYAAAAAAAIApP///wAAAAYQAAAAFAAAAAQAAAAAAAAAAQAAAGEAAADM////EAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABgAAAAEAAAAAAAAAAEAAAB5AAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAQAAAHgAAAAIAAwACAAHAAgAAAAAAAABIAAAAAAAAAD/////AAAAAA==", + "format1_hash": "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestStructMixedTypes::test_struct_mixed_types_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3ABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAnP///wAAAQ0gAAAAKAAAAAQAAAAEAAAA8AAAALAAAACEAAAAFAAAAAUAAABhcnJheQAAAET///9A////AAAADBQAAAAcAAAABAAAAAEAAAAkAAAABgAAAHNjb3JlcwAAcP///xAAFAAIAAYABwAMAAAAEAAQAAAAAAABAhAAAAAYAAAABAAAAAAAAAAEAAAAaXRlbQAAAABw////AAAAASAAAACs////AAAABhAAAAAYAAAABAAAAAAAAAAGAAAAYWN0aXZlAADY////1P///wAAABQQAAAAHAAAAAQAAAAAAAAABAAAAG5hbWUAAAAABAAEAAQAAAAQABQACAAAAAcADAAAABAAEAAAAAAAAAIQAAAAHAAAAAQAAAAAAAAAAgAAAGlkAAAIAAwACAAHAAgAAAAAAAABIAAAAP////94AQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABQAAAAAAAAAAAACgAYAAwABAAIAAoAAADcAAAAEAAAAAIAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAYAAAAAAAAACAAAAAAAAAACAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAABAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAwAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAABgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAFAAAAAAAAAAgAAAAAAAAAQWxpY2VCb2IBAAAAAAAAAAAAAAACAAAAAwAAAAAAAABaAAAAVQAAAEYAAAAAAAAA/////wAAAAA=", + "format1_hash": "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_bool_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEGEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////3AAAAAQAAAAAAAKAA4ABgAFAAgACgAAAAADBAAQAAAAAAAKAAwAAAAEAAgACgAAADAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestListOfStruct::test_nullable_list_of_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEVFAAAABwAAAAEAAAAAQAAABQAAAAFAAAAYXJyYXkAAACs////qP///wAAAA0YAAAAIAAAAAQAAAACAAAAUAAAABQAAAAEAAAAaXRlbQAAAADc////2P///wAAABQQAAAAGAAAAAQAAAAAAAAAAwAAAHZhbAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////8YAQAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAABgAAAAAAAAAAAACgAYAAwABAAIAAoAAACcAAAAEAAAAAMAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAgAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAMAAAAAAAAADgAAAAAAAAAAAAAAAAAAAA4AAAAAAAAACAAAAAAAAAAWAAAAAAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAKAAAAFAAAAB4AAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAABwcXIAAAAAAP////8AAAAA", + "format1_hash": "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestStructFieldOrderIndependence::test_struct_3field_order_independence", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////wgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAENHAAAACQAAAAEAAAAAwAAAHgAAAA8AAAAFAAAAAUAAABhcnJheQAAALj///+0////AAAABhAAAAAUAAAABAAAAAAAAAABAAAAYwAAANz////Y////AAAAFBAAAAAYAAAABAAAAAAAAAABAAAAYgAAAAQABAAEAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAABhAAAACAAMAAgABwAIAAAAAAAAASAAAAD/////GAEAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAMAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAnAAAABAAAAACAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAGAAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAKAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAQAAAAAAAAAAAAAABAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAHh5AAAAAAAAAQAAAAAAAAD/////AAAAAA==", + "format1_hash": "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestUnicodeStrings::test_unicode_string_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEUEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////5gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAAFgAAAAAAAAAAAAKABgADAAEAAgACgAAAEwAAAAQAAAABQAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAAAAADAAAAAAAAAAOAAAAAAAAAAcAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAABcAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAsAAAAAAAAAFwAAAAAAAAAXAAAAAAAAABwAAAAAAAAAaGVsbG/kuJbnlYzwn4yN8J+MjvCfjI9jYWbDqQAAAAD/////AAAAAA==", + "format1_hash": "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestNestedNullableInnerStruct::test_nested_nullable_inner_struct", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////0gBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA0P///wAAAQ0YAAAAIAAAAAQAAAACAAAAxAAAACQAAAAFAAAAYXJyYXkAAADA////EAAUAAgABgAHAAwAAAAQABAAAAAAAAENGAAAACQAAAAEAAAAAgAAAEgAAAAYAAAABQAAAGlubmVyAAAABAAEAAQAAACo////AAAAAhAAAAAUAAAABAAAAAAAAAABAAAAcQAAAJj///8AAAABIAAAANT///8AAAACEAAAABQAAAAEAAAAAAAAAAEAAABwAAAAxP///wAAAAEgAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAABhAAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////ygBAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADgAAAAAAAAAAAAKABgADAAEAAgACgAAAJwAAAAQAAAAAwAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAQAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAMAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAwAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAFAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAEAAAABQAAAAYAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestLargeSchema::test_large_schema_12_fields", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xADAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAwAAACoAgAAaAIAACgCAAD4AQAAxAEAAJgBAABsAQAARAEAABwBAADwAAAAYAAAAAQAAADU/f//AAABFRQAAAAYAAAABAAAAAEAAAAQAAAAAwAAAGYxMgCw/v///P3//wAAAQIQAAAAGAAAAAQAAAAAAAAABAAAAGl0ZW0AAAAAtP3//wAAAAEgAAAA8P3//wAAAA0YAAAAHAAAAAQAAAACAAAAQAAAABAAAAADAAAAZjExAAz///9Y/v//AAABFBAAAAAcAAAABAAAAAAAAAAIAAAAbmVzdGVkX2IAAAAAOP///0j+//8AAAACEAAAABwAAAAEAAAAAAAAAAgAAABuZXN0ZWRfYQAAAABA/v//AAAAASAAAAC4/v//AAABCBAAAAAUAAAABAAAAAAAAAADAAAAZjEwAD7///8AAAAApP7//wAAABMQAAAAFAAAAAQAAAAAAAAAAwAAAGYwOQC4////BP///wAAARQQAAAAFAAAAAQAAAAAAAAAAwAAAGYwOADc////7P7//wAAAAYQAAAAGAAAAAQAAAAAAAAAAwAAAGYwNwAEAAQABAAAAFD///8AAAEDEAAAABQAAAAEAAAAAAAAAAMAAABmMDYA1v///wAAAgA8////AAAAAxAAAAAcAAAABAAAAAAAAAADAAAAZjA1AAAABgAIAAYABgAAAAAAAQCo////AAABAhAAAAAUAAAABAAAAAAAAAADAAAAZjA0AFz///8AAAABQAAAAJj///8AAAACEAAAABQAAAAEAAAAAAAAAAMAAABmMDMAiP///wAAAAEgAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABQAAAAEAAAAAAAAAAMAAABmMDIAxP///wAAAAEQAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAMAAABmMDEACAAMAAgABwAIAAAAAAAAAQgAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestMultiBatchStruct::test_multi_batch_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////+gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAlP///wAAAA0YAAAAIAAAAAQAAAACAAAAZAAAACQAAAABAAAAcwAAAAQABAAEAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABQAAAAEAAAAAAAAAAEAAAB5AAAAxP///wAAAAEgAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAAB4AAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////9gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABgAAAAAAAAAAAAKABgADAAEAAgACgAAAGwAAAAQAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAABAAAAAgAAAAEAAAAAAAAACgAAAAAAAAD/////2AAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAEAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAHgAAAAAAAAD/////AAAAAA==", + "format1_hash": "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_int64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////4AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAUAAABhcnJheQAAAAgADAAIAAcACAAAAAAAAAFAAAAAAAAAAP////+IAAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAIAAAAAAAAAAAACgAYAAwABAAIAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAP/jC1QCAAAA/////wAAAAA=", + "format1_hash": "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////xgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAYP///wAAAA0YAAAAIAAAAAQAAAACAAAAmAAAABQAAAAGAAAAcmVjb3JkAADU////0P///wAAAQwUAAAAIAAAAAQAAAABAAAAKAAAAAQAAAB0YWdzAAAAAAQABAAEAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAABgAAAAEAAAAAAAAAAQAAABpdGVtAAAAAMT///8AAAABIAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAACAAAAaWQAAAgADAAIAAcACAAAAAAAAAEgAAAA/////wgBAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADgAAAAAAAAAAAAKABgADAAEAAgACgAAAIwAAAAQAAAAAwAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAQAAAAAAAAAYAAAAAAAAABAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAACgAAAAAAAAADAAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAADAAAACgAAABQAAAAeAAAAAAAAAP////8AAAAA", + "format1_hash": "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAATP///wAAAA0YAAAAHAAAAAQAAAACAAAArAAAABAAAAADAAAAdG9wANT///94////AAAADRgAAAAgAAAABAAAAAIAAABEAAAAFAAAAAMAAABtaWQABAAEAAQAAACo////AAAAAhAAAAAUAAAABAAAAAAAAAABAAAAegAAAJj///8AAAABIAAAANT///8AAAACEAAAABQAAAAEAAAAAAAAAAEAAAB5AAAAxP///wAAAAEgAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAAB4AAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////wAAAAA=", + "format1_hash": "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestBooleanArrays::test_bool_17_elements", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAEGEAAAABwAAAAEAAAAAAAAAAUAAABhcnJheQAAAAQABAAEAAAA/////4gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABAAAAAAAAAAAAAKABgADAAEAAgACgAAADwAAAAQAAAAEQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAwAAAAAAAAAIAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAARAAAAAAAAAAMAAAAAAAAA730BAAAAAABNNQEAAAAAAP////8AAAAA", + "format1_hash": "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestMultiBatchList::test_multi_batch_list", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7AAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA0P///wAAARUUAAAAIAAAAAQAAAABAAAAKAAAAAUAAABpdGVtcwAAAAQABAAEAAAAEAAUAAgABgAHAAwAAAAQABAAAAAAAAECEAAAACAAAAAEAAAAAAAAAAQAAABpdGVtAAAAAAgADAAIAAcACAAAAAAAAAEgAAAAAAAAAP////+4AAAAFAAAAAAAAAAMABYABgAFAAgADAAMAAAAAAMEABgAAAAoAAAAAAAAAAAACgAYAAwABAAIAAoAAABcAAAAEAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAYAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAgAAAAAAAAAAAAAAAIAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAQAAAAIAAAD/////uAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAAIAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAMAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAwAAAAQAAAAFAAAAAAAAAP////8AAAAA", + "format1_hash": "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "test": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zABAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAEAAAATP///wAAAA0YAAAAHAAAAAQAAAACAAAArAAAABAAAAADAAAAdG9wANT///94////AAAADRgAAAAgAAAABAAAAAIAAABEAAAAFAAAAAMAAABtaWQABAAEAAQAAACo////AAAAAhAAAAAUAAAABAAAAAAAAAABAAAAegAAAJj///8AAAABIAAAANT///8AAAACEAAAABQAAAAEAAAAAAAAAAEAAAB5AAAAxP///wAAAAEgAAAAEAAUAAgAAAAHAAwAAAAQABAAAAAAAAACEAAAABwAAAAEAAAAAAAAAAEAAAB4AAAACAAMAAgABwAIAAAAAAAAASAAAAAAAAAA/////ygBAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAABgAAAAAAAAAAAAKABgADAAEAAgACgAAAJwAAAAQAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAGQAAAAAAAAAyAAAAAAAAAAsAQAAAAAAAP////8AAAAA", + "format1_hash": "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a" + }, + { + "source": "starfix-python tests/test_metadata_hashing.py", + "test": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAIAAYABwAMAAAAEAAQAAAAAAABFBAAAAAcAAAABAAAAAAAAAAEAAAAbmFtZQAAAAAEAAQABAAAABAAFAAIAAAABwAMAAAAEAAQAAAAAAAAAhAAAAAcAAAABAAAAAAAAAADAAAAYWdlAAgADAAIAAcACAAAAAAAAAEgAAAA/////8gAAAAUAAAAAAAAAAwAFgAGAAUACAAMAAwAAAAAAwQAGAAAADAAAAAAAAAAAAAKABgADAAEAAgACgAAAGwAAAAQAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAABAAAAAAAAABAAAAAAAAAAGAAAAAAAAAAoAAAAAAAAAAUAAAAAAAAAAAAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAABkAAAAeAAAAAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAABQAAAAAAAABBbGljZQAAAP////8AAAAA", + "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + } + ] +} \ No newline at end of file diff --git a/tests/test_format2.py b/tests/test_format2.py index ef5251c..7e1daf1 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -421,10 +421,27 @@ def test_slash_aliasing_nothing_is_accepted() -> None: f2.hash_schema(pa.schema([pa.field("km/h", pa.float64()), pa.field("km", pa.int8())])) -def test_hash_array_root_path_is_claimed() -> None: - arr = pa.StructArray.from_arrays([pa.array([1])], fields=[pa.field("", pa.int64())]) +def test_struct_child_paths_always_use_a_slash() -> None: + """Spec 3.1: a struct child is p + "/" + name, also when p or name is empty.""" + # hash_array root struct child "" is the node "/" (distinct from the root ""). + arr = pa.StructArray.from_arrays([pa.array([1], pa.int64())], fields=[pa.field("", pa.int64(), nullable=False)]) + type_json = b'{"Struct":[{"data_type":"Int64","name":"","nullable":false}]}' + assert f2.hash_array(arr) == V + sha(header(0), type_json, u64(1), sha(struct.pack(" None: + """Entries of a root struct: "" (validity) then "/x" (byte order).""" + s = pa.StructArray.from_arrays([pa.array([1, 2], pa.int8())], fields=[pa.field("x", pa.int8(), nullable=True)], + mask=pa.array([False, True])) + type_json = b'{"Struct":[{"data_type":"Int8","name":"x","nullable":true}]}' + expected = V + sha(header(0), type_json, u64(2), u64(2) + b"\x01", u64(2) + b"\x01", sha(b"\x01")) + assert f2.hash_array(s) == expected # ── Section 5: per-batch schema check ────────────────────────────────── @@ -450,11 +467,23 @@ def test_streaming_check() -> None: # ── Section 8: unsupported data ───────────────────────────────────────── -def test_unsupported_data_raises() -> None: - batch = pa.record_batch([pa.array([None, None], pa.null())], names=["n"]) - f2.hash_schema(batch.schema) - with pytest.raises(NotImplementedError): - f2.hash_record_batch(batch) +@pytest.mark.parametrize( + "t", + [pa.null(), pa.list_(pa.int8(), 2), pa.map_(pa.utf8(), pa.int8()), pa.month_day_nano_interval(), + pa.struct([pa.field("n", pa.null())]), pa.list_(pa.null())], + ids=["null", "fixed_size_list", "map", "interval", "nested_null", "list_of_null"], +) +def test_unsupported_data_rejected_whatever_the_row_count(t) -> None: + """Spec 7 item 3: rejected before any data is hashed, also with zero rows / no batches.""" + schema = pa.schema([pa.field("c", t)]) + f2.hash_schema(schema) # schemas of these types hash + with pytest.raises(ValueError): + f2.Digester(schema) + empty = pa.RecordBatch.from_arrays([pa.array([], t)], schema=schema) + with pytest.raises(ValueError): + f2.hash_record_batch(empty) + with pytest.raises(ValueError): + f2.hash_array(pa.array([], t)) # ── Section 2.3: extension types (E1 pending for pyarrow's C++ built-in types) ── @@ -527,6 +556,19 @@ def test_unregistered_extension_keys_hashed_verbatim() -> None: assert f2.hash_schema(seen, include_metadata=True) == V + sha(header(0), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) +def test_extension_name_without_metadata_key_is_hashed_as_empty_metadata() -> None: + """Spec 2.3: ARROW:extension:name present and :metadata absent -> hashed as "" (E1).""" + name_only = pa.schema([pa.field("q", pa.int32(), metadata={"ARROW:extension:name": "other.thing"})]) + empty = pa.schema([pa.field("q", pa.int32(), metadata={ + "ARROW:extension:name": "other.thing", "ARROW:extension:metadata": ""})]) + phase2 = b'{"fields":{"q":{"ARROW:extension:metadata":"","ARROW:extension:name":"other.thing"}}}' + expected = V + sha(header(0), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) + assert f2.hash_schema(name_only, include_metadata=True) == expected + assert f2.hash_schema(empty, include_metadata=True) == expected + seen, _ = _ipc_roundtrip(name_only) + assert f2.hash_schema(seen, include_metadata=True) == expected + + def test_builtin_uuid_extension_with_canonical_metadata() -> None: """arrow.uuid stored with an empty metadata value: exact (E1 covers other stored forms).""" if not hasattr(pa, "uuid"): From 7fb582838c8a3e6504f84f83b822f3a75088a65b Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:58:31 -0800 Subject: [PATCH 20/49] feat!: hash format 2 is the only format; delete format-1 code (ITL-898) BREAKING CHANGE: every hash changes; the prefix is 00 00 02 (format 2). - src/starfix/arrow_digester.py is a thin ArrowDigester over _format2 (keywords include_metadata, ordered_columns, ordered_struct_fields; no nested_validity); all format-1 code and the _FORMAT_VERSION / _FIX_* switches are deleted - removed format-1-only tests and the unreleased ordered_v0.5.json; test_golden_parity_metadata.py removed (include_metadata_v0.3.json is kept as the historical format-1 record, see tests/golden/README.md) - hand-coded literals moved to their Rust-produced format-2 values from format1_to_format2.json (39); the other 69 await Rust values for the inputs in python_literals_format1_inputs.json - tests/test_golden_parity_format2.py asserts every vector and relation of format2_v0.5.json (only version-gated skips for old pyarrow) - tests/test_api.py: keyword-only options, no third option - CI golden-sync-check diffs format2_v0.5.json and format1_to_format2.json Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 35 +- src/starfix/arrow_digester.py | 1376 +---------- tests/golden/README.md | 8 + tests/golden/ordered_v0.5.json | 3140 -------------------------- tests/test_api.py | 51 + tests/test_arrow_digester.py | 27 +- tests/test_golden_parity.py | 60 +- tests/test_golden_parity_format2.py | 112 + tests/test_golden_parity_metadata.py | 127 -- tests/test_golden_parity_ordered.py | 186 -- tests/test_known_divergences.py | 187 -- tests/test_lossless_fix_scope.py | 122 - tests/test_metadata_hashing.py | 89 +- tests/test_ordered_hashing.py | 839 ------- 14 files changed, 293 insertions(+), 6066 deletions(-) create mode 100644 tests/golden/README.md delete mode 100644 tests/golden/ordered_v0.5.json create mode 100644 tests/test_api.py create mode 100644 tests/test_golden_parity_format2.py delete mode 100644 tests/test_golden_parity_metadata.py delete mode 100644 tests/test_golden_parity_ordered.py delete mode 100644 tests/test_known_divergences.py delete mode 100644 tests/test_lossless_fix_scope.py delete mode 100644 tests/test_ordered_hashing.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f7fefa7..72f1542 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -108,24 +108,27 @@ jobs: exit 1 fi - - name: Fetch authoritative ordered fixture from starfix + - name: Fetch authoritative format-2 fixtures from starfix run: | - # Tolerate a missing file here so the next step prints the explanation. - gh api repos/nauticalab/starfix/contents/tests/golden/ordered_v0.5.json \ - --jq '.content' | base64 -d > /tmp/upstream_ordered.json || true + # Tolerate missing files here so the next step prints the explanation. + for f in format2_v0.5.json format1_to_format2.json; do + gh api "repos/nauticalab/starfix/contents/tests/golden/$f" \ + --jq '.content' | base64 -d > "/tmp/upstream_$f" || true + done env: GH_TOKEN: ${{ steps.app-token.outputs.token }} - - name: Fail on ordered fixture drift + - name: Fail on format-2 fixture drift run: | - if [ ! -s /tmp/upstream_ordered.json ]; then - echo "ERROR: Could not fetch fixture from nauticalab/starfix main." - echo "Ensure nauticalab/starfix#main has tests/golden/ordered_v0.5.json" - echo "(the starfix ITL-898 PR must be merged before this check can pass)" - exit 1 - fi - if ! diff tests/golden/ordered_v0.5.json /tmp/upstream_ordered.json; then - echo "ERROR: tests/golden/ordered_v0.5.json has drifted from nauticalab/starfix main." - echo "Copy the updated fixture from the starfix repo and commit it." - exit 1 - fi + for f in format2_v0.5.json format1_to_format2.json; do + if [ ! -s "/tmp/upstream_$f" ]; then + echo "ERROR: Could not fetch tests/golden/$f from nauticalab/starfix main." + echo "(the starfix ITL-898 PR must be merged before this check can pass)" + exit 1 + fi + if ! diff "tests/golden/$f" "/tmp/upstream_$f" > /dev/null; then + echo "ERROR: tests/golden/$f has drifted from nauticalab/starfix main." + echo "Copy the updated fixture from the starfix repo and commit it." + exit 1 + fi + done diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 01a719f..a33bada 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -1,1046 +1,36 @@ """Pure-Python implementation of the starfix Arrow logical hasher. -Implements the byte-layout specification defined in the starfix Rust crate -(``nauticalab/starfix docs/byte-layout-spec.md``). +Implements hash format 2 of the byte-layout specification defined in the starfix Rust +crate (``nauticalab/starfix docs/byte-layout-spec.md``). Every hash is 35 bytes: the +3-byte format number ``00 00 02`` followed by a SHA-256 digest, and is byte-identical to +the Rust implementation. """ from __future__ import annotations -import hashlib -import json -import struct -from collections import OrderedDict -from typing import TYPE_CHECKING, Protocol +from typing import TYPE_CHECKING -if TYPE_CHECKING: - import pyarrow as pa - - -class _Hasher(Protocol): - """Minimal protocol for a hash accumulator (e.g. ``hashlib.sha256()``).""" - - def update(self, data: bytes | bytearray, /) -> None: ... - - -# Hash format version (developer decision 2026-11-11: bump it). Format 1 is the -# v0.4.0 layout. Format 2 (pending the regenerated Rust spec and golden file) is the -# corrected lossless layout with every default-mode alignment below; switching to it -# is this one line. The version prefix is the 3-byte big-endian format number. -_FORMAT_VERSION = 1 -VERSION_BYTES = _FORMAT_VERSION.to_bytes(3, "big") -DELIMITER = "/" - -_FORMAT_2 = _FORMAT_VERSION >= 2 - -# --------------------------------------------------------------------------- -# Default-mode changes that format 2 brings. Each is a separate switch so that it -# can be tested on its own: True applies the Rust/spec behaviour with no options on -# (it already applies whenever an option is on). tests/test_known_divergences.py -# checks each switch against the Rust values and pins format 1 as strict xfails. -# --------------------------------------------------------------------------- - -# Lossless layout (spec 9.5 / 9.5.1): developer ruling 2026-11-11, the only layout in format 2. -_LOSSLESS_BY_DEFAULT = _FORMAT_2 -# Map schema JSON: entries field (Struct[key, value]) and keys_sorted (spec 2.1). -_FIX_DEFAULT_MAP_JSON = _FORMAT_2 -# hash_array type JSON: non-ASCII written raw, as serde_json does (spec 2.1). -_FIX_DEFAULT_TYPE_JSON_UTF8 = _FORMAT_2 -# Null / Interval / Utf8View / BinaryView schema forms (spec 2.1); format 1 raises. -_FIX_DEFAULT_TYPE_FORMS = _FORMAT_2 -# Phase 2 metadata paths (2.2.1): map entries m/, key m//key, value m//value, and -# dictionaries looked through. -_FIX_DEFAULT_MAP_METADATA_PATHS = _FORMAT_2 -# Streaming: reject a batch whose schema differs from the digester's (spec 9.7). -_FIX_DEFAULT_BATCH_CHECK = _FORMAT_2 - -# Hashing options (spec Section 9.1): keyword name -> bit of the flags byte. -# This table is the single place that names the options; the keyword arguments of -# the public API must use exactly these names. -_OPTION_FLAGS: dict[str, int] = { - "ordered_columns": 0x01, - "ordered_struct_fields": 0x02, - "nested_validity": 0x04, -} - -# Options tag prefix (spec Section 9.2); the flags byte is appended. -_OPTIONS_TAG_PREFIX = b"\x00starfix-options-v1" - -_ORDERED_COLUMNS = _OPTION_FLAGS["ordered_columns"] -_ORDERED_STRUCT_FIELDS = _OPTION_FLAGS["ordered_struct_fields"] -_NESTED_VALIDITY = _OPTION_FLAGS["nested_validity"] - -_SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" - - -def _flags(ordered_columns: bool, ordered_struct_fields: bool, nested_validity: bool) -> int: - """Build the flags byte of spec Section 9.1 from the option values.""" - return ( - (_ORDERED_COLUMNS if ordered_columns else 0) - | (_ORDERED_STRUCT_FIELDS if ordered_struct_fields else 0) - | (_NESTED_VALIDITY if nested_validity else 0) - ) - - -def _reject_nested_validity(nested_validity: bool) -> None: - """Format 2 has no third option: its layout is always lossless (spec format 2, §1).""" - if nested_validity: - raise TypeError("nested_validity is not an option in hash format 2 (its layout is always lossless)") - - -def _lossless(flags: int) -> bool: - """Whether the lossless layout of spec 9.5 / 9.5.1 applies.""" - return _LOSSLESS_BY_DEFAULT or bool(flags & _NESTED_VALIDITY) - - -def _options_tag(flags: int) -> bytes: - """Options tag (spec Section 9.2): 0x00 || "starfix-options-v1" || flags (20 bytes).""" - return _OPTIONS_TAG_PREFIX + bytes([flags]) - - -# --------------------------------------------------------------------------- -# Bit-vector helper (LSB-first packing, matching bitvec) -# --------------------------------------------------------------------------- - -class _BitVec: - """Minimal LSB-first u8 bit vector compatible with Rust bitvec. - - Matches Arrow's native validity bitmap layout. - """ - - __slots__ = ("_bytes", "_len") - - def __init__(self) -> None: - self._bytes = bytearray() - self._len = 0 - - def push(self, bit: bool) -> None: - byte_idx = self._len >> 3 - bit_idx = self._len & 7 # LSB-first: bit 0 is least significant - if byte_idx >= len(self._bytes): - self._bytes.append(0) - if bit: - self._bytes[byte_idx] |= 1 << bit_idx - self._len += 1 - - def extend_true(self, count: int) -> None: - for _ in range(count): - self.push(True) - - def __len__(self) -> int: - return self._len - - def raw_bytes(self) -> bytes: - return bytes(self._bytes) - - -# --------------------------------------------------------------------------- -# Schema / DataType serialization (spec Section 2) -# --------------------------------------------------------------------------- - -def _data_type_to_value(dt: pa.DataType, flags: int = 0) -> object: - """Convert a pyarrow DataType to the JSON-compatible value that matches - the canonical form described in spec Section 2.1. - - Types are normalized: Utf8→LargeUtf8, Binary→LargeBinary, List→LargeList, - Dictionary→value_type. Struct fields are sorted alphabetically, or kept in - declaration order when ``flags`` has ``ordered_struct_fields`` (spec - Section 9.3), at every depth. ``flags == 0`` is the historical form. - """ - import pyarrow as pa - - # Normalize: Dictionary → recurse on value type - if pa.types.is_dictionary(dt): - return _data_type_to_value(dt.value_type, flags) - - if pa.types.is_struct(dt): - fields = [dt.field(i) for i in range(dt.num_fields)] - if not flags & _ORDERED_STRUCT_FIELDS: - # Sort struct fields alphabetically by name - fields.sort(key=lambda f: f.name) - fields_json = [_inner_field_to_value(f, flags) for f in fields] - return {"Struct": fields_json} - if pa.types.is_list(dt) or pa.types.is_large_list(dt): - return {"LargeList": _element_type_to_value(dt.value_field, flags)} - if pa.types.is_fixed_size_list(dt): - return {"FixedSizeList": [_element_type_to_value(dt.value_field, flags), dt.list_size]} - if pa.types.is_map(dt): - if flags or _FIX_DEFAULT_MAP_JSON: - # The entries field (a struct of key and value) and keys_sorted, - # as the Rust implementation serializes DataType::Map(entries, sorted). - return {"Map": [_inner_field_to_value(dt.field(0), flags), dt.keys_sorted]} - # Historical form (flags == 0), kept byte for byte: it omits the value - # type and does not match the Rust form (see tests/test_known_divergences.py). - return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries")), False]} - - # Primitive / leaf types – must match Arrow-Rust serde - return _primitive_data_type_string(dt, flags) - - -# Spec Section 2.1 forms of types that the historical (flags == 0) serializer rejects. -# They are used only when an option is on, so default-mode behaviour is unchanged. -_V05_ONLY_TYPE_FORMS = { - "null": "Null", - "month_interval": {"Interval": "YearMonth"}, - "day_time_interval": {"Interval": "DayTime"}, - "month_day_nano_interval": {"Interval": "MonthDayNano"}, - "string_view": "Utf8View", - "binary_view": "BinaryView", -} - - -def _primitive_data_type_string(dt: pa.DataType, flags: int = 0) -> object: - """Return the serde_json representation that arrow-rs produces (spec Section 2.1).""" - import pyarrow as pa - - _simple = { - pa.bool_(): "Boolean", - pa.int8(): "Int8", - pa.uint8(): "UInt8", - pa.int16(): "Int16", - pa.uint16(): "UInt16", - pa.int32(): "Int32", - pa.uint32(): "UInt32", - pa.int64(): "Int64", - pa.uint64(): "UInt64", - pa.float16(): "Float16", - pa.float32(): "Float32", - pa.float64(): "Float64", - pa.date32(): "Date32", - pa.date64(): "Date64", - pa.utf8(): "LargeUtf8", - pa.large_utf8(): "LargeUtf8", - pa.binary(): "LargeBinary", - pa.large_binary(): "LargeBinary", - } - if dt in _simple: - return _simple[dt] - - if pa.types.is_decimal(dt): - if dt.bit_width == 32: - return {"Decimal32": [dt.precision, dt.scale]} - if dt.bit_width == 64: - return {"Decimal64": [dt.precision, dt.scale]} - if dt.bit_width == 128: - return {"Decimal128": [dt.precision, dt.scale]} - if dt.bit_width == 256: - return {"Decimal256": [dt.precision, dt.scale]} - - if pa.types.is_time32(dt): - unit = "Second" if dt.unit == "s" else "Millisecond" - return {"Time32": unit} - if pa.types.is_time64(dt): - unit = "Microsecond" if dt.unit == "us" else "Nanosecond" - return {"Time64": unit} - - if pa.types.is_timestamp(dt): - unit_map = {"s": "Second", "ms": "Millisecond", "us": "Microsecond", "ns": "Nanosecond"} - unit = unit_map[dt.unit] - if dt.tz is None: - return {"Timestamp": [unit, None]} - return {"Timestamp": [unit, dt.tz]} - - if pa.types.is_duration(dt): - unit_map = {"s": "Second", "ms": "Millisecond", "us": "Microsecond", "ns": "Nanosecond"} - return {"Duration": unit_map[dt.unit]} - - if pa.types.is_fixed_size_binary(dt): - return {"FixedSizeBinary": dt.byte_width} - - if (flags or _FIX_DEFAULT_TYPE_FORMS) and str(dt) in _V05_ONLY_TYPE_FORMS: - return _V05_ONLY_TYPE_FORMS[str(dt)] - - raise NotImplementedError(f"Unsupported data type: {dt}") - - -def _inner_field_to_value(field: pa.Field, flags: int = 0) -> dict: - """Convert a field to JSON with name, data_type, and nullable.""" - return { - "name": field.name, - "data_type": _data_type_to_value(field.type, flags), - "nullable": field.nullable, - } - - -def _element_type_to_value(field: pa.Field, flags: int = 0) -> dict: - """Convert a container element field to JSON with only data_type and nullable (no name). - - Used for list and fixed-size list element types, matching Rust ``element_type_to_value``. - """ - return { - "data_type": _data_type_to_value(field.type, flags), - "nullable": field.nullable, - } - - -def _sort_json_value(value: object) -> object: - """Recursively sort JSON object keys (matching Rust ``sort_json_value``).""" - if isinstance(value, dict): - return OrderedDict(sorted((k, _sort_json_value(v)) for k, v in value.items())) - if isinstance(value, list): - return [_sort_json_value(v) for v in value] - return value - - -def _serialized_schema(schema: pa.Schema) -> str: - fields: dict[str, object] = {} - for i in range(len(schema)): - field = schema.field(i) - value = { - "data_type": _data_type_to_value(field.type), - "nullable": field.nullable, - } - fields[field.name] = _sort_json_value(value) - # Sort by field name (BTreeMap ordering) - sorted_fields = OrderedDict(sorted(fields.items())) - return json.dumps(sorted_fields, separators=(",", ":"), ensure_ascii=False) - - -def _phase1_json(schema: pa.Schema, flags: int) -> str: - """Phase 1 canonical schema JSON for a flags byte (spec Sections 2.1 and 9.3). - - ``flags == 0`` is exactly the default serialization (Section 2.1). - """ - if flags == 0: - return _serialized_schema(schema) - fields = [schema.field(i) for i in range(len(schema))] - if flags & _ORDERED_COLUMNS: - # Top level is an array of struct-child-form objects, in schema order. - doc: object = [_sort_json_value(_inner_field_to_value(f, flags)) for f in fields] - else: - doc = OrderedDict(sorted( - (f.name, _sort_json_value({ - "data_type": _data_type_to_value(f.type, flags), - "nullable": f.nullable, - })) - for f in fields - )) - return json.dumps(doc, separators=(",", ":"), ensure_ascii=False) - - -def _type_json(data_type: pa.DataType, flags: int) -> str: - """``hash_array`` canonical type JSON (spec Sections 6 and 9.4). - - ``flags == 0`` keeps the historical serialization byte for byte. With any - option on, non-ASCII characters are written as raw UTF-8 (as serde_json does). - """ - value = _sort_json_value(_data_type_to_value(data_type, flags)) - if flags == 0 and not _FIX_DEFAULT_TYPE_JSON_UTF8: - return json.dumps(value, separators=(",", ":")) - return json.dumps(value, separators=(",", ":"), ensure_ascii=False) - - -# --------------------------------------------------------------------------- -# Node-path rejection (spec Section 9.6, any option on) -# --------------------------------------------------------------------------- - -def _join(parent: str, name: str) -> str: - return f"{parent}{DELIMITER}{name}" if parent else name - - -def _claim(seen: set[str], path: str) -> None: - if path in seen: - raise ValueError( - f"Ambiguous node path {path!r}: two schema nodes share one path " - "(duplicate names, or a name containing '/' that aliases another node); " - "rejected when any hashing option is on" - ) - seen.add(path) - - -def _walk_node_paths(data_type: pa.DataType, path: str, seen: set[str]) -> None: - import pyarrow as pa - - t = data_type - while pa.types.is_dictionary(t): - t = t.value_type - if pa.types.is_struct(t): - for i in range(t.num_fields): - child = t.field(i) - child_path = _join(path, child.name) - _claim(seen, child_path) - _walk_node_paths(child.type, child_path, seen) - elif pa.types.is_map(t): - # The element of a map is its entries struct (key, value). - element_path = f"{path}{DELIMITER}" - _claim(seen, element_path) - _walk_node_paths(t.field(0).type, element_path, seen) - elif pa.types.is_list(t) or pa.types.is_large_list(t) or pa.types.is_fixed_size_list(t): - element_path = f"{path}{DELIMITER}" - _claim(seen, element_path) - _walk_node_paths(t.value_field.type, element_path, seen) - - -def _check_schema_node_paths(schema: pa.Schema) -> None: - """Raise ``ValueError`` if two nodes of ``schema`` share a node path (spec 9.6).""" - seen: set[str] = set() - for i in range(len(schema)): - field = schema.field(i) - _claim(seen, field.name) - _walk_node_paths(field.type, field.name, seen) - - -def _check_type_node_paths(data_type: pa.DataType) -> None: - """Raise ``ValueError`` if two nodes of an array type share a node path (spec 9.6).""" - seen: set[str] = set() - _claim(seen, "") - _walk_node_paths(data_type, "", seen) - - -# --------------------------------------------------------------------------- -# Metadata helpers (Phase 2 schema hashing — PLT-1734) -# --------------------------------------------------------------------------- - -def _sort_metadata(metadata) -> dict[str, str]: - """Decode PyArrow's bytes-keyed/valued metadata into a sorted str-keyed/valued dict. - - Returns an empty dict when metadata is None or empty. - Arrow IPC spec guarantees metadata keys and values are valid UTF-8. - The str fallback in the key/value decoding is defensive for direct callers. - """ - if not metadata: - return {} - return dict(sorted( - (k.decode("utf-8") if isinstance(k, bytes) else k, - v.decode("utf-8") if isinstance(v, bytes) else v) - for k, v in metadata.items() - )) - - -def _collect_nested_field_metadata( - field, path: str, flags: int = 0 -) -> dict[str, dict[str, str]]: - """Recursively collect metadata from a field and its nested children. - - Returns a dict sorted by path: {path: sorted_metadata_dict}. - Only fields with non-empty metadata are included. - - Path convention (matches the data-hashing BTreeMap paths): - - Struct children: "{parent_path}/{child_name}" - - List/LargeList/FixedSizeList/Map element: "{parent_path}/" (trailing slash, no element name) - - For Map types with ``flags == 0`` (historical form), only the value/item field - is traversed, at "{parent_path}/"; Map key fields are skipped. With any option - on (spec Section 2.2.1), a map's element is its entries field: entries at - "{parent_path}/", key at "{parent_path}//key", value at "{parent_path}//value". - """ - import pyarrow as pa - - result: dict[str, dict[str, str]] = {} - - if field.metadata: - result[path] = _sort_metadata(field.metadata) - - # Spec 2.2.1 paths (options on) are the 9.6 node paths: dictionaries are looked - # through and a map's element is its entries field. Format 1 does neither. - rust_paths = flags or _FIX_DEFAULT_MAP_METADATA_PATHS - t = field.type - while rust_paths and pa.types.is_dictionary(t): - t = t.value_type - - if pa.types.is_struct(t): - for i in range(t.num_fields): - child = t.field(i) - child_path = f"{path}{DELIMITER}{child.name}" - result.update(_collect_nested_field_metadata(child, child_path, flags)) - elif ( - pa.types.is_list(t) - or pa.types.is_large_list(t) - or pa.types.is_fixed_size_list(t) - ): - element_path = f"{path}{DELIMITER}" - result.update(_collect_nested_field_metadata(t.value_field, element_path, flags)) - elif pa.types.is_map(t): - element_path = f"{path}{DELIMITER}" - element = t.field(0) if rust_paths else t.item_field - result.update(_collect_nested_field_metadata(element, element_path, flags)) - - return dict(sorted(result.items())) - - -def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema, flags: int = 0) -> None: - """Feed Phase 2 metadata JSON into ``hasher`` (only when metadata is present). - - Builds a compact JSON string of the form: - {"fields": {"": {"": "", ...}, ...}, "schema": {"": "", ...}} - - ``"fields"`` is omitted when no field (at any nesting level) has metadata. - ``"schema"`` is omitted when the schema has no metadata. - Nothing is written when both would be absent (empty-metadata invariant). - """ - import pyarrow as pa - - # Collect all field metadata recursively. - # _collect_nested_field_metadata returns per-subtree sorted paths, but - # cross-field order depends on schema field order, so we sort globally below. - all_field_meta: dict[str, dict[str, str]] = {} - for i in range(len(schema)): - field = schema.field(i) - all_field_meta.update(_collect_nested_field_metadata(field, field.name, flags)) - - meta_doc: dict[str, object] = {} - if all_field_meta: - meta_doc["fields"] = dict(sorted(all_field_meta.items())) - if schema.metadata: - meta_doc["schema"] = _sort_metadata(schema.metadata) - - if meta_doc: - hasher.update(json.dumps(meta_doc, separators=(",", ":"), ensure_ascii=False).encode()) - - -class _BytesCollector: - """A ``_Hasher`` that records its input (used to compare Phase 2 documents).""" - - def __init__(self) -> None: - self.data = bytearray() - - def update(self, data: bytes | bytearray, /) -> None: - self.data += data - - -def _schema_key(schema: pa.Schema, include_metadata: bool, flags: int) -> tuple[str, bytes]: - """Everything a schema contributes to the schema digest (spec 9.7 check key).""" - phase2 = _BytesCollector() - if include_metadata: - _update_metadata_hash(phase2, schema, flags) - return _phase1_json(schema, flags), bytes(phase2.data) - - -def _hash_schema(schema: pa.Schema, include_metadata: bool = False, flags: int = 0) -> bytes: - h = hashlib.sha256() - if flags: - # Spec Section 9.2: tag, Phase 1 under flags, then Phase 2 unchanged. - h.update(_options_tag(flags)) - h.update(_phase1_json(schema, flags).encode()) - else: - h.update(_serialized_schema(schema).encode()) - if include_metadata: - _update_metadata_hash(h, schema, flags) - return h.digest() - - -# --------------------------------------------------------------------------- -# DigestBufferType (spec Section 3: null_bits, structural, data) -# -# Each entry is a 3-tuple: (BitVec|None, sha256|None, sha256|None) -# [0] null_bits – present when nullable -# [1] structural – present for list entries -# [2] data – present for leaf and list-leaf entries -# --------------------------------------------------------------------------- - -def _new_data_only(nullable: bool) -> tuple: - """Leaf field entry (spec Section 3 — data-only or validity+data).""" - return (_BitVec() if nullable else None, None, hashlib.sha256()) - - -def _new_structural_only(nullable: bool) -> tuple: - """List-level entry whose value is a struct or nested list (spec Section 3).""" - return (_BitVec() if nullable else None, hashlib.sha256(), None) - - -def _new_list_leaf(nullable: bool) -> tuple: - """List-level entry whose value is a leaf type (spec Section 3).""" - return (_BitVec() if nullable else None, hashlib.sha256(), hashlib.sha256()) - - -def _new_validity_only() -> tuple: - """Nullable parent entry — just null_bits, no structural or data (spec Section 3).""" - return (_BitVec(), None, None) - - -# --------------------------------------------------------------------------- -# Type decomposition into BTreeMap entries (spec Sections 3.4, 3.5) -# --------------------------------------------------------------------------- - -def _extract_type_entries( - data_type: pa.DataType, - nullable: bool, - path: str, - out: dict[str, tuple], - nested_validity: bool = False, -) -> None: - """Recursively decompose a data type into BTreeMap entries. - - This implements the recursive decomposition described in spec Section 3: - - Structs are transparent — no entry, recurse into sorted children - - Lists create validity-only + structural/data entries - - Leaves create data entries - - With ``nested_validity`` (spec Section 9.5) a nullable struct gets a - validity-only entry, and a nullable struct or list that is a list element - records its validity in the list's element entry (``reuse``) instead of - replacing it. - """ - import pyarrow as pa - canonical = _normalize_data_type(data_type) - nv = nested_validity - # True only for a nullable list element: the list has just created its - # element entry at `path` (spec Section 9.5). - reuse = nv and nullable and path in out - - if pa.types.is_struct(canonical): - # Struct is transparent — no entry for the struct itself (default). - if nv and nullable and not reuse: - out[path] = _new_validity_only() - # Recurse into children sorted alphabetically (spec Section 3.5). - children = [canonical.field(i) for i in range(canonical.num_fields)] - children.sort(key=lambda f: f.name) - for child in children: - child_path = f"{path}{DELIMITER}{child.name}" if path else child.name - _extract_type_entries(child.type, child.nullable, child_path, out, nv) - - elif pa.types.is_large_list(canonical) or pa.types.is_list(canonical): - # Nullable list: validity-only entry at `path` (spec Section 3.4). - # Default: this REPLACES an existing list-element entry. - if nullable and not reuse: - out[path] = _new_validity_only() - - # List level: entry at path + "/" (spec Section 3.4) - list_path = f"{path}{DELIMITER}" - inner_field = canonical.value_field - inner_canonical = _normalize_data_type(inner_field.type) +from starfix import _format2 - if pa.types.is_struct(inner_canonical): - # List: structural-only at list_path, struct children get own entries - out[list_path] = _new_structural_only(inner_field.nullable) - _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out, nv) - elif pa.types.is_large_list(inner_canonical) or pa.types.is_list(inner_canonical): - # List: structural-only, recurse into inner list - out[list_path] = _new_structural_only(inner_field.nullable) - _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out, nv) - else: - # List: list-leaf entry with both structural + data - out[list_path] = _new_list_leaf(inner_field.nullable) - - else: - # Leaf type: data entry - out[path] = _new_data_only(nullable) - - -def _extract_fields( - field: pa.Field, parent: str, out: dict[str, tuple], nested_validity: bool = False -) -> None: - """Extract BTreeMap entries from a schema field (record-batch path).""" - full_name = f"{parent}{DELIMITER}{field.name}" if parent else field.name - _extract_type_entries(field.type, field.nullable, full_name, out, nested_validity) - - -# --------------------------------------------------------------------------- -# Type normalization (spec Section 2.1 — type canonicalization) -# --------------------------------------------------------------------------- - -def _normalize_data_type(dt: pa.DataType) -> pa.DataType: - """Recursively normalize a DataType to its canonical large equivalent.""" - import pyarrow as pa - - if pa.types.is_dictionary(dt): - return _normalize_data_type(dt.value_type) - if dt == pa.utf8(): - return pa.large_utf8() - if dt == pa.binary(): - return pa.large_binary() - if pa.types.is_list(dt) or pa.types.is_large_list(dt): - inner = _normalize_field(dt.value_field) - return pa.large_list(inner) - if pa.types.is_struct(dt): - fields = [_normalize_field(dt.field(i)) for i in range(dt.num_fields)] - return pa.struct(fields) - if pa.types.is_fixed_size_list(dt): - inner = _normalize_field(dt.value_field) - return pa.list_(inner, dt.list_size) - if pa.types.is_map(dt): - key_field = _normalize_field(dt.key_field) - item_field = _normalize_field(dt.item_field) - return pa.map_(key_field.type, item_field.type, keys_sorted=dt.keys_sorted) - return dt - - -def _normalize_field(field: pa.Field) -> pa.Field: - """Normalize a single field: keep name and nullability, normalize the data type.""" - import pyarrow as pa - return pa.field(field.name, _normalize_data_type(field.type), field.nullable) - - -# --------------------------------------------------------------------------- -# Array normalization helper -# --------------------------------------------------------------------------- - -def _normalize_array(data_type, array): - """Normalize small Arrow variants to their large canonical equivalents. - - Returns (effective_data_type, effective_array). - """ - import pyarrow as pa - - if pa.types.is_string(data_type) and not pa.types.is_large_string(data_type): - return pa.large_utf8(), array.cast(pa.large_utf8()) - if pa.types.is_binary(data_type) and not pa.types.is_large_binary(data_type): - return pa.large_binary(), array.cast(pa.large_binary()) - if pa.types.is_list(data_type) and not pa.types.is_large_list(data_type): - target = pa.large_list(data_type.value_field) - return target, array.cast(target) - if pa.types.is_dictionary(data_type): - effective_type = data_type.value_type - return _normalize_array(effective_type, array.cast(effective_type)) - return data_type, array - - -# --------------------------------------------------------------------------- -# Recursive traversal — populates BTreeMap entries from array data -# (spec Sections 3.1–3.5) -# --------------------------------------------------------------------------- - -def _combine_null_masks(own_valid, ancestor_valid): - """AND-combine two validity lists. Returns None if all valid.""" - if own_valid is None and ancestor_valid is None: - return None - if own_valid is None: - return ancestor_valid - if ancestor_valid is None: - return own_valid - return [a and b for a, b in zip(own_valid, ancestor_valid)] - - -def _get_validity_list(array): - """Return a list of bools (True=valid) or None if no nulls.""" - if array.null_count == 0: - return None - return [array[i].is_valid for i in range(len(array))] - - -def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, fields, nested_validity=False): - """Top-down recursive traversal that routes data to BTreeMap entries. - - Parameters: - data_type: Arrow data type of the array - nullable: whether this position is nullable - array: the Arrow array to hash - path: current BTreeMap key path - ancestor_nulls: list of bools from ancestor struct nulls, or None - fields: the BTreeMap of entries to populate - nested_validity: spec Section 9.5 (nullable structs record their validity) - """ - import pyarrow as pa - - effective_type, effective_array = _normalize_array(data_type, array) - canonical = _normalize_data_type(effective_type) - - if pa.types.is_large_list(canonical): - _traverse_list( - effective_array, canonical.value_field, nullable, path, ancestor_nulls, fields, nested_validity - ) - elif pa.types.is_struct(canonical): - _traverse_struct(effective_array, nullable, path, ancestor_nulls, fields, nested_validity) - else: - _traverse_leaf(effective_type, effective_array, path, ancestor_nulls, fields, nested_validity) - - -def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields, nested_validity=False): - """Traverse a list array, populating validity/structural/data entries (spec Section 3.4).""" - import pyarrow as pa - - # If nullable, record list-level validity at `path` - if nullable: - entry = fields.get(path) - if entry is not None: - null_bits = entry[0] - if null_bits is not None: - own_valid = _get_validity_list(array) - effective = _combine_null_masks(own_valid, ancestor_nulls) - if effective is not None: - for v in effective: - null_bits.push(v) - else: - null_bits.extend_true(len(array)) - - list_path = f"{path}{DELIMITER}" - - # Determine effective null buffer for skipping null list elements - own_valid = _get_validity_list(array) - effective_nulls = _combine_null_masks(own_valid, ancestor_nulls) - - # For each row, write structural info and recurse into non-null elements - offsets = array.offsets - for i in range(len(array)): - is_valid = effective_nulls is None or effective_nulls[i] - if is_valid: - start = offsets[i].as_py() - end = offsets[i + 1].as_py() - sub_array = array.values.slice(start, end - start) - sub_len = len(sub_array) - - # Write list length to structural digest at list_path - entry = fields.get(list_path) - if entry is not None and entry[1] is not None: - entry[1].update(struct.pack(" int | None: - """Return byte width for fixed-size types, or None for variable-length.""" - import pyarrow as pa - - _sizes = { - pa.int8(): 1, pa.uint8(): 1, - pa.int16(): 2, pa.uint16(): 2, pa.float16(): 2, - pa.int32(): 4, pa.uint32(): 4, pa.float32(): 4, pa.date32(): 4, - pa.int64(): 8, pa.uint64(): 8, pa.float64(): 8, pa.date64(): 8, - } - if dt in _sizes: - return _sizes[dt] - if pa.types.is_time32(dt): - return 4 - if pa.types.is_time64(dt): - return 8 - if pa.types.is_timestamp(dt): - return 8 # int64 physical storage; unit/tz are schema metadata - if pa.types.is_duration(dt): - return 8 # int64 physical storage; unit is schema metadata - if pa.types.is_decimal(dt): - return dt.bit_width // 8 - if pa.types.is_fixed_size_binary(dt): - return dt.byte_width - return None - - -def _hash_fixed_size_data(arr, data_digest, element_size: int, effective_nulls) -> None: - """Hash a fixed-width array's data bytes (spec Section 3.1).""" - bufs = arr.buffers() - data_buf = bufs[1] - offset = arr.offset - - raw = data_buf.to_pybytes() - start = offset * element_size - - if effective_nulls is None: - # Non-nullable or all valid: feed entire contiguous buffer - end = start + len(arr) * element_size - data_digest.update(raw[start:end]) - else: - # Nullable: feed only valid elements - has_nulls = any(not v for v in effective_nulls) - if has_nulls: - for i in range(len(arr)): - if effective_nulls[i]: - pos = start + i * element_size - data_digest.update(raw[pos:pos + element_size]) - else: - end = start + len(arr) * element_size - data_digest.update(raw[start:end]) - - -def _hash_boolean_data(arr, data_digest, effective_nulls) -> None: - """Hash boolean array data bits (spec Section 3.2).""" - bv = _BitVec() - if effective_nulls is None: - for i in range(len(arr)): - bv.push(arr[i].as_py()) - else: - for i in range(len(arr)): - if effective_nulls[i]: - bv.push(arr[i].as_py()) - data_digest.update(bv.raw_bytes()) - - -# Elements per chunk when expanding Booleans to one byte each (bounds temporary memory). -_BOOLEAN_CHUNK = 1 << 16 - - -def _hash_boolean_bytes(arr, data_digest, effective_nulls) -> None: - """Hash boolean data as one byte (0x00/0x01) per valid value (spec Section 9.5.1). - - Works in chunks of ``_BOOLEAN_CHUNK`` elements: consecutive digest updates give - the same bytes as one update, without expanding the whole column at once. - """ +if TYPE_CHECKING: import pyarrow as pa - import pyarrow.compute as pc - - for start in range(0, len(arr), _BOOLEAN_CHUNK): - chunk = arr.slice(start, _BOOLEAN_CHUNK) - if effective_nulls is not None: - mask = pa.array(effective_nulls[start:start + len(chunk)], pa.bool_()) - chunk = pc.filter(chunk, mask) - as_u8 = pc.cast(chunk, pa.uint8()) - data_digest.update( - as_u8.buffers()[1].to_pybytes()[as_u8.offset:as_u8.offset + len(as_u8)] - ) - - -def _hash_binary_data(arr, data_digest, effective_nulls) -> None: - """Hash binary array data (spec Section 3.3).""" - if effective_nulls is None: - for i in range(len(arr)): - val = arr[i].as_py() - data_digest.update(struct.pack(" None: - """Hash string array data (spec Section 3.3).""" - if effective_nulls is None: - for i in range(len(arr)): - val = arr[i].as_py().encode("utf-8") - data_digest.update(struct.pack(" None: - """Finalize a single BTreeMap entry into the final combining digest (spec Section 4).""" - null_bits, structural, data = entry - - # 1. null_bits (if present — nullable entries only) - if null_bits is not None: - final_digest.update(struct.pack(" None: - """Initialize a streaming Arrow hasher. + """Start a streaming hash of record batches with this schema. Args: - schema: The Arrow schema all record batches must conform to. - include_metadata: When True, schema-level and per-field Arrow - metadata are included in the hash. Default is False, - preserving hash format 0.0.1 stability. A schema with no - metadata produces the same hash regardless of this flag - (empty-metadata invariant). - ordered_columns: When True, the order of the top-level columns is - part of the hash (spec Section 9.3). - ordered_struct_fields: When True, the order of struct fields, at - every nesting depth, is part of the hash (spec Section 9.3). - nested_validity: When True, every nullable struct, and every - nullable list or struct that is a list element, records its - own validity bits (spec Section 9.5). + schema: The Arrow schema every record batch must have. + include_metadata: Hash schema- and field-level metadata. + ordered_columns: Make the order of the top-level columns part of the hash. + ordered_struct_fields: Make the order of struct fields, at every depth, + part of the hash. - With any of these three options on, the hash never equals the hash - taken with a different set of options (in particular with all of them - off), and schemas in which two nodes share a path (duplicate names, or - a name containing ``/`` that aliases another node) are rejected with - ``ValueError`` (spec Section 9.6). - - With any option on, every batch passed to :meth:`update` must have the - same canonical schema as ``schema`` under those options, otherwise - ``ValueError`` is raised (spec Section 9.7). For example, with - ``ordered_columns`` a batch with the columns in a different order is - rejected. - - Raises: - ValueError: With any option on, if ``schema`` is rejected (spec 9.6). + Hashes taken with different order options never coincide. """ - if _FORMAT_2: - _reject_nested_validity(nested_validity) - from starfix import _format2 - - self._format2 = _format2.Digester( - schema, - include_metadata=include_metadata, - ordered_columns=ordered_columns, - ordered_struct_fields=ordered_struct_fields, - ) - return - self._format2 = None - flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) - if flags: - _check_schema_node_paths(schema) - self._schema = schema - self._include_metadata = include_metadata # captured in _schema_digest; reused by update() - self._flags = flags - self._schema_digest = _hash_schema(schema, include_metadata=include_metadata, flags=flags) - # Spec Section 9.7: with any option on, every batch must match this key. - self._schema_key = ( - _schema_key(schema, include_metadata, flags) if flags or _FIX_DEFAULT_BATCH_CHECK else None + self._digester = _format2.Digester( + schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, ) - # BTreeMap — sorted by key - self._fields: dict[str, tuple] = {} - nv = _lossless(flags) - for i in range(len(schema)): - _extract_fields(schema.field(i), "", self._fields, nv) - # Ensure sorted order (Python 3.7+ dicts are insertion-ordered) - self._fields = dict(sorted(self._fields.items())) def update(self, record_batch: pa.RecordBatch) -> None: - """Feed a RecordBatch into the running digest (spec Sections 3–5). - - Raises: - ValueError: With any option on, if the batch's schema is rejected - (spec 9.6) or does not match the digester's schema under its - options (spec 9.7). - """ - if self._format2 is not None: - self._format2.update(record_batch) - return - schema = record_batch.schema - if self._flags: - _check_schema_node_paths(schema) - if self._schema_key is not None: - if _schema_key(schema, self._include_metadata, self._flags) != self._schema_key: - raise ValueError(_SCHEMA_MISMATCH) - nv = _lossless(self._flags) - # Traverse each top-level field using the recursive traversal - for i in range(len(schema)): - field = schema.field(i) - col = record_batch.column(i) - _traverse_and_update( - field.type, - field.nullable, - col, - field.name, - None, # no ancestor struct nulls at top level - self._fields, - nv, - ) + """Add a record batch. Splitting rows into batches does not change the hash.""" + self._digester.update(record_batch) def finalize(self) -> bytes: - """Consume the digester and return the versioned hash (spec Section 5).""" - if self._format2 is not None: - return self._format2.finalize() - final_digest = hashlib.sha256() - final_digest.update(self._schema_digest) - for _path, entry in sorted(self._fields.items()): - _finalize_digest(final_digest, entry) - return VERSION_BYTES + final_digest.digest() - - # -- Convenience class methods ------------------------------------------ + """Return the 35-byte hash of everything added so far.""" + return self._digester.finalize() @staticmethod def hash_schema( @@ -1166,50 +74,14 @@ def hash_schema( include_metadata: bool = False, ordered_columns: bool = False, ordered_struct_fields: bool = False, - nested_validity: bool = False, ) -> bytes: - """Hash an Arrow schema. - - Args: - schema: The schema to hash. - include_metadata: When True, schema-level and per-field Arrow - metadata are included in the hash. Default is False, - preserving hash format 0.0.1 stability. A schema with no - metadata produces the same hash regardless of this flag - (empty-metadata invariant). - ordered_columns: When True, the order of the top-level columns is - part of the hash (spec Section 9.3). - ordered_struct_fields: When True, the order of struct fields, at - every nesting depth, is part of the hash (spec Section 9.3). - nested_validity: When True, every nullable struct, and every - nullable list or struct that is a list element, records its - own validity bits (spec Section 9.5). - - With any of these three options on, the hash never equals the hash - taken with a different set of options (in particular with all of them - off), and schemas in which two nodes share a path (duplicate names, or - a name containing ``/`` that aliases another node) are rejected with - ``ValueError`` (spec Section 9.6). - ``nested_validity`` does not change the schema JSON, but like every - option it is part of the hash. - - Raises: - ValueError: With any option on, if ``schema`` is rejected (spec 9.6). - """ - if _FORMAT_2: - _reject_nested_validity(nested_validity) - from starfix import _format2 - - return _format2.hash_schema( - schema, - include_metadata=include_metadata, - ordered_columns=ordered_columns, - ordered_struct_fields=ordered_struct_fields, - ) - flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) - if flags: - _check_schema_node_paths(schema) - return VERSION_BYTES + _hash_schema(schema, include_metadata=include_metadata, flags=flags) + """Hash an Arrow schema.""" + return _format2.hash_schema( + schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + ) @staticmethod def hash_record_batch( @@ -1218,42 +90,14 @@ def hash_record_batch( include_metadata: bool = False, ordered_columns: bool = False, ordered_struct_fields: bool = False, - nested_validity: bool = False, ) -> bytes: - """Hash an Arrow record batch. - - Args: - record_batch: The record batch to hash. - include_metadata: When True, schema-level and per-field Arrow - metadata are included in the hash. Default is False, - preserving hash format 0.0.1 stability. A schema with no - metadata produces the same hash regardless of this flag - (empty-metadata invariant). - ordered_columns: When True, the order of the top-level columns is - part of the hash (spec Section 9.3). - ordered_struct_fields: When True, the order of struct fields, at - every nesting depth, is part of the hash (spec Section 9.3). - nested_validity: When True, every nullable struct, and every - nullable list or struct that is a list element, records its - own validity bits (spec Section 9.5). - - With any of these three options on, the hash never equals the hash - taken with a different set of options (in particular with all of them - off), and schemas in which two nodes share a path (duplicate names, or - a name containing ``/`` that aliases another node) are rejected with - ``ValueError`` (spec Section 9.6). - Raises: - ValueError: With any option on, if the schema is rejected (spec 9.6). - """ - d = ArrowDigester( - record_batch.schema, + """Hash one record batch (equal to streaming it through a digester).""" + return _format2.hash_record_batch( + record_batch, include_metadata=include_metadata, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields, - nested_validity=nested_validity, ) - d.update(record_batch) - return d.finalize() @staticmethod def hash_table( @@ -1262,46 +106,14 @@ def hash_table( include_metadata: bool = False, ordered_columns: bool = False, ordered_struct_fields: bool = False, - nested_validity: bool = False, ) -> bytes: - """Hash a full Arrow table (iterates over all batches). - - Equivalent to ``ArrowDigester(table.schema, ...)``, :meth:`update` for each - batch of ``table.to_batches()``, then :meth:`finalize`. - - Args: - table: The table to hash. - include_metadata: When True, schema-level and per-field Arrow - metadata are included in the hash. Default is False, - preserving hash format 0.0.1 stability. A schema with no - metadata produces the same hash regardless of this flag - (empty-metadata invariant). - ordered_columns: When True, the order of the top-level columns is - part of the hash (spec Section 9.3). - ordered_struct_fields: When True, the order of struct fields, at - every nesting depth, is part of the hash (spec Section 9.3). - nested_validity: When True, every nullable struct, and every - nullable list or struct that is a list element, records its - own validity bits (spec Section 9.5). - - With any of these three options on, the hash never equals the hash - taken with a different set of options (in particular with all of them - off), and schemas in which two nodes share a path (duplicate names, or - a name containing ``/`` that aliases another node) are rejected with - ``ValueError`` (spec Section 9.6). - Raises: - ValueError: With any option on, if the schema is rejected (spec 9.6). - """ - d = ArrowDigester( - table.schema, + """Hash a table: a digester over ``table.to_batches()``.""" + return _format2.hash_table( + table, include_metadata=include_metadata, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields, - nested_validity=nested_validity, ) - for batch in table.to_batches(): - d.update(batch) - return d.finalize() @staticmethod def hash_array( @@ -1309,93 +121,11 @@ def hash_array( *, ordered_columns: bool = False, ordered_struct_fields: bool = False, - nested_validity: bool = False, ) -> bytes: - """Hash a single array (spec Section 6). - - Uses the same recursive BTreeMap decomposition as the record-batch path. + """Hash a single array (no schema; ``include_metadata`` does not apply). - Args: - array: The array to hash. - ordered_columns: When True, the order of the top-level columns is - part of the hash (spec Section 9.3). - ordered_struct_fields: When True, the order of struct fields, at - every nesting depth, is part of the hash (spec Section 9.3). - nested_validity: When True, every nullable struct, and every - nullable list or struct that is a list element, records its - own validity bits (spec Section 9.5). - - With any of these three options on, the hash never equals the hash - taken with a different set of options (in particular with all of them - off), and schemas in which two nodes share a path (duplicate names, or - a name containing ``/`` that aliases another node) are rejected with - ``ValueError`` (spec Section 9.6). - ``ordered_columns`` does not change the type JSON of an array, but like - every option it is part of the hash (spec Section 9.4). - - Raises: - ValueError: With any option on, if the array's type is rejected - (spec 9.6). - - Note: - ``include_metadata`` is intentionally absent here — standalone arrays - carry no schema or field metadata. This matches the Rust ``starfix`` API. + ``ordered_columns`` changes only the header of an array's hash. """ - import pyarrow as pa - - if _FORMAT_2: - _reject_nested_validity(nested_validity) - from starfix import _format2 - - return _format2.hash_array( - array, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields - ) - flags = _flags(ordered_columns, ordered_struct_fields, nested_validity) - nv = _lossless(flags) - - # Resolve dictionary arrays to their plain value type - effective_type = array.type - effective_array = array - if pa.types.is_dictionary(effective_type): - effective_type = effective_type.value_type - effective_array = array.cast(effective_type) - - if flags: - _check_type_node_paths(effective_type) - - # Normalize to canonical large types - normalized_type = _normalize_data_type(effective_type) - - final_digest = hashlib.sha256() - if flags: - # Spec Section 9.2: the options tag is the first input. - final_digest.update(_options_tag(flags)) - - # Step 1: Type metadata (canonical JSON string) - final_digest.update(_type_json(normalized_type, flags).encode()) - - # Determine nullability: arrays with null_count > 0 are nullable - nullable = effective_array.null_count > 0 - - # Step 2: Build BTreeMap entries from the type tree (same as record-batch) - fields: dict[str, tuple] = {} - _extract_type_entries(effective_type, nullable, "", fields, nv) - fields = dict(sorted(fields.items())) - - # Step 3: Traverse and populate entries - _traverse_and_update( - effective_type, - nullable, - effective_array, - "", - None, - fields, - nv, + return _format2.hash_array( + array, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields ) - - # Step 4: Finalize all entries into the digest - for _path, entry in sorted(fields.items()): - _finalize_digest(final_digest, entry) - - return VERSION_BYTES + final_digest.digest() - diff --git a/tests/golden/README.md b/tests/golden/README.md new file mode 100644 index 0000000..3fe47f0 --- /dev/null +++ b/tests/golden/README.md @@ -0,0 +1,8 @@ +# Golden files + +| File | Status | +|---|---| +| `format2_v0.5.json` | Hash format 2. Generated by Rust (`cargo run --bin emit_golden_format2` in nauticalab/starfix) and copied here byte for byte. Every vector and relation is asserted by `tests/test_golden_parity_format2.py`. Never edit. | +| `format1_to_format2.json` | Every format-1 golden or pinned value of the Rust repository with its format-2 value (Rust-generated, copied byte for byte). Used to move this repository's hand-coded test literals to format 2. | +| `python_literals_format1_inputs.json` | Inputs of this repository's hand-coded format-1 test literals that `format1_to_format2.json` did not cover, recovered from the calls that produced them, so that Rust could supply their format-2 values. | +| `include_metadata_v0.3.json` | Historical format-1 record (starfix ≤ 0.4). Kept unchanged; no longer asserted. | diff --git a/tests/golden/ordered_v0.5.json b/tests/golden/ordered_v0.5.json deleted file mode 100644 index 775c925..0000000 --- a/tests/golden/ordered_v0.5.json +++ /dev/null @@ -1,3140 +0,0 @@ -{ - "version": "0.5", - "generated_by": "cargo run --bin emit_golden_ordered", - "rust_commit": "e5b49c45351194943498a2ef488a388be71a1c1e", - "vectors": [ - { - "id": "cols_ab_rb_f0", - "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d" - }, - { - "id": "cols_ba_rb_f0", - "description": "Same data, columns b,a", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d" - }, - { - "id": "cols_ab_schema_f0", - "description": "Schema [a, b]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9" - }, - { - "id": "cols_ba_schema_f0", - "description": "Schema [b, a]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9" - }, - { - "id": "cols_ab_rb_f1", - "description": "Record batch [a: Int32, b: LargeUtf8?], columns a,b", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000121b54ec5ca8e122a2196ee4432edd4e2a2819d2c72b9ae19868874ee1a4d4595" - }, - { - "id": "cols_ba_rb_f1", - "description": "Same data, columns b,a", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000197d403796b51f4aecb389b95428a3a628c0eec3f87f3e7e98c3ad2f028c88dac" - }, - { - "id": "cols_ab_schema_f1", - "description": "Schema [a, b]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001433f79fbd0ee506ee7dc7fcb53dcb20a5513d301283e81e48a9c4eddf2657edb" - }, - { - "id": "cols_ba_schema_f1", - "description": "Schema [b, a]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001927f7ad3301ffa6420efb0e7fbd1928d98454a92d55888e53e3b37f3ff6c7b4a" - }, - { - "id": "cols_ba_stream_f1", - "description": "Stream of the cols_ba data split into two batches, ordered_columns", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000197d403796b51f4aecb389b95428a3a628c0eec3f87f3e7e98c3ad2f028c88dac" - }, - { - "id": "combo_ns_xy_f0", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" - }, - { - "id": "combo_sn_xy_f0", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" - }, - { - "id": "combo_ns_yx_f0", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" - }, - { - "id": "combo_sn_yx_f0", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd" - }, - { - "id": "combo_ns_xy_f1", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a12d9d439905c16338fec9ab33c757d3c9c11ed4ed14e8d618a699fbf170e40d" - }, - { - "id": "combo_sn_xy_f1", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000016d9c52cf9a055df5764d2b52e57929f650d6ac8b92206eb7f67adb9b679cfd41" - }, - { - "id": "combo_ns_yx_f1", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a12d9d439905c16338fec9ab33c757d3c9c11ed4ed14e8d618a699fbf170e40d" - }, - { - "id": "combo_sn_yx_f1", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000016d9c52cf9a055df5764d2b52e57929f650d6ac8b92206eb7f67adb9b679cfd41" - }, - { - "id": "combo_ns_xy_f2", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001f3338aeec6740e360c7919ed1527d3a180d721611dbe2573fdfdafb01c250b93" - }, - { - "id": "combo_sn_xy_f2", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001f3338aeec6740e360c7919ed1527d3a180d721611dbe2573fdfdafb01c250b93" - }, - { - "id": "combo_ns_yx_f2", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001ce00ff6234af4635713dbc8ef6ed4acc6f751e2153fca3fd292e9d7bf20a6a28" - }, - { - "id": "combo_sn_yx_f2", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001ce00ff6234af4635713dbc8ef6ed4acc6f751e2153fca3fd292e9d7bf20a6a28" - }, - { - "id": "combo_ns_xy_f3", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000157528aa46dc70002df3ac22328918d1128fdad6b3fb0f428b944214ff283ec1f" - }, - { - "id": "combo_sn_xy_f3", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001bbbb6e0038be6938efa52f5b1cd8107f54d7db033790b27d5f9068b852efec9f" - }, - { - "id": "combo_ns_yx_f3", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000018ad68d9e117c5551e8bddf182148c7f4873d14ea322df73dfe52ea6ef8be26da" - }, - { - "id": "combo_sn_yx_f3", - "description": "Columns n: Int32 and s: Struct; ns/sn = column order, xy/yx = struct field order", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000018484372d6f9b79b7e2dd09a4574784f5d16d8cd32c8e9f5d806d7961ba15e0f6" - }, - { - "id": "nested_struct_ab_schema_f0", - "description": "s: Struct>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad" - }, - { - "id": "nested_struct_ba_schema_f0", - "description": "s: Struct> (only the inner level permuted)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad" - }, - { - "id": "list_struct_ab_rb_f0", - "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" - }, - { - "id": "list_struct_ba_rb_f0", - "description": "Same, struct fields declared b, a", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" - }, - { - "id": "large_list_struct_ab_rb_f0", - "description": "Same as list_struct_ab with LargeList", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb" - }, - { - "id": "fsl_struct_ab_schema_f0", - "description": "f: FixedSizeList, 2> (schema only: data unsupported)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5" - }, - { - "id": "fsl_struct_ba_schema_f0", - "description": "f: FixedSizeList, 2>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5" - }, - { - "id": "map_struct_ab_schema_f0", - "description": "m: Map> (schema only)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c" - }, - { - "id": "map_struct_ba_schema_f0", - "description": "m: Map>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c" - }, - { - "id": "nested_struct_ab_schema_f2", - "description": "s: Struct>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000103feec3edfc6ad67372f2a0b039b31e3c5e09dc89c38f1a333d0c235c20daff0" - }, - { - "id": "nested_struct_ba_schema_f2", - "description": "s: Struct> (only the inner level permuted)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000011db23e275141dbafc6885145528be2d78b2896fe00d8c05d97e6cb7433092169" - }, - { - "id": "list_struct_ab_rb_f2", - "description": "l: List?>? rows [[{1,'x'},{2,null}], null, []]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000174b0ee3721df257940875351a9d9a639b5422637c6e83725d0f346ae5cc38a37" - }, - { - "id": "list_struct_ba_rb_f2", - "description": "Same, struct fields declared b, a", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001098bdb016a9ef1086c264d7d6dc16e42d30b82cb6b44a194545f2262dee91101" - }, - { - "id": "large_list_struct_ab_rb_f2", - "description": "Same as list_struct_ab with LargeList", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000174b0ee3721df257940875351a9d9a639b5422637c6e83725d0f346ae5cc38a37" - }, - { - "id": "fsl_struct_ab_schema_f2", - "description": "f: FixedSizeList, 2> (schema only: data unsupported)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000175deb7bc7a57e6937b78f9feaf9110e93842cf762f743c2221497657a944da77" - }, - { - "id": "fsl_struct_ba_schema_f2", - "description": "f: FixedSizeList, 2>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000154a53df59f8a47829c7b277d9e95b47320608fdf6c1ed9e9712dfb996484538e" - }, - { - "id": "map_struct_ab_schema_f2", - "description": "m: Map> (schema only)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001d700e3cc5935b5cb72702e39727308f5bd6d3419dff84d400a8c189b2d469cd2" - }, - { - "id": "map_struct_ba_schema_f2", - "description": "m: Map>", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001436d0e9de48650db71fbb3af6c2ef02e1269edf8a93a8e5c8f63814fdccb4b6a" - }, - { - "id": "one_col_rb_f0", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857" - }, - { - "id": "one_col_schema_f0", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000001b7f25ba092def78ecd57c231765bac9d23a37ef04734462c1f50ec5880e7f204" - }, - { - "id": "one_col_array_f0", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c" - }, - { - "id": "one_col_rb_f1", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001b78fcdc09baafc38945854618d7f457e01535e7c72f8e959c0073acb8b99da8b" - }, - { - "id": "one_col_schema_f1", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000001962aa3a655a41ac8a79532f949b5af68637de2b08d0ef7a787d0c19e5b804fe1" - }, - { - "id": "one_col_array_f1", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000013f93038c45e900987f5428c0615210a40e9c9a64a7dff45a397ac163ece0c383" - }, - { - "id": "one_col_rb_f2", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001f4c62f99ec684a654040f08a293c249f7d7ed930242c15bbdb9883575cdff57e" - }, - { - "id": "one_col_schema_f2", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "00000171533ac6eefe6e41b09c75961a5b9700d6c9d68f48ac427496a80c9e28aa1a0a" - }, - { - "id": "one_col_array_f2", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001c3423f6ea4cd018fc045934f847cfa79c30a2201390d75cdfacbf84302493fe4" - }, - { - "id": "one_col_rb_f3", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000013362f852129e33e3204b15ac3ddc8dd57bdc8771c4396a9946d2c911628e5f65" - }, - { - "id": "one_col_schema_f3", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000001e1e6d344de70bc1eb034163991fc1fc57787adb5af12ce57c00bead160cf53ba" - }, - { - "id": "one_col_array_f3", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000011470123be74fd71dc50ade81d0226a3e68a6337b057c2b85f9468bf90dd0da59" - }, - { - "id": "one_col_rb_f4", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000017b8433e7bd2c431a74138d9935ee6d619c001af4f2e4e128c35c60dbdb53c70b" - }, - { - "id": "one_col_schema_f4", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "0000017022b81e60e4a1dba9ec4602a4976a0dea50f490c916d0ce01e697ebcf9069ee" - }, - { - "id": "one_col_array_f4", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000019e3adff54fa94dec7e5d72a37b3d7b1f8153afedd28032b59997d2ba47c51db0" - }, - { - "id": "one_col_rb_f5", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001c38897ca9f720d18fb37eba87e4b28765a1e664b92764a914590130131816bd2" - }, - { - "id": "one_col_schema_f5", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000001d90f32c33eaaa8b3c3c51f2cf33ff920ca09015eeb50d98727a556765a83bd3e" - }, - { - "id": "one_col_array_f5", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000016add16fe46328698a1f252768018a01aa8eab9eacef5adaf602c67fa4196f869" - }, - { - "id": "one_col_rb_f6", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001dbbf891eed1bf9ef6a93202984a39deb5c993b7481cd734eba54878bce23e6f1" - }, - { - "id": "one_col_schema_f6", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "0000018996061e12067c82279f8c5f08d3defe8ad2f9509c6701416a7b75055dcf0d95" - }, - { - "id": "one_col_array_f6", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001973166b6e70cba833de35adaed48af4416d986c5b411196e4b5a1951259119c7" - }, - { - "id": "one_col_rb_f7", - "description": "One column v: Int32 [1, 2, 3]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000165a886e87aaa8efd06668bc6bb3f154d0aad098cc2f301eaf45150d1bacb15ca" - }, - { - "id": "one_col_schema_f7", - "description": "Schema [v: Int32]", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "0000010da7daf6e5c269dcc172b9756942366d3ed59d809ed79f0a8c961c21a64ba581" - }, - { - "id": "one_col_array_f7", - "description": "hash_array of Int32 [1, 2, 3]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000016135b88789127c04f395b05ffd47ceac8ed34829f9bb952ad5e5f4e17c881394" - }, - { - "id": "plain_schema_f1_im0", - "description": "Schema [b, a] without metadata, include_metadata=false", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001f671b75064ce3c0dcc6722dec4c8b7dfae3f5aecd931ae45073f449a59f0abe6" - }, - { - "id": "plain_schema_f1_im1", - "description": "Same, include_metadata=true", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001f671b75064ce3c0dcc6722dec4c8b7dfae3f5aecd931ae45073f449a59f0abe6" - }, - { - "id": "meta_schema_f1_im1", - "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001155c895b58a677b6e8b553e5c934ade77df1a089f400e8dc82a11617e12fa746" - }, - { - "id": "plain_schema_f7_im0", - "description": "Schema [b, a] without metadata, include_metadata=false", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000012e5ca80a107600a263f4ae5362e7be8f5531dc190fb745134eeb99b5dd29cf42" - }, - { - "id": "plain_schema_f7_im1", - "description": "Same, include_metadata=true", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000012e5ca80a107600a263f4ae5362e7be8f5531dc190fb745134eeb99b5dd29cf42" - }, - { - "id": "meta_schema_f7_im1", - "description": "Schema [b{unit:kg}, a] + schema metadata {source:golden}, include_metadata=true", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000015a690f2487025a0de8162d8c5eaa4a7684991819b210b7726f83f3249a34b22f" - }, - { - "id": "ext_struct_xy_rb_f0_im1", - "description": "Extension type (metadata) over Struct storage, include_metadata=true", - "method": "hash_record_batch", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb" - }, - { - "id": "ext_struct_yx_rb_f0_im1", - "description": "Extension type over Struct storage, include_metadata=true", - "method": "hash_record_batch", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb" - }, - { - "id": "ext_struct_xy_rb_f2_im1", - "description": "Extension type (metadata) over Struct storage, include_metadata=true", - "method": "hash_record_batch", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001d2a7a89d0cd08c78e9a16fff1d4e7db5600bd3b9e9407c6ab3c245b150650455" - }, - { - "id": "ext_struct_yx_rb_f2_im1", - "description": "Extension type over Struct storage, include_metadata=true", - "method": "hash_record_batch", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000015a7cc4edc5954bcd08d7d331dfe81ca1b319196b62d362e04ce595ca84cbf376" - }, - { - "id": "empty_stream_f1", - "description": "Schema [b, a], zero batches, ordered_columns", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001a0334ecb0161cff7c3008d42ca53d6753aaba6e75e948a1ae7ef6771bbd05bff" - }, - { - "id": "zero_row_rb_f1", - "description": "Schema [b, a], one batch with zero rows, ordered_columns", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAADAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001a0334ecb0161cff7c3008d42ca53d6753aaba6e75e948a1ae7ef6771bbd05bff" - }, - { - "id": "zero_cols_0rows_rb_f0", - "description": "Zero columns, 0 rows", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6" - }, - { - "id": "zero_cols_3rows_rb_f0", - "description": "Zero columns, 3 rows (row count of a zero-column table is not hashed)", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6" - }, - { - "id": "zero_cols_0rows_rb_f1", - "description": "Zero columns, 0 rows", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000102cd9a406580a25178a7838fba0e6266f84a8508d93696c2eca2467bbd58c22d" - }, - { - "id": "zero_cols_3rows_rb_f1", - "description": "Zero columns, 3 rows (row count of a zero-column table is not hashed)", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000102cd9a406580a25178a7838fba0e6266f84a8508d93696c2eca2467bbd58c22d" - }, - { - "id": "leaf_nulls_rb_f3", - "description": "Nullable leaves with nulls and an all-null Int32 column, flags 3", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAABwAAAANAAAAAQAAACs////EAAAABgAAAAAAAECFAAAAJz///8gAAAAAAAAAQAAAAABAAAAegAAANj///8YAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGEAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAACAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001b4426782caaad59a74937bf850a86141caf138caa1badeaa2420520edb390f24" - }, - { - "id": "nv_null_struct_rb_f0", - "description": "s: Struct? rows [{a:1}, null]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9" - }, - { - "id": "nv_null_fields_rb_f0", - "description": "s: Struct? rows [{a:1}, {a:null}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9" - }, - { - "id": "nv_rows3_rb_f0", - "description": "s: Struct? rows [{a:1}, null, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a" - }, - { - "id": "nv_rows2_rb_f0", - "description": "s: Struct? rows [{a:1}, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a" - }, - { - "id": "nv_list_list_1row_rb_f0", - "description": "c: List?> one row [[1], [2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006" - }, - { - "id": "nv_list_list_2rows_rb_f0", - "description": "c: List?> two rows [[1]], [[2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006" - }, - { - "id": "nv_list_null_elem_rb_f0", - "description": "l: List?> one row [null, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6" - }, - { - "id": "nv_list_null_fields_elem_rb_f0", - "description": "l: List?> one row [{a:null}, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6" - }, - { - "id": "nv_null_struct_rb_f4", - "description": "s: Struct? rows [{a:1}, null]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001bac1fd3395c1558237b83d1058ddfe0ed147777235b268f915d0db961d5d5a92" - }, - { - "id": "nv_null_fields_rb_f4", - "description": "s: Struct? rows [{a:1}, {a:null}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000013c71bf0f16c580e51fecfe6a319bcabf8726c971c7dae68aadabfae3a2d463ba" - }, - { - "id": "nv_rows3_rb_f4", - "description": "s: Struct? rows [{a:1}, null, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ca0b11291a17b3a74df4d3e07e598df6254f18bea48d6de658bad6ce0764ed2c" - }, - { - "id": "nv_rows2_rb_f4", - "description": "s: Struct? rows [{a:1}, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000014938f09116f0bd0ba424d14c2147fba37f50156ea6a8a16ad6491e7a19fd7b4e" - }, - { - "id": "nv_list_list_1row_rb_f4", - "description": "c: List?> one row [[1], [2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a12b9454ccc5aba3531a3402e2b245afa5c13aeb7e34760893614025460c3510" - }, - { - "id": "nv_list_list_2rows_rb_f4", - "description": "c: List?> two rows [[1]], [[2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001024d511e3ecf756438dae91a23fc5129a7f075aa30be86f6605370b076567c95" - }, - { - "id": "nv_list_null_elem_rb_f4", - "description": "l: List?> one row [null, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000014be0fee254d85051c22a6be84af446096947a5a04b993571fdbb6ff1967f3113" - }, - { - "id": "nv_list_null_fields_elem_rb_f4", - "description": "l: List?> one row [{a:null}, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000110b24fe51f19bcd11887cc0b00514da0939a1f4e6465852f5b67c2ba5ee8d4fe" - }, - { - "id": "nv_null_struct_rb_f7", - "description": "s: Struct? rows [{a:1}, null]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000178a32a80015616d24eec5c25eca12bbea6685c04bde437c1f1575dfa1afafda3" - }, - { - "id": "nv_null_fields_rb_f7", - "description": "s: Struct? rows [{a:1}, {a:null}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001196f0d60192e3fd1b9cab06112c76238fdb91f17e489099e71551c29faeef270" - }, - { - "id": "nv_rows3_rb_f7", - "description": "s: Struct? rows [{a:1}, null, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000198afb787b75ff51607154462604f6c5a87c59c8b3d559d40ea3633f750cb2794" - }, - { - "id": "nv_rows2_rb_f7", - "description": "s: Struct? rows [{a:1}, {a:3}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001323fc9c3c1bcd52c819613c152c5f57af4249574a11a1cec936827576f3e507a" - }, - { - "id": "nv_list_list_1row_rb_f7", - "description": "c: List?> one row [[1], [2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000018c0df99d4e6f5a1e71c6dfcbe32a9812cd8c2027ec6d83d699e52aeff7c6b0bb" - }, - { - "id": "nv_list_list_2rows_rb_f7", - "description": "c: List?> two rows [[1]], [[2]]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001fbafc458f570526d42a9a81f3ecd8e5e15ca485efab0e1a96a4d84c3c2e2d1c7" - }, - { - "id": "nv_list_null_elem_rb_f7", - "description": "l: List?> one row [null, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000183c17f4fc47ee0bae5018422ed0d792ceeb5d1d8bedec85cc476996b96056a00" - }, - { - "id": "nv_list_null_fields_elem_rb_f7", - "description": "l: List?> one row [{a:null}, {a:4}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001002591d3d2c26cc8b54288f76f17955ee1563be257ed6ff1671e6511c0481641" - }, - { - "id": "nv_nested_structs_rb_f4", - "description": "o: Struct?>? with nulls at both levels", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000142749678d54b57f5edea35b4cdf05ee82198181e33812ce1b9dea23f3b0b5c71" - }, - { - "id": "nv_nested_structs_rb_f7", - "description": "o: Struct?>? with nulls at both levels", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000137e9864f3f6ecc066f6e970390de95773bf728c664df3ce23b9f5093e038b2a8" - }, - { - "id": "nv_rows3_stream_f4", - "description": "nv_rows3 data split into two batches, nested_validity", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ca0b11291a17b3a74df4d3e07e598df6254f18bea48d6de658bad6ce0764ed2c" - }, - { - "id": "nv_array_rows3_f0", - "description": "hash_array of Struct [{a:1}, null, {a:3}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a" - }, - { - "id": "nv_array_rows2_f0", - "description": "hash_array of Struct [{a:1}, {a:3}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a" - }, - { - "id": "nv_array_rows3_f4", - "description": "hash_array of Struct [{a:1}, null, {a:3}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000012fb1af7ca813fefcbd19e1f6d01edc842e1729b0531d2e1bee183692647d4173" - }, - { - "id": "nv_array_rows2_f4", - "description": "hash_array of Struct [{a:1}, {a:3}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001db8ad691e48339ba83ece8c4d4aa7a720788c0e415edbfba4d8ad51d2fc0a692" - }, - { - "id": "phys_dict_rb_f0", - "description": "[z: Int32, d: Dictionary]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" - }, - { - "id": "phys_utf8_rb_f0", - "description": "[z: Int32, d: Utf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" - }, - { - "id": "phys_large_utf8_rb_f0", - "description": "[z: Int32, d: LargeUtf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b" - }, - { - "id": "phys_dict_rb_f3", - "description": "[z: Int32, d: Dictionary]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" - }, - { - "id": "phys_utf8_rb_f3", - "description": "[z: Int32, d: Utf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" - }, - { - "id": "phys_large_utf8_rb_f3", - "description": "[z: Int32, d: LargeUtf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c7f18b8258426b49c253d89a4a7bf41e4ac6e88d0298094fc602de07bfbcaa2a" - }, - { - "id": "phys_dict_rb_f7", - "description": "[z: Int32, d: Dictionary]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" - }, - { - "id": "phys_utf8_rb_f7", - "description": "[z: Int32, d: Utf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" - }, - { - "id": "phys_large_utf8_rb_f7", - "description": "[z: Int32, d: LargeUtf8] same values", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001abd90a756d2b9b699859c501edf37b6dcfc31e009c4e4191d4b0e087a65f7575" - }, - { - "id": "array_struct_xy_f0", - "description": "hash_array of Struct [{1,true},{2,false}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd" - }, - { - "id": "array_struct_yx_f0", - "description": "Same, fields declared y, x", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd" - }, - { - "id": "array_struct_xy_f2", - "description": "hash_array of Struct [{1,true},{2,false}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001e79c0ad382c937100b1dba1ae06a2c0b27be7f78cc72a4b37b9c3d0d87348098" - }, - { - "id": "array_struct_yx_f2", - "description": "Same, fields declared y, x", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000015fe62c542a14a2b619eca6792dba8d93fa89a87176995a8b5ae6462a8da51788" - }, - { - "id": "array_struct_xy_f6", - "description": "hash_array of Struct [{1,true},{2,false}]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001ec888add39caf7a9dedd6ec56bfa446143f3f2abf03848fbf82f61af9cda7215" - }, - { - "id": "array_struct_yx_f6", - "description": "Same, fields declared y, x", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000015735e773b173cc5fe0e1e882674f130575b03e4133667062a777592ac31c5faf" - }, - { - "id": "array_list_struct_f2", - "description": "hash_array of List?> with a null row", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000183624352b7ebacda7b8c3a3e8a2e51561b694c3835b8468e5a9fcfac3d488c5b" - }, - { - "id": "array_list_struct_f7", - "description": "hash_array of List?> with a null row", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000106b91fc017c699ca97737d4bc78d5f52525b6406dd3efecb46b902e928731e4e" - }, - { - "id": "combo_sn_yx_3rows_rb_f7", - "description": "Columns s, n; struct y, x; 3 rows; all options on", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001d6b4594d17ae3482c202877531923bb9212bcf8389fb7597b173dc5796079929" - }, - { - "id": "combo_sn_yx_3rows_stream_f7", - "description": "Same data as two batches", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "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", - "expected_hash": "000001d6b4594d17ae3482c202877531923bb9212bcf8389fb7597b173dc5796079929" - }, - { - "id": "bool_1row_rb_f0", - "description": "b: Boolean non-null [true]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31" - }, - { - "id": "bool_3rows_rb_f0", - "description": "b: Boolean non-null [true, false, false]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31" - }, - { - "id": "bool_array_1_f0", - "description": "hash_array of Boolean [true]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005" - }, - { - "id": "bool_array_2_f0", - "description": "hash_array of Boolean [true, false]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005" - }, - { - "id": "bool_1row_rb_f4", - "description": "b: Boolean non-null [true]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001e392174345825efe12d76a8cf613d226902dcc594342c537f9d81c528b137531" - }, - { - "id": "bool_3rows_rb_f4", - "description": "b: Boolean non-null [true, false, false]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001b5597cc0ee4c9dc458c9e06baa947609cd923db09dacbe2378f33aaf6c690f14" - }, - { - "id": "bool_array_1_f4", - "description": "hash_array of Boolean [true]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000014e102943402882cc417bc1d710b20cae5f60c411ccea8c77bdc020a884ca1236" - }, - { - "id": "bool_array_2_f4", - "description": "hash_array of Boolean [true, false]", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000019f574770ec94ceca20efe47c91263b67b642a106bc40d27345e22d1e72dd2423" - }, - { - "id": "bool_nullable_rb_f0", - "description": "b: Boolean nullable [true, null, false, true]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000012374ef8a63a8cfe593283ae0336f8d9ea5a84c534655acd6eff15636812d388b" - }, - { - "id": "bool_nullable_stream_f0", - "description": "Same as two batches [true] + [null, false, true]", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001185dc35a80c8f2e12d34ceaa7062f09b6edbba7131bd7298752debea7e9c9d04" - }, - { - "id": "bool_nullable_rb_f4", - "description": "b: Boolean nullable [true, null, false, true]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001f38e97f8e2fe332a95bf129fbc7bd02bf809c7ff2ad345cbed6045ec3085ddf4" - }, - { - "id": "bool_nullable_stream_f4", - "description": "Same as two batches [true] + [null, false, true]", - "method": "hash_stream", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001f38e97f8e2fe332a95bf129fbc7bd02bf809c7ff2ad345cbed6045ec3085ddf4" - }, - { - "id": "names_schema_f0", - "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "00000158f3ffc55d1fb210829f8ac71f1b4a29f45e70b120217fd17df22abb0eca1a9b" - }, - { - "id": "names_array_struct_f0", - "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c" - }, - { - "id": "names_schema_f1", - "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "0000011549b426a5c6fe76ee5b0dce8561aeb4448c86627904d9764bd915917fb8feda" - }, - { - "id": "names_array_struct_f1", - "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000146e5353e99efadb553b63626e3785e065ea977063290331f6f4cc66254f1efb5" - }, - { - "id": "names_schema_f7", - "description": "Column names: non-ASCII, CJK, control characters and quotes, and 'km/h' (a '/' that aliases nothing)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "00000158f3d79b469fa3908f93bf0521948e82d2c742a631debb55abfe87d98aa75ae5" - }, - { - "id": "names_array_struct_f7", - "description": "hash_array of Struct<é: Int32> [{é: 1}] (type JSON keeps non-ASCII raw)", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000011791c000afa0ce2c897e5e6635537d691efe7e7bc7ae6be6589005f8aa805034" - }, - { - "id": "names_array_struct_int8_f0", - "description": "hash_array of Struct<é: Int8 non-null> [{é: 1}], default options", - "method": "hash_array", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001e131c1f05f488566a32e4d387451a8998a54d2207416681782e7a2c0ff3affa9" - }, - { - "id": "fsl_int_schema_f0", - "description": "f: FixedSizeList (schema only)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696" - }, - { - "id": "fsl_int_schema_f1", - "description": "f: FixedSizeList (schema only)", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001028f65ed5fcdeb314bb355eedd49c6968b91fc07d3a3048d9868de0075241901" - }, - { - "id": "list_kv_ab_rb_f0", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001622d311ff5b38c734946fffc9088f1dc99bfe8e0cb04ccfda0e420aa8914f4dd" - }, - { - "id": "list_kv_ba_rb_f0", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000015dd41853de5c821a2f13436e7d1886bb606be477024b795d0993cf00f55df2b5" - }, - { - "id": "list_kv_ab_rb_f1", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000013262951dd2bd0d5816a27db1b0dbe6baf6fd321960bdbca93eb77424120754d4" - }, - { - "id": "list_kv_ba_rb_f1", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001b732bdeb1adbe10736db0d382ae346bff3579bcf0c0f726c36097c05621a21ef" - }, - { - "id": "list_kv_ab_rb_f2", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001e3e2ab9ce5627462a6478b88358f11d9e830f9fe0a6e93caea1d99c074bd4ae1" - }, - { - "id": "list_kv_ba_rb_f2", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001934aae7c67907dfb8d81e9065d5882577878dbd6fb9e45a16b70db7a572fe963" - }, - { - "id": "list_kv_ab_rb_f3", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001cc01e2e14642c75fa87a20386fffbc6cbf768573f83746c77236dcfc59ecf72f" - }, - { - "id": "list_kv_ba_rb_f3", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001888c32dcb51501e91305f2b10e384fb4b64f38051fde6ae198a2e354a075e649" - }, - { - "id": "list_kv_ab_rb_f4", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001e7d3f89675621f5a4156f6f078abae23727db8fc317f1cac71e1984e21992ce6" - }, - { - "id": "list_kv_ba_rb_f4", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001ed916278281456016a7a4464aa609718917bb3241fc3dfdab5aa9b195b2b59b6" - }, - { - "id": "list_kv_ab_rb_f5", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000010aebc959d788c3dc406624ce5bc8e8fcd8075b1548cffc3591e1458ff810a49a" - }, - { - "id": "list_kv_ba_rb_f5", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000149081383d6607d80608e51b8b98ef17851e7dd4812a7eef4338767a7f1dfc13a" - }, - { - "id": "list_kv_ab_rb_f6", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001748fdb72d4caf3a1c6801f9e100aa1eec834ece90a80bf9c9ba22dce25c9d006" - }, - { - "id": "list_kv_ba_rb_f6", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001756f035b80282125cf229c8aa85c8d3a57f86d03bde234f60d97c58fce63cab0" - }, - { - "id": "list_kv_ab_rb_f7", - "description": "kv: List> one row [{a,1},{b,2}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000168c7045a867d7ad44e355b2dd396eeb6a5eaa0755ab51b0e06be7a3fb9ba498f" - }, - { - "id": "list_kv_ba_rb_f7", - "description": "Same elements in reverse order [{b,2},{a,1}]", - "method": "hash_record_batch", - "include_metadata": false, - "ordered_columns": true, - "ordered_struct_fields": true, - "nested_validity": true, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000165094d74353dc990af3bf495d67dbef64b278e757fed267583a7ce44f7d6088d" - }, - { - "id": "type_null_schema_f0", - "description": "Schema [c: Null nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQEQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001450e51629d5bf2b2ef7ab0639e64238f7598446f0dbd0716e3d7f4b64b8c640c" - }, - { - "id": "type_boolean_schema_f0", - "description": "Schema [c: Boolean nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001f9913189cc32c79fb14c307c8eef776bfe6a5ac40a7ccc49a0461b5ee557e0d1" - }, - { - "id": "type_int8_schema_f0", - "description": "Schema [c: Int8 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "0000012b83e283d49b73e9069da9861fc1741adb391ce8f592220935a64344ada102a8" - }, - { - "id": "type_int16_schema_f0", - "description": "Schema [c: Int16 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000001880d3e13346e5b9ee77784fc268e1627cf77e8b3411e11b46f6454c3510e381e" - }, - { - "id": "type_int32_schema_f0", - "description": "Schema [c: Int32 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "00000127e2d4e9ff00877d5f7d23ed3881633983fc7aef3b006a96fedb859d128c3989" - }, - { - "id": "type_int64_schema_f0", - "description": "Schema [c: Int64 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000001b025613f15b5f393a4989ef73a15771a1102a55ef411a4b632aabade82a3d01b" - }, - { - "id": "type_uint8_schema_f0", - "description": "Schema [c: UInt8 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000100824cb9155025aae789d5dd0df53c9c16c88deb0972fc9b1e863c39ec55acbd" - }, - { - "id": "type_uint16_schema_f0", - "description": "Schema [c: UInt16 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b0f78a84d6b3598e5526341cd4f4570bc0ec6e98718f4d5249b851c6152eabc7" - }, - { - "id": "type_uint32_schema_f0", - "description": "Schema [c: UInt32 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001351c5bba858bc19d1b0e76c645616c137ab578e680a168263de0c183d881ebfe" - }, - { - "id": "type_uint64_schema_f0", - "description": "Schema [c: UInt64 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000013f0e525838f78941dd7ebf1cf53a38aab1ce76083120f046e3c7d5d3a1d36674" - }, - { - "id": "type_float16_schema_f0", - "description": "Schema [c: Float16 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAAFAAAAAAAAQMQAAAABAAEAAQAAAAAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000014da58ec28052f47317cbc02b5af025698cb2c541ca0c0296a0f37098e1bc8393" - }, - { - "id": "type_float32_schema_f0", - "description": "Schema [c: Float32 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b79ddc004ecda1cacf1ca4129c9339f87231e38b3feb324f37505fbb00448261" - }, - { - "id": "type_float64_schema_f0", - "description": "Schema [c: Float64 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000018a4b885963f8e74a322a01627a43ace66eff8b29f9bffaae78d75026d6c338f0" - }, - { - "id": "type_date32_schema_f0", - "description": "Schema [c: Date32 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000017067a187a25f7004d66cca4b06e7e3e319f7f71288a9fc42df603f092b6c7f4b" - }, - { - "id": "type_date64_schema_f0", - "description": "Schema [c: Date64 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001eafdd4283792f22e1655bf61378bdc53de9f32d3b34cba20ee33349b6d215d27" - }, - { - "id": "type_time32_s_schema_f0", - "description": "Schema [c: Time32(Second) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001fedd3327155f022a4dd129ad3ed5afca9999f932498d991cc8efbb8e020052a2" - }, - { - "id": "type_time32_ms_schema_f0", - "description": "Schema [c: Time32(Millisecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001c2e1de3bcbf6a5a5faaec60dce7c65c5124061f0ccb97e7ef165a17a42b2fc4b" - }, - { - "id": "type_time64_us_schema_f0", - "description": "Schema [c: Time64(Microsecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAgBAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000001228968561050acaeb788b5475feba508a6ea8234768429d0671bf0e62d58d71b" - }, - { - "id": "type_time64_ns_schema_f0", - "description": "Schema [c: Time64(Nanosecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "0000018b7675631dcdbdaf3dfa91e3f3286f7211cf2193dcae672411b09afe4050fe59" - }, - { - "id": "type_timestamp_s_naive_schema_f0", - "description": "Schema [c: Timestamp(Second, None) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQoYAAAAAAAAAAQABAAEAAAAAAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000019fe4c7746047294fd6a07264648cedf7f0e64f08a644d779c852d270dde089db" - }, - { - "id": "type_timestamp_ms_utc_schema_f0", - "description": "Schema [c: Timestamp(Millisecond, Some(\"UTC\")) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQokAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAEAAwAAAFVUQwABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000196d90de77d3557403eb475d0f0d64774319117987aa1c588115c455666c597b5" - }, - { - "id": "type_timestamp_us_offset_schema_f0", - "description": "Schema [c: Timestamp(Microsecond, Some(\"+05:30\")) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQooAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAIABgAAACswNTozMAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001c87d3b92444ee5a6b5e4e2f3bc098236ba7bcc9524ffe6e58cd012c3092bb922" - }, - { - "id": "type_timestamp_ns_named_tz_schema_f0", - "description": "Schema [c: Timestamp(Nanosecond, Some(\"America/New_York\")) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQo0AAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAMAEAAAAEFtZXJpY2EvTmV3X1lvcmsAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001940af673c638fc1ff9aefe02078d47ad1713ba21d3916a1a87bdb0ead51afc5e" - }, - { - "id": "type_duration_s_schema_f0", - "description": "Schema [c: Duration(Second) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000019ef92ec048bd73719517bcdd78f1a52e57dd8d3ebbba8c3dbe689bf3473c8454" - }, - { - "id": "type_duration_ms_schema_f0", - "description": "Schema [c: Duration(Millisecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARIQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000015f844828d2b1cf182199ab026ac2903425f0f84898befe53f53b38a8468ae257" - }, - { - "id": "type_duration_us_schema_f0", - "description": "Schema [c: Duration(Microsecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001bc8e82b752d5d898ae332e360b8325e742b6d7359b6b6aed59ff21578b53141e" - }, - { - "id": "type_duration_ns_schema_f0", - "description": "Schema [c: Duration(Nanosecond) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAwABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001e881ee30b58bdaa77fbc333e13eb21a00d3ca4e96283f1eeb4062fb29995352f" - }, - { - "id": "type_interval_year_month_schema_f0", - "description": "Schema [c: Interval(YearMonth) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQsQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001edfdb7dd18d6d1f1726bd0a820e82c13ba013ca920bd3d93d08530782119785b" - }, - { - "id": "type_interval_day_time_schema_f0", - "description": "Schema [c: Interval(DayTime) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAQABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001ff900d6b57d11a3aed395b0a882a0cdf411450df8a497826e4cbdad57a41217f" - }, - { - "id": "type_interval_month_day_nano_schema_f0", - "description": "Schema [c: Interval(MonthDayNano) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001b8ebd94791c839fcf2572f1abfe6584d39ff559624dc3362f6ff6a9b43bfd9b7" - }, - { - "id": "type_decimal32_schema_f0", - "description": "Schema [c: Decimal32(9, 2) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAAAgAAAAAgAAAAkAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001dd88bf3c39e96145f03d8fc9054089eb4dd8c437d74b1d4aa1b25b8e351e5c75" - }, - { - "id": "type_decimal64_negative_scale_schema_f0", - "description": "Schema [c: Decimal64(18, -3) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAABAAAAA/f///xIAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001e16e0018ba784be83994c7a94db3071ab9c5462566161105d4ef8128105ed816" - }, - { - "id": "type_decimal128_schema_f0", - "description": "Schema [c: Decimal128(38, 10) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQccAAAAAAAAAAgADAAIAAQACAAAAAoAAAAmAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000001ebcc3afc437ac2f831005f29907440ae6d08ab647a04f974be15d44951326683" - }, - { - "id": "type_decimal256_schema_f0", - "description": "Schema [c: Decimal256(76, 0) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQcgAAAAAAAAAAAACgAMAAgAAAAEAAoAAAAAAQAATAAAAAEAAABjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000017bf47db10e1322b3ebd6780afe01406dd3680654a3b77133f8139ebd4c987e04" - }, - { - "id": "type_fixed_size_binary_schema_f0", - "description": "Schema [c: FixedSizeBinary(16) nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a1ed63688a1bfef27f1bb08ffbc85de0edc469fc74ca4a78b89d524c1524eaa4" - }, - { - "id": "type_utf8_schema_f0", - "description": "Schema [c: Utf8 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8" - }, - { - "id": "type_large_utf8_schema_f0", - "description": "Schema [c: LargeUtf8 nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8" - }, - { - "id": "type_binary_schema_f0", - "description": "Schema [c: Binary nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5" - }, - { - "id": "type_large_binary_schema_f0", - "description": "Schema [c: LargeBinary nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARMQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5" - }, - { - "id": "type_utf8_view_schema_f0", - "description": "Schema [c: Utf8View nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001c4f113df591f75ffe79c1da85c5000f0ade80eae214b97713872cab348800aa7" - }, - { - "id": "type_binary_view_schema_f0", - "description": "Schema [c: BinaryView nullable], default options", - "method": "hash_schema", - "include_metadata": false, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARcQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001d212dca06f49287359b6359167ac3cc02782572c4463bb552297ae03a347b856" - }, - { - "id": "meta_map_value_schema_f0_im1", - "description": "m: Map, metadata on the value field (path m//value)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000018e90e39f63cff9891fa1536def277ab7c2545567c51cecf37e765e75f0609789" - }, - { - "id": "meta_map_key_schema_f0_im1", - "description": "m: Map, metadata on the key field (path m//key)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000197b0e3e6528d52a065864a687be4a19b4197dfb62a4ca9915c6b7d3e6bd31ee7" - }, - { - "id": "meta_map_entries_schema_f0_im1", - "description": "m: Map, metadata on the entries field (path m/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000138559b12d08a2cd6fc073ad2f98a22d75737b580905227d99207851c25e89951" - }, - { - "id": "meta_map_all_schema_f0_im1", - "description": "m: Map, metadata on entries, key and value", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", - "expected_hash": "0000017f5cbc6a8a7a9e6f8b06fdb33a8689f413b5034a80e41451cc7d3e50d648dbaf" - }, - { - "id": "meta_struct_child_schema_f0_im1", - "description": "s: Struct, metadata on a struct child (path s/a)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000013ad8bf07377e7c14cdf271b6626b203a28f2295391ef0e9ac21d40d99bd0473a" - }, - { - "id": "meta_list_element_schema_f0_im1", - "description": "l: List, metadata on the element field (path l/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000138cb63f6c736f44536dbc3c1cef7a81d6caa89a68a35db9ef4fcb04a82cfe91f" - }, - { - "id": "meta_fsl_element_schema_f0_im1", - "description": "f: FixedSizeList, metadata on the element field (path f/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": false, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", - "expected_hash": "00000167f097bbffcd5ab67297252711a30106996ce8d0d7940e91ceab68b69c07023a" - }, - { - "id": "meta_map_value_schema_f1_im1", - "description": "m: Map, metadata on the value field (path m//value)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000113d0fd6b28169745d9c4d182918e571390b1cdc5081347332df240882251759d" - }, - { - "id": "meta_map_key_schema_f1_im1", - "description": "m: Map, metadata on the key field (path m//key)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000114911c97fa61b213f4dad790c41703f48d942ae6dc5c5daedc3f6058445c0015" - }, - { - "id": "meta_map_entries_schema_f1_im1", - "description": "m: Map, metadata on the entries field (path m/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000001a75deaf594d41aa6dd774d1a115aa616f04c70a36e485293823428d2e508d8f3" - }, - { - "id": "meta_map_all_schema_f1_im1", - "description": "m: Map, metadata on entries, key and value", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", - "expected_hash": "000001a6df789e7d95703d35ac88bf1438ef6da2062c332fc369685c2983abf3987407" - }, - { - "id": "meta_struct_child_schema_f1_im1", - "description": "s: Struct, metadata on a struct child (path s/a)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000001116ae1c6756fb49fdc4725823fec527edd01ac1967861bfee2aa1f9173b5c2a7" - }, - { - "id": "meta_list_element_schema_f1_im1", - "description": "l: List, metadata on the element field (path l/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000001f9f1fcf3d5677aacd3ded7dd226567241e40326037a175e03ac1c8f974de1d12" - }, - { - "id": "meta_fsl_element_schema_f1_im1", - "description": "f: FixedSizeList, metadata on the element field (path f/)", - "method": "hash_schema", - "include_metadata": true, - "ordered_columns": true, - "ordered_struct_fields": false, - "nested_validity": false, - "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", - "expected_hash": "0000018a1bc48fd6b563121326907f9cd57a3b038a74de116c9ba2594f50d0913bee86" - } - ], - "relations": [ - { - "kind": "equal", - "ids": [ - "cols_ab_rb_f0", - "cols_ba_rb_f0" - ], - "why": "column order ignored by default" - }, - { - "kind": "different", - "ids": [ - "cols_ab_rb_f1", - "cols_ba_rb_f1" - ], - "why": "ordered_columns: column order is part of the hash" - }, - { - "kind": "equal", - "ids": [ - "cols_ab_schema_f0", - "cols_ba_schema_f0" - ], - "why": "schema: column order ignored by default" - }, - { - "kind": "different", - "ids": [ - "cols_ab_schema_f1", - "cols_ba_schema_f1" - ], - "why": "schema: ordered_columns" - }, - { - "kind": "equal", - "ids": [ - "cols_ba_stream_f1", - "cols_ba_rb_f1" - ], - "why": "batch-split independence in ordered mode" - }, - { - "kind": "equal", - "ids": [ - "combo_ns_xy_f0", - "combo_sn_xy_f0", - "combo_ns_yx_f0", - "combo_sn_yx_f0" - ], - "why": "flags 0: no order matters" - }, - { - "kind": "equal", - "ids": [ - "combo_ns_xy_f1", - "combo_ns_yx_f1" - ], - "why": "flags 1: struct order ignored" - }, - { - "kind": "equal", - "ids": [ - "combo_sn_xy_f1", - "combo_sn_yx_f1" - ], - "why": "flags 1: struct order ignored" - }, - { - "kind": "different", - "ids": [ - "combo_ns_xy_f1", - "combo_sn_xy_f1" - ], - "why": "flags 1: column order matters" - }, - { - "kind": "equal", - "ids": [ - "combo_ns_xy_f2", - "combo_sn_xy_f2" - ], - "why": "flags 2: column order ignored" - }, - { - "kind": "equal", - "ids": [ - "combo_ns_yx_f2", - "combo_sn_yx_f2" - ], - "why": "flags 2: column order ignored" - }, - { - "kind": "different", - "ids": [ - "combo_ns_xy_f2", - "combo_ns_yx_f2" - ], - "why": "flags 2: struct order matters" - }, - { - "kind": "different", - "ids": [ - "combo_ns_xy_f3", - "combo_sn_xy_f3", - "combo_ns_yx_f3", - "combo_sn_yx_f3" - ], - "why": "flags 3: both orders matter" - }, - { - "kind": "different", - "ids": [ - "combo_ns_xy_f0", - "combo_ns_xy_f1", - "combo_ns_xy_f2", - "combo_ns_xy_f3" - ], - "why": "the four combinations are domain separated" - }, - { - "kind": "equal", - "ids": [ - "nested_struct_ab_schema_f0", - "nested_struct_ba_schema_f0" - ], - "why": "struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "nested_struct_ab_schema_f2", - "nested_struct_ba_schema_f2" - ], - "why": "ordered_struct_fields applies at this depth" - }, - { - "kind": "equal", - "ids": [ - "list_struct_ab_rb_f0", - "list_struct_ba_rb_f0" - ], - "why": "struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "list_struct_ab_rb_f2", - "list_struct_ba_rb_f2" - ], - "why": "ordered_struct_fields applies at this depth" - }, - { - "kind": "equal", - "ids": [ - "fsl_struct_ab_schema_f0", - "fsl_struct_ba_schema_f0" - ], - "why": "struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "fsl_struct_ab_schema_f2", - "fsl_struct_ba_schema_f2" - ], - "why": "ordered_struct_fields applies at this depth" - }, - { - "kind": "equal", - "ids": [ - "map_struct_ab_schema_f0", - "map_struct_ba_schema_f0" - ], - "why": "struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "map_struct_ab_schema_f2", - "map_struct_ba_schema_f2" - ], - "why": "ordered_struct_fields applies at this depth" - }, - { - "kind": "equal", - "ids": [ - "list_struct_ab_rb_f2", - "large_list_struct_ab_rb_f2" - ], - "why": "List and LargeList agree in ordered mode" - }, - { - "kind": "equal", - "ids": [ - "list_struct_ab_rb_f0", - "large_list_struct_ab_rb_f0" - ], - "why": "List and LargeList agree by default" - }, - { - "kind": "different", - "ids": [ - "one_col_rb_f0", - "one_col_rb_f1", - "one_col_rb_f2", - "one_col_rb_f3", - "one_col_rb_f4", - "one_col_rb_f5", - "one_col_rb_f6", - "one_col_rb_f7" - ], - "why": "every flag value is domain separated, even when order cannot matter" - }, - { - "kind": "different", - "ids": [ - "one_col_schema_f0", - "one_col_schema_f1", - "one_col_schema_f2", - "one_col_schema_f3", - "one_col_schema_f4", - "one_col_schema_f5", - "one_col_schema_f6", - "one_col_schema_f7" - ], - "why": "every flag value is domain separated, even when order cannot matter" - }, - { - "kind": "different", - "ids": [ - "one_col_array_f0", - "one_col_array_f1", - "one_col_array_f2", - "one_col_array_f3", - "one_col_array_f4", - "one_col_array_f5", - "one_col_array_f6", - "one_col_array_f7" - ], - "why": "every flag value is domain separated, even when order cannot matter" - }, - { - "kind": "equal", - "ids": [ - "plain_schema_f1_im0", - "plain_schema_f1_im1" - ], - "why": "empty-metadata invariant holds within each mode" - }, - { - "kind": "different", - "ids": [ - "plain_schema_f1_im1", - "meta_schema_f1_im1" - ], - "why": "metadata counts within each mode" - }, - { - "kind": "equal", - "ids": [ - "plain_schema_f7_im0", - "plain_schema_f7_im1" - ], - "why": "empty-metadata invariant holds within each mode" - }, - { - "kind": "different", - "ids": [ - "plain_schema_f7_im1", - "meta_schema_f7_im1" - ], - "why": "metadata counts within each mode" - }, - { - "kind": "equal", - "ids": [ - "ext_struct_xy_rb_f0_im1", - "ext_struct_yx_rb_f0_im1" - ], - "why": "extension storage struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "ext_struct_xy_rb_f2_im1", - "ext_struct_yx_rb_f2_im1" - ], - "why": "extension storage struct order counts with ordered_struct_fields" - }, - { - "kind": "equal", - "ids": [ - "empty_stream_f1", - "zero_row_rb_f1" - ], - "why": "a zero-row batch contributes nothing" - }, - { - "kind": "equal", - "ids": [ - "zero_cols_0rows_rb_f0", - "zero_cols_3rows_rb_f0" - ], - "why": "documented limitation: zero-column tables do not hash their row count" - }, - { - "kind": "equal", - "ids": [ - "zero_cols_0rows_rb_f1", - "zero_cols_3rows_rb_f1" - ], - "why": "documented limitation: zero-column tables do not hash their row count" - }, - { - "kind": "different", - "ids": [ - "zero_cols_0rows_rb_f0", - "zero_cols_0rows_rb_f1" - ], - "why": "zero-column table is still domain separated" - }, - { - "kind": "equal", - "ids": [ - "nv_null_struct_rb_f0", - "nv_null_fields_rb_f0" - ], - "why": "default layout loses this distinction (frozen)" - }, - { - "kind": "different", - "ids": [ - "nv_null_struct_rb_f4", - "nv_null_fields_rb_f4" - ], - "why": "nested_validity records it" - }, - { - "kind": "different", - "ids": [ - "nv_null_struct_rb_f7", - "nv_null_fields_rb_f7" - ], - "why": "nested_validity records it (all options on)" - }, - { - "kind": "equal", - "ids": [ - "nv_rows3_rb_f0", - "nv_rows2_rb_f0" - ], - "why": "default layout loses this distinction (frozen)" - }, - { - "kind": "different", - "ids": [ - "nv_rows3_rb_f4", - "nv_rows2_rb_f4" - ], - "why": "nested_validity records it" - }, - { - "kind": "different", - "ids": [ - "nv_rows3_rb_f7", - "nv_rows2_rb_f7" - ], - "why": "nested_validity records it (all options on)" - }, - { - "kind": "equal", - "ids": [ - "nv_list_list_1row_rb_f0", - "nv_list_list_2rows_rb_f0" - ], - "why": "default layout loses this distinction (frozen)" - }, - { - "kind": "different", - "ids": [ - "nv_list_list_1row_rb_f4", - "nv_list_list_2rows_rb_f4" - ], - "why": "nested_validity records it" - }, - { - "kind": "different", - "ids": [ - "nv_list_list_1row_rb_f7", - "nv_list_list_2rows_rb_f7" - ], - "why": "nested_validity records it (all options on)" - }, - { - "kind": "equal", - "ids": [ - "nv_list_null_elem_rb_f0", - "nv_list_null_fields_elem_rb_f0" - ], - "why": "default layout loses this distinction (frozen)" - }, - { - "kind": "different", - "ids": [ - "nv_list_null_elem_rb_f4", - "nv_list_null_fields_elem_rb_f4" - ], - "why": "nested_validity records it" - }, - { - "kind": "different", - "ids": [ - "nv_list_null_elem_rb_f7", - "nv_list_null_fields_elem_rb_f7" - ], - "why": "nested_validity records it (all options on)" - }, - { - "kind": "equal", - "ids": [ - "nv_rows3_stream_f4", - "nv_rows3_rb_f4" - ], - "why": "batch-split independence with nested_validity" - }, - { - "kind": "equal", - "ids": [ - "nv_array_rows3_f0", - "nv_array_rows2_f0" - ], - "why": "default hash_array drops null struct rows (frozen)" - }, - { - "kind": "different", - "ids": [ - "nv_array_rows3_f4", - "nv_array_rows2_f4" - ], - "why": "nested_validity counts them" - }, - { - "kind": "equal", - "ids": [ - "phys_dict_rb_f0", - "phys_utf8_rb_f0", - "phys_large_utf8_rb_f0" - ], - "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" - }, - { - "kind": "equal", - "ids": [ - "phys_dict_rb_f3", - "phys_utf8_rb_f3", - "phys_large_utf8_rb_f3" - ], - "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" - }, - { - "kind": "equal", - "ids": [ - "phys_dict_rb_f7", - "phys_utf8_rb_f7", - "phys_large_utf8_rb_f7" - ], - "why": "dictionary, Utf8 and LargeUtf8 agree in every mode" - }, - { - "kind": "equal", - "ids": [ - "array_struct_xy_f0", - "array_struct_yx_f0" - ], - "why": "hash_array: struct order ignored by default" - }, - { - "kind": "different", - "ids": [ - "array_struct_xy_f2", - "array_struct_yx_f2" - ], - "why": "hash_array: ordered_struct_fields" - }, - { - "kind": "different", - "ids": [ - "array_struct_xy_f6", - "array_struct_yx_f6" - ], - "why": "hash_array: ordered_struct_fields with nested_validity" - }, - { - "kind": "equal", - "ids": [ - "combo_sn_yx_3rows_rb_f7", - "combo_sn_yx_3rows_stream_f7" - ], - "why": "batch-split independence with all options on" - }, - { - "kind": "equal", - "ids": [ - "bool_1row_rb_f0", - "bool_3rows_rb_f0" - ], - "why": "default layout: trailing false Boolean rows are lost (frozen)" - }, - { - "kind": "different", - "ids": [ - "bool_1row_rb_f4", - "bool_3rows_rb_f4" - ], - "why": "third switch: one byte per Boolean value counts them" - }, - { - "kind": "equal", - "ids": [ - "bool_array_1_f0", - "bool_array_2_f0" - ], - "why": "default hash_array: trailing false lost (frozen)" - }, - { - "kind": "different", - "ids": [ - "bool_array_1_f4", - "bool_array_2_f4" - ], - "why": "third switch: counted" - }, - { - "kind": "different", - "ids": [ - "bool_nullable_rb_f0", - "bool_nullable_stream_f0" - ], - "why": "default layout: Boolean data is packed per batch, so batch splits change the hash (frozen)" - }, - { - "kind": "equal", - "ids": [ - "bool_nullable_rb_f4", - "bool_nullable_stream_f4" - ], - "why": "third switch: Boolean is batch-split independent" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f0", - "list_kv_ba_rb_f0" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f1", - "list_kv_ba_rb_f1" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f2", - "list_kv_ba_rb_f2" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f3", - "list_kv_ba_rb_f3" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f4", - "list_kv_ba_rb_f4" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f5", - "list_kv_ba_rb_f5" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f6", - "list_kv_ba_rb_f6" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "different", - "ids": [ - "list_kv_ab_rb_f7", - "list_kv_ba_rb_f7" - ], - "why": "list element order is part of the hash in every mode (starfix never sorts lists)" - }, - { - "kind": "equal", - "ids": [ - "type_utf8_schema_f0", - "type_large_utf8_schema_f0" - ], - "why": "Utf8 and LargeUtf8 share the canonical form" - }, - { - "kind": "equal", - "ids": [ - "type_binary_schema_f0", - "type_large_binary_schema_f0" - ], - "why": "Binary and LargeBinary share the canonical form" - }, - { - "kind": "different", - "ids": [ - "type_utf8_schema_f0", - "type_utf8_view_schema_f0" - ], - "why": "Utf8View is not canonicalized" - }, - { - "kind": "different", - "ids": [ - "meta_map_value_schema_f0_im1", - "meta_map_key_schema_f0_im1", - "meta_map_entries_schema_f0_im1", - "meta_map_all_schema_f0_im1" - ], - "why": "metadata on the map's entries, key and value fields is recorded at distinct paths" - } - ] -} diff --git a/tests/test_api.py b/tests/test_api.py new file mode 100644 index 0000000..628108f --- /dev/null +++ b/tests/test_api.py @@ -0,0 +1,51 @@ +"""Public API shape of ArrowDigester (hash format 2).""" + +from __future__ import annotations + +import pyarrow as pa +import pytest + +from starfix import ArrowDigester + +OPTIONS = ("include_metadata", "ordered_columns", "ordered_struct_fields") + + +def _inputs(): + schema = pa.schema([pa.field("a", pa.int32())]) + batch = pa.record_batch([pa.array([1], pa.int32())], schema=schema) + return schema, batch, pa.Table.from_batches([batch]), batch.column(0) + + +def test_options_are_keyword_only() -> None: + schema, batch, table, arr = _inputs() + with pytest.raises(TypeError): + ArrowDigester(schema, True) # type: ignore[misc] + for call, arg in ((ArrowDigester.hash_schema, schema), (ArrowDigester.hash_record_batch, batch), + (ArrowDigester.hash_table, table)): + with pytest.raises(TypeError): + call(arg, True) # type: ignore[misc] + for name in OPTIONS: + assert call(arg, **{name: True}).hex().startswith("000002") + with pytest.raises(TypeError): + ArrowDigester.hash_array(arr, True) # type: ignore[misc] + + +def test_hash_array_has_no_include_metadata() -> None: + with pytest.raises(TypeError): + ArrowDigester.hash_array(pa.array([1]), include_metadata=True) # type: ignore[call-arg] + + +def test_no_third_option_in_format_2() -> None: + schema, *_ = _inputs() + with pytest.raises(TypeError): + ArrowDigester.hash_schema(schema, nested_validity=True) # type: ignore[call-arg] + + +def test_streaming_equals_one_shot() -> None: + schema, batch, table, _ = _inputs() + d = ArrowDigester(schema, ordered_columns=True) + d.update(batch) + assert d.finalize() == ArrowDigester.hash_table(table, ordered_columns=True) + assert ArrowDigester.hash_record_batch(batch, ordered_columns=True) == ArrowDigester.hash_table( + table, ordered_columns=True + ) diff --git a/tests/test_arrow_digester.py b/tests/test_arrow_digester.py index 0d5f2d6..9e64258 100644 --- a/tests/test_arrow_digester.py +++ b/tests/test_arrow_digester.py @@ -6,7 +6,12 @@ import pyarrow as pa import pytest -from starfix.arrow_digester import ArrowDigester, _serialized_schema +from starfix._format2 import phase1_json +from starfix.arrow_digester import ArrowDigester + + +def _serialized_schema(schema): + return phase1_json(schema, 0) # ── Schema serialization ────────────────────────────────────────────── @@ -108,7 +113,7 @@ def test_simple_schema_empty_table(self): ]) d = ArrowDigester(schema) h = d.finalize().hex() - assert h.startswith("000001") + assert h.startswith("000002") # hash format 2 # Self-consistency: finalize with no updates on fresh instances d2 = ArrowDigester(schema) assert d2.finalize() == d.finalize() @@ -121,22 +126,22 @@ class TestArrayHashing: def test_boolean_array(self): arr = pa.array([True, None, False, True], type=pa.bool_()) h = ArrowDigester.hash_array(arr).hex() - assert h == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + assert h == "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" def test_int32_array(self): arr = pa.array([42, None, -7, 0], type=pa.int32()) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + assert h == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" def test_time32_second_array(self): arr = pa.array([1000, None, 5000, 0], type=pa.time32("s")) h = ArrowDigester.hash_array(arr).hex() - assert h == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + assert h == "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" def test_time64_microsecond_array(self): arr = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) h = ArrowDigester.hash_array(arr).hex() - assert h == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + assert h == "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" def test_time_units_differ(self): a = pa.array([1000, 2000], type=pa.time32("s")) @@ -146,12 +151,12 @@ def test_time_units_differ(self): def test_binary_array(self): arr = pa.array([b"hello", None, b"world", b""], type=pa.binary()) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + assert h == "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" def test_string_array(self): arr = pa.array(["hello", None, "world", ""], type=pa.utf8()) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert h == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" def test_list_array(self): arr = pa.array( @@ -159,7 +164,7 @@ def test_list_array(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) h = ArrowDigester.hash_array(arr).hex() - assert h == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + assert h == "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" def test_decimal128_array(self): from decimal import Decimal @@ -173,7 +178,7 @@ def test_decimal128_array(self): type=pa.decimal128(38, 5), ) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e" + assert h == "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" # ── Type normalization ──────────────────────────────────────────────── @@ -340,7 +345,7 @@ def test_streaming_golden_value(self): d = ArrowDigester(schema) d.update(batch1) d.update(batch2) - assert d.finalize().hex() == "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0" + assert d.finalize().hex() == "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" def test_nullable_vs_non_nullable_same_data(self): """Array with all valid values should hash same whether nullable or not.""" diff --git a/tests/test_golden_parity.py b/tests/test_golden_parity.py index df28334..5fb8349 100644 --- a/tests/test_golden_parity.py +++ b/tests/test_golden_parity.py @@ -52,13 +52,13 @@ def test_example_b_bool_array_with_nulls(self): """Example B: BooleanArray [true, NULL, false, true].""" array = pa.array([True, None, False, True], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + assert result == "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" def test_example_c_non_nullable_int32(self): """Example C: Int32Array [1, 2, 3] — non-nullable.""" array = pa.array([1, 2, 3], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c" + assert result == "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" def test_example_d_non_nullable_binary(self): """Example D: BinaryArray [b'hi', b''] — non-nullable; tests Binary→LargeBinary canonicalization.""" @@ -100,13 +100,13 @@ def test_example_g_nullable_int32(self): """Example G: Int32Array [Some(42), None, Some(-7), Some(0)].""" array = pa.array([42, None, -7, 0], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + assert result == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" def test_example_h_nullable_string(self): """Example H: StringArray [Some('hello'), None, Some('world'), Some('')].""" array = pa.array(["hello", None, "world", ""], type=pa.utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert result == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" def test_example_i_empty_table(self): """Example I: schema {a: Int32 non-null, b: Boolean nullable} with zero rows.""" @@ -127,7 +127,7 @@ def test_example_j_multi_batch_streaming(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857" + assert result == "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b" def test_example_k_struct_column(self): """Example K: {person: Struct}.""" @@ -212,7 +212,7 @@ def test_int16(self): def test_int32(self): array = pa.array([42, None, -7, 0], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + assert result == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" def test_int64(self): array = pa.array([1_000_000, None, -1_000_000, 0], type=pa.int64()) @@ -272,7 +272,7 @@ def test_time32_seconds(self): """Time32(s): seconds since midnight.""" array = pa.array([1000, None, 5000, 0], type=pa.time32("s")) result = ArrowDigester.hash_array(array).hex() - assert result == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + assert result == "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" def test_time32_milliseconds(self): """Time32(ms): milliseconds since midnight.""" @@ -284,7 +284,7 @@ def test_time64_microseconds(self): """Time64(us): microseconds since midnight.""" array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) result = ArrowDigester.hash_array(array).hex() - assert result == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + assert result == "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" def test_time64_nanoseconds(self): """Time64(ns): nanoseconds since midnight.""" @@ -303,13 +303,13 @@ def test_binary(self): """Binary array — tests LargeBinary canonicalization.""" array = pa.array([b"hello", None, b"world", b""], type=pa.binary()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + assert result == "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" def test_large_binary_equals_binary(self): """LargeBinary and Binary arrays with same data must produce the same hash.""" small = pa.array([b"hello", None, b"world", b""], type=pa.binary()) large = pa.array([b"hello", None, b"world", b""], type=pa.large_binary()) - expected = "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + expected = "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -317,13 +317,13 @@ def test_string(self): """String (Utf8) array — tests LargeUtf8 canonicalization.""" array = pa.array(["hello", None, "world", ""], type=pa.utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert result == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" def test_large_string_equals_string(self): """LargeUtf8 and Utf8 arrays with same data must produce the same hash.""" small = pa.array(["hello", None, "world", ""], type=pa.utf8()) large = pa.array(["hello", None, "world", ""], type=pa.large_utf8()) - expected = "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + expected = "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -346,7 +346,7 @@ def test_decimal_precision_9_scale_2(self): type=pa.decimal128(9, 2), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000014f015bd5c4b6ce6e939a8c890333f3e110c2c28ef8014aafd352f8373791e547" + assert result == "000002e83147c84038cb72cb3cc8e24e651e0491028c449cfe7f2a9d51ded84391ca40" def test_decimal_precision_15_scale_3(self): """Decimal128 precision=15 (maps to decimal64 range) scale=3.""" @@ -355,7 +355,7 @@ def test_decimal_precision_15_scale_3(self): type=pa.decimal128(15, 3), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001dc08c7b9c583edecec36bc5dee21cd2edec9f402a651014fea5f8834d16ad737" + assert result == "00000226d3b5c66b1fa3b3de097542369f89b2717f3026c778ce17d57817fbf2fec8f0" def test_decimal_precision_38_scale_5(self): """Decimal128 precision=38 scale=5 — full 16-byte integer path.""" @@ -369,7 +369,7 @@ def test_decimal_precision_38_scale_5(self): type=pa.decimal128(38, 5), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e" + assert result == "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" # --------------------------------------------------------------------------- @@ -390,7 +390,7 @@ def test_list_of_int32(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + assert result == "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" def test_large_list_equals_list(self): """LargeList with the same data must produce the same hash as List.""" @@ -402,7 +402,7 @@ def test_large_list_equals_list(self): [[1, 2, 3], None, [4, 5], [6]], type=pa.large_list(pa.field("item", pa.int32(), nullable=True)), ) - expected = "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + expected = "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -588,7 +588,7 @@ def test_streaming_two_batches(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0" + assert result == "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" def test_batch_split_independence(self): """Splitting a batch into two must not change the hash.""" @@ -626,37 +626,37 @@ class TestTimestampDurationHashing: def test_timestamp_second_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("s", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b" + assert ArrowDigester.hash_array(arr).hex() == "00000252859a0dad006bac78dd1ba3fa17fde43bfa2af9cc95bdd08b6611da1691f012" def test_timestamp_millisecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ms", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5" + assert ArrowDigester.hash_array(arr).hex() == "000002f6dcd4d91471e975d86257785c15f0d8e120a84b45f163378e913d10935f1ec9" def test_timestamp_microsecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("us", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e" + assert ArrowDigester.hash_array(arr).hex() == "00000209c1c989349caa973563a880521cbcaaa4e62ccc77f380e69f0fc57c639b4bfa" def test_timestamp_nanosecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ns", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0" + assert ArrowDigester.hash_array(arr).hex() == "0000021d86082dfda0e2f0449320c2acd853756d79dc3080cf1ee14327c7c9f2201480" # -- Timestamp (tz-naive) ---------------------------------------------- def test_timestamp_second_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("s")) - assert ArrowDigester.hash_array(arr).hex() == "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30" + assert ArrowDigester.hash_array(arr).hex() == "0000028fa5d6fbc775327e0c766cab77a00991dc87cf7ac7d45f875d049559b55cbb3e" def test_timestamp_millisecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ms")) - assert ArrowDigester.hash_array(arr).hex() == "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842" + assert ArrowDigester.hash_array(arr).hex() == "000002c0d0e86c4e7ff759ad83bf887cf5b20f2b662ceeeba5865ed1f5353b6b7a9445" def test_timestamp_microsecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("us")) - assert ArrowDigester.hash_array(arr).hex() == "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3" + assert ArrowDigester.hash_array(arr).hex() == "000002148a265e62ae6878931d8d3316c4aec43f50da2e688d83bfe62901c3703e6b4f" def test_timestamp_nanosecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ns")) - assert ArrowDigester.hash_array(arr).hex() == "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796" + assert ArrowDigester.hash_array(arr).hex() == "00000292c1b50fa17e537e6afb5903cce37b5b28b03088e6ec3e23c346d9adafb071a7" # -- Timestamp: unit and tz produce different hashes ------------------- @@ -682,19 +682,19 @@ def test_timestamp_tz_differs(self): def test_duration_second(self): arr = pa.array([0, None, 1_000], type=pa.duration("s")) - assert ArrowDigester.hash_array(arr).hex() == "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa" + assert ArrowDigester.hash_array(arr).hex() == "000002f4db00404adc309eaa3c23518b36b56a44659edc0a4c4dbbddea90449cf90413" def test_duration_millisecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("ms")) - assert ArrowDigester.hash_array(arr).hex() == "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c" + assert ArrowDigester.hash_array(arr).hex() == "000002767dcb630f550d41da343f63fb308d1e2ce97e68306f988573178da666fb156f" def test_duration_microsecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("us")) - assert ArrowDigester.hash_array(arr).hex() == "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a" + assert ArrowDigester.hash_array(arr).hex() == "00000267a46b80b8577b61b24e665edbe71f78d6af7170305cbe0b348ca07a1b2874d9" def test_duration_nanosecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("ns")) - assert ArrowDigester.hash_array(arr).hex() == "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b" + assert ArrowDigester.hash_array(arr).hex() == "00000265d49688aae1ade659148d969f4fd703fa688fd7e3dcbe3c00d5e7ef2ae50720" def test_duration_units_differ(self): values = [1_000, 2_000] diff --git a/tests/test_golden_parity_format2.py b/tests/test_golden_parity_format2.py new file mode 100644 index 0000000..0272655 --- /dev/null +++ b/tests/test_golden_parity_format2.py @@ -0,0 +1,112 @@ +"""Cross-language golden parity for hash format 2 (ITL-898). + +Every expected hash in ``tests/golden/format2_v0.5.json`` was generated by +``cargo run --bin emit_golden_format2`` in the Rust starfix crate and is the authoritative +source of truth; the file is a byte-for-byte copy and is never edited here. Every vector +and every relation is checked. The only skips are version-gated: vectors the installed +pyarrow cannot decode (see ``_pyarrow_compat``); CI runs a pyarrow that decodes all. +""" + +from __future__ import annotations + +import base64 +import io +import itertools +import json +from functools import cache +from pathlib import Path +from typing import Any + +import pyarrow as pa +import pytest +from _pyarrow_compat import UNREADABLE_HERE + +from starfix import ArrowDigester + +_FIXTURE_PATH = Path(__file__).parent / "golden" / "format2_v0.5.json" +_OPTIONS = ("ordered_columns", "ordered_struct_fields") + + +@cache +def _fixture() -> dict[str, Any]: + with _FIXTURE_PATH.open(encoding="utf-8") as f: + return json.load(f) + + +def _vectors() -> list[dict[str, Any]]: + return _fixture()["vectors"] + + +def _relations() -> list[dict[str, Any]]: + return _fixture()["relations"] + + +def _hash(vector: dict[str, Any]) -> str: + vid = vector["id"] + reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))) + schema, batches = reader.schema, list(reader) + options = {name: vector[name] for name in _OPTIONS} + include_metadata: bool = vector["include_metadata"] + method = vector["method"] + if method == "hash_schema": + result = ArrowDigester.hash_schema(schema, include_metadata=include_metadata, **options) + elif method == "hash_record_batch": + assert len(batches) == 1, f"Vector '{vid}': hash_record_batch needs exactly one batch" + result = ArrowDigester.hash_record_batch(batches[0], include_metadata=include_metadata, **options) + elif method == "hash_stream": + digester = ArrowDigester(schema, include_metadata=include_metadata, **options) + for batch in batches: + digester.update(batch) + result = digester.finalize() + elif method == "hash_array": + assert len(batches) == 1 and batches[0].num_columns == 1, f"Vector '{vid}': hash_array needs one column" + result = ArrowDigester.hash_array(batches[0].column(0), **options) + else: + pytest.fail(f"Vector '{vid}': unknown method '{method}'") + return result.hex() + + +def _skip_if_unreadable(*ids: str) -> None: + unreadable = [i for i in ids if i in UNREADABLE_HERE] + if unreadable: + pytest.skip(f"{unreadable}: {UNREADABLE_HERE[unreadable[0]]}") + + +def test_fixture_is_well_formed() -> None: + fixture = _fixture() + assert fixture["format"] == 2 + ids = [v["id"] for v in _vectors()] + assert ids and len(ids) == len(set(ids)), "vector ids must be unique" + for v in _vectors(): + assert v["expected_hash"].startswith("000002"), v["id"] + missing = [k for k in (*_OPTIONS, "include_metadata") if k not in v] + assert not missing, f"{v['id']} lacks {missing}" + for rel in _relations(): + assert rel["kind"] in ("equal", "different") + assert len(rel["ids"]) >= 2 and set(rel["ids"]) <= set(ids), rel["ids"] + + +@pytest.mark.parametrize("vector", _vectors(), ids=lambda v: v["id"]) +def test_golden_vector(vector: dict[str, Any]) -> None: + _skip_if_unreadable(vector["id"]) + got = _hash(vector) + assert got == vector["expected_hash"], ( + f"Vector '{vector['id']}' mismatch: {vector['description']}\n" + f" got: {got}\n expected: {vector['expected_hash']}" + ) + + +@pytest.mark.parametrize("relation", _relations(), ids=lambda r: f"{r['kind']}:{'|'.join(r['ids'])}") +def test_golden_relation(relation: dict[str, Any]) -> None: + """Each relation holds for the pinned values and for the live Python hashes.""" + _skip_if_unreadable(*relation["ids"]) + by_id = {v["id"]: v for v in _vectors()} + ids = relation["ids"] + pinned = {i: by_id[i]["expected_hash"] for i in ids} + live = {i: _hash(by_id[i]) for i in ids} + for label, hashes in (("pinned", pinned), ("live", live)): + if relation["kind"] == "equal": + assert len(set(hashes.values())) == 1, f"relation equal {ids} fails on {label}: {hashes}" + else: + for a, b in itertools.combinations(ids, 2): + assert hashes[a] != hashes[b], f"relation different {ids} fails on {label}: {a} == {b}" diff --git a/tests/test_golden_parity_metadata.py b/tests/test_golden_parity_metadata.py deleted file mode 100644 index 008a1d9..0000000 --- a/tests/test_golden_parity_metadata.py +++ /dev/null @@ -1,127 +0,0 @@ -"""Cross-language golden-hash parity tests for include_metadata vectors (PLT-1735). - -Every expected hash in `tests/golden/include_metadata_v0.3.json` was generated by -`cargo run --bin emit_golden_metadata` in the Rust starfix crate and is treated as -the authoritative source of truth. These tests will fail immediately if the Python -implementation diverges from Rust. - -Covers 9 vectors: - - no_metadata_include_false (regression: same as v0.1.0 schema hash) - - schema_level_metadata (schema-level metadata, include_metadata=True) - - field_metadata_single_field (single field with metadata, include_metadata=True) - - field_metadata_multiple_fields (two fields with metadata, include_metadata=True) - - schema_and_field_metadata (both schema- and field-level, include_metadata=True) - - unicode_metadata (emoji + CJK keys/values, include_metadata=True) - - key_reorder_canonical (metadata keys in alphabetical order) - - key_reorder_shuffled (same keys, different insertion order — same hash) - - empty_metadata_invariant (no metadata — hash must be same for both flag values) -""" -from __future__ import annotations - -import base64 -import io -import json -from pathlib import Path -from typing import Any - -import pyarrow as pa -import pytest - -from starfix.arrow_digester import ArrowDigester - -_FIXTURE_PATH = Path(__file__).parent / "golden" / "include_metadata_v0.3.json" - - -def _load_vectors() -> list[dict[str, Any]]: - with _FIXTURE_PATH.open(encoding="utf-8") as f: - return json.load(f)["vectors"] - - -def _get_vector(vector_id: str) -> dict[str, Any]: - for v in _load_vectors(): - if v["id"] == vector_id: - return v - raise KeyError(f"Vector '{vector_id}' not found in fixture") - - -def _deserialize_ipc(ipc_b64: str) -> tuple[pa.Schema, pa.RecordBatch | None]: - raw = base64.b64decode(ipc_b64) - reader = pa.ipc.open_stream(io.BytesIO(raw)) - schema = reader.schema - batches = list(reader) - batch = batches[0] if batches else None - return schema, batch - - -@pytest.mark.parametrize("vector", _load_vectors(), ids=lambda v: v["id"]) -def test_golden_vector(vector: dict[str, Any]) -> None: - """Each vector must produce the Rust-authoritative expected_hash.""" - schema, batch = _deserialize_ipc(vector["ipc_b64"]) - include_metadata: bool = vector["include_metadata"] - - if vector["method"] == "hash_schema": - result = ArrowDigester.hash_schema(schema, include_metadata=include_metadata) - elif vector["method"] == "hash_record_batch": - assert batch is not None, ( - f"Vector '{vector['id']}': method is hash_record_batch but IPC has no batch" - ) - result = ArrowDigester.hash_record_batch(batch, include_metadata=include_metadata) - else: - pytest.fail(f"Vector '{vector['id']}': unknown method '{vector['method']}'") - - assert result.hex() == vector["expected_hash"], ( - f"Vector '{vector['id']}' mismatch: {vector['description']}\n" - f" got: {result.hex()}\n" - f" expected: {vector['expected_hash']}" - ) - - -def test_empty_metadata_invariant_both_flags() -> None: - """Empty-metadata invariant: include_metadata=True must produce the same hash as False.""" - vector = _get_vector("empty_metadata_invariant") - schema, _ = _deserialize_ipc(vector["ipc_b64"]) - - hash_false = ArrowDigester.hash_schema(schema, include_metadata=False).hex() - hash_true = ArrowDigester.hash_schema(schema, include_metadata=True).hex() - - assert hash_false == vector["expected_hash"], ( - f"empty_metadata_invariant: include_metadata=False got {hash_false}, " - f"expected {vector['expected_hash']}" - ) - assert hash_true == vector["expected_hash"], ( - f"empty_metadata_invariant: include_metadata=True got {hash_true}, " - f"expected {vector['expected_hash']}" - ) - assert hash_false == hash_true, ( - "empty_metadata_invariant: both flag values must produce the same hash" - ) - - -def test_key_reorder_hashes_are_identical() -> None: - """key_reorder_canonical and key_reorder_shuffled encode to identical IPC bytes. - - arrow-ipc normalises metadata key order (alphabetical sort) before FlatBuffers - encoding, so both vectors produce byte-identical blobs regardless of insertion - order. This test asserts those fixture invariants explicitly, then hashes once - as a live sanity check — re-hashing both would just hash the same bytes twice. - """ - canonical = _get_vector("key_reorder_canonical") - shuffled = _get_vector("key_reorder_shuffled") - - # Fixture invariants: arrow-ipc sorts keys before encoding, so both entries - # must carry the same IPC blob and the same expected hash. - assert canonical["ipc_b64"] == shuffled["ipc_b64"], ( - "key_reorder_canonical and key_reorder_shuffled must have identical ipc_b64 " - "(arrow-ipc normalises metadata key order before FlatBuffers encoding)" - ) - assert canonical["expected_hash"] == shuffled["expected_hash"], ( - "key_reorder_canonical and key_reorder_shuffled must have identical expected_hash" - ) - - # Sanity check: live hash must match the (single) fixture value. - schema, _ = _deserialize_ipc(canonical["ipc_b64"]) - live_hash = ArrowDigester.hash_schema(schema, include_metadata=True).hex() - assert live_hash == canonical["expected_hash"], ( - f"key_reorder live hash drifted from fixture: " - f"got {live_hash}, expected {canonical['expected_hash']}" - ) diff --git a/tests/test_golden_parity_ordered.py b/tests/test_golden_parity_ordered.py deleted file mode 100644 index 54181f4..0000000 --- a/tests/test_golden_parity_ordered.py +++ /dev/null @@ -1,186 +0,0 @@ -"""Cross-language golden-hash parity tests for the v0.5 hashing options (ITL-898). - -Every expected hash in ``tests/golden/ordered_v0.5.json`` was generated by -``cargo run --bin emit_golden_ordered`` in the Rust starfix crate and is the -authoritative source of truth. The file is a byte-for-byte copy and is never edited -here. Every vector and every relation is checked; nothing is skipped. - -Vector methods (IPC stream decoded with ``pyarrow.ipc.open_stream``): - -* ``hash_schema`` the stream's schema -* ``hash_record_batch`` exactly one batch -* ``hash_stream`` ``ArrowDigester(schema)``, ``update`` per batch in stream order, ``finalize`` -* ``hash_array`` exactly one batch with exactly one column; that column's array -""" - -from __future__ import annotations - -import base64 -import io -import itertools -import json -from functools import cache -from pathlib import Path -from typing import Any - -import pyarrow as pa -import pytest -from _pyarrow_compat import UNREADABLE_HERE as _UNREADABLE_HERE - -from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester - -_FIXTURE_PATH = Path(__file__).parent / "golden" / "ordered_v0.5.json" - - -@cache -def _fixture() -> dict[str, Any]: - with _FIXTURE_PATH.open(encoding="utf-8") as f: - return json.load(f) - - -def _vectors() -> list[dict[str, Any]]: - return _fixture()["vectors"] - - -def _relations() -> list[dict[str, Any]]: - return _fixture()["relations"] - - -def _options(vector: dict[str, Any]) -> dict[str, bool]: - """The vector's option values, keyed by the Python keyword names.""" - missing = [name for name in _OPTION_FLAGS if name not in vector] - assert not missing, f"Vector '{vector['id']}' has no value for option(s) {missing}" - return {name: vector[name] for name in _OPTION_FLAGS} - - -def _read_ipc(ipc_b64: str) -> tuple[pa.Schema, list[pa.RecordBatch]]: - reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(ipc_b64))) - return reader.schema, list(reader) - - -def _hash(vector: dict[str, Any]) -> str: - vid = vector["id"] - schema, batches = _read_ipc(vector["ipc_b64"]) - options = _options(vector) - include_metadata: bool = vector["include_metadata"] - method = vector["method"] - - if method == "hash_schema": - result = ArrowDigester.hash_schema(schema, include_metadata=include_metadata, **options) - elif method == "hash_record_batch": - assert len(batches) == 1, f"Vector '{vid}': hash_record_batch needs exactly one batch" - result = ArrowDigester.hash_record_batch(batches[0], include_metadata=include_metadata, **options) - elif method == "hash_stream": - digester = ArrowDigester(schema, include_metadata=include_metadata, **options) - for batch in batches: - digester.update(batch) - result = digester.finalize() - elif method == "hash_array": - assert len(batches) == 1 and batches[0].num_columns == 1, ( - f"Vector '{vid}': hash_array needs exactly one batch with one column" - ) - result = ArrowDigester.hash_array(batches[0].column(0), **options) - else: - pytest.fail(f"Vector '{vid}': unknown method '{method}'") - return result.hex() - - -def test_fixture_is_well_formed() -> None: - vectors = _vectors() - assert vectors, "golden file has no vectors" - ids = [v["id"] for v in vectors] - duplicates = sorted({i for i in ids if ids.count(i) > 1}) - assert not duplicates, f"duplicate vector ids: {duplicates}" - known = set(ids) - for rel in _relations(): - assert rel["kind"] in ("equal", "different"), f"unknown relation kind {rel['kind']!r}" - assert len(rel["ids"]) >= 2, f"relation {rel['ids']} names fewer than two vectors" - unknown = [i for i in rel["ids"] if i not in known] - assert not unknown, f"relation {rel['ids']} names unknown vector ids {unknown}" - - -# Default-mode (no options) vectors on which starfix-python's released output differs -# from Rust. Changing default output moves released hashes; that is the developer's -# decision (see tests/test_known_divergences.py). strict=True: these turn into hard -# failures once the default output is fixed, so the entry must then be removed. -_KNOWN_DEFAULT_MODE_DIVERGENCES = { - "map_struct_ab_schema_f0": "default Map JSON omits the value type (known divergence)", - "map_struct_ba_schema_f0": "default Map JSON omits the value type (known divergence)", - "names_array_struct_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", - "names_array_struct_int8_f0": "default hash_array type JSON escapes non-ASCII (known divergence)", - # Types the historical serializer rejects (NotImplementedError); options on: supported. - "type_null_schema_f0": "default schema hashing rejects Null (known divergence)", - "type_interval_year_month_schema_f0": "default schema hashing rejects Interval (known divergence)", - "type_interval_day_time_schema_f0": "default schema hashing rejects Interval (known divergence)", - "type_interval_month_day_nano_schema_f0": "default schema hashing rejects Interval (known divergence)", - "type_utf8_view_schema_f0": "default schema hashing rejects Utf8View (known divergence)", - "type_binary_view_schema_f0": "default schema hashing rejects BinaryView (known divergence)", - # Default Phase 2 map paths: value metadata at "m/", key skipped (Rust: entries/key/value). - "meta_map_value_schema_f0_im1": "default Map metadata paths (known divergence)", - "meta_map_key_schema_f0_im1": "default Map metadata paths (known divergence)", - "meta_map_entries_schema_f0_im1": "default Map metadata paths (known divergence)", - "meta_map_all_schema_f0_im1": "default Map metadata paths (known divergence)", -} - -# Vectors that no pyarrow-based implementation can reproduce: pyarrow drops the metadata -# of a map's entries field when it reads an IPC stream (key and value metadata survive), -# so the input Rust hashed is not visible to Python. Pending a decision in the Rust spec. -_PYARROW_UNREPRESENTABLE = { - "meta_map_entries_schema_f1_im1": "pyarrow drops map entries-field metadata on IPC read", - "meta_map_all_schema_f1_im1": "pyarrow drops map entries-field metadata on IPC read", -} - -_XFAIL_VECTORS = {**_KNOWN_DEFAULT_MODE_DIVERGENCES, **_PYARROW_UNREPRESENTABLE, **_UNREADABLE_HERE} - - -def _vector_params() -> list[Any]: - params = [] - for v in _vectors(): - reason = _XFAIL_VECTORS.get(v["id"]) - marks = [pytest.mark.xfail(strict=True, reason=reason)] if reason else [] - params.append(pytest.param(v, id=v["id"], marks=marks)) - return params - - -def test_known_divergences_are_default_mode_vectors() -> None: - by_id = {v["id"]: v for v in _vectors()} - for vid in _KNOWN_DEFAULT_MODE_DIVERGENCES: - assert vid in by_id, f"known divergence '{vid}' is not in the golden file" - assert not any(_options(by_id[vid]).values()), f"'{vid}' is not a default-mode vector" - - -@pytest.mark.parametrize("vector", _vector_params()) -def test_golden_vector(vector: dict[str, Any]) -> None: - """Each vector must produce the Rust-authoritative expected_hash.""" - got = _hash(vector) - assert got == vector["expected_hash"], ( - f"Vector '{vector['id']}' mismatch: {vector['description']}\n" - f" got: {got}\n" - f" expected: {vector['expected_hash']}" - ) - - -@pytest.mark.parametrize( - "relation", _relations(), ids=lambda r: f"{r['kind']}:{'|'.join(r['ids'])}" -) -def test_golden_relation(relation: dict[str, Any]) -> None: - """Each relation holds for the pinned values and for the live Python hashes. - - Live hashes are compared over the relation's vectors that Python reproduces; the - others (``_XFAIL_VECTORS``) are each covered by their own strict xfail above. - """ - by_id = {v["id"]: v for v in _vectors()} - ids = relation["ids"] - pinned = {i: by_id[i]["expected_hash"] for i in ids} - live = {i: _hash(by_id[i]) for i in ids if i not in _XFAIL_VECTORS} - for label, hashes in (("pinned", pinned), ("live", live)): - if relation["kind"] == "equal": - assert len(set(hashes.values())) <= 1, ( - f"relation equal {ids} fails on {label} hashes: {hashes} ({relation.get('why', '')})" - ) - else: - for a, b in itertools.combinations(list(hashes), 2): - assert hashes[a] != hashes[b], ( - f"relation different {ids} fails on {label} hashes: '{a}' == '{b}' " - f"({relation.get('why', '')})" - ) diff --git a/tests/test_known_divergences.py b/tests/test_known_divergences.py deleted file mode 100644 index 07c4989..0000000 --- a/tests/test_known_divergences.py +++ /dev/null @@ -1,187 +0,0 @@ -"""Known default-mode divergences from the Rust starfix implementation (ITL-898). - -Each test asserts the Rust value and is marked ``xfail(strict=True)``: it fails today -because starfix-python's released default-mode (no options) output differs from Rust, -and it turns into a hard failure the day the default output is changed to match, so the -marker must then be removed deliberately. Changing a default-mode output moves released -hashes and is the developer's decision; it is not done in ITL-898. - -With any hashing option on (``flags != 0``) Python already uses the Rust form for the -two JSON cases and checks every streamed batch, and the golden vectors in -``tests/golden/ordered_v0.5.json`` pin that. -""" - -from __future__ import annotations - -import base64 -import hashlib -import io -import json -from pathlib import Path - -import pyarrow as pa -import pytest -from _pyarrow_compat import UNREADABLE_HERE - -from starfix.arrow_digester import ArrowDigester - -_GOLDEN = Path(__file__).parent / "golden" / "ordered_v0.5.json" - - -def _golden_vector(vector_id: str) -> dict: - with _GOLDEN.open(encoding="utf-8") as f: - return next(v for v in json.load(f)["vectors"] if v["id"] == vector_id) - - -@pytest.mark.xfail( - strict=True, - reason=( - "Default Map JSON omits the map's value type and keys_sorted: Python emits " - '{"Map":[{"data_type":,"name":"entries","nullable":false},false]}, ' - "Rust emits the entries field (Struct[key, value]) and keys_sorted" - ), -) -@pytest.mark.parametrize("vector_id", ["map_struct_ab_schema_f0", "map_struct_ba_schema_f0"]) -def test_default_map_schema_matches_rust(vector_id: str) -> None: - vector = _golden_vector(vector_id) - schema = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))).schema - assert ArrowDigester.hash_schema(schema).hex() == vector["expected_hash"] - - -def test_default_map_schema_ignores_value_type_today() -> None: - """Documents the consequence: the default schema hash ignores a map's value type.""" - a = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.int8()))]) - b = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.struct([pa.field("x", pa.int64())])))]) - assert ArrowDigester.hash_schema(a) == ArrowDigester.hash_schema(b) - assert ArrowDigester.hash_schema(a, ordered_struct_fields=True) != ArrowDigester.hash_schema( - b, ordered_struct_fields=True - ) - - -@pytest.mark.xfail( - strict=True, - reason="Default hash_array type JSON escapes non-ASCII (\\u00e9); Rust writes raw UTF-8", -) -@pytest.mark.parametrize("vector_id", ["names_array_struct_f0", "names_array_struct_int8_f0"]) -def test_default_hash_array_non_ascii_name_matches_rust(vector_id: str) -> None: - vector = _golden_vector(vector_id) - batch = next(iter(pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))))) - assert ArrowDigester.hash_array(batch.column(0)).hex() == vector["expected_hash"] - - -# Spec Section 2.1 Map example (literal JSON and hash from the spec text). -_SPEC_MAP_JSON = ( - '{"m":{"data_type":{"Map":[{"data_type":{"Struct":[{"data_type":"LargeUtf8","name":"key",' - '"nullable":false},{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":false},' - '{"data_type":"Int32","name":"z","nullable":false}]},"name":"value","nullable":true}]},' - '"name":"entries","nullable":false},false]},"nullable":true}}' -) -_SPEC_MAP_HASH = "000001edad0efdc8086afa34e6633ee4213d2ed803cbd8849e7d062f882f698bdcf897" - - -def _spec_map_schema() -> pa.Schema: - value = pa.struct([pa.field("z", pa.int32(), nullable=False), pa.field("a", pa.int32(), nullable=False)]) - return pa.schema([pa.field("m", pa.map_(pa.utf8(), value), nullable=True)]) - - -def test_spec_map_example_is_self_consistent() -> None: - assert "000001" + hashlib.sha256(_SPEC_MAP_JSON.encode()).hexdigest() == _SPEC_MAP_HASH - - -@pytest.mark.xfail(strict=True, reason="Default Map JSON differs from the spec Section 2.1 form") -def test_default_map_spec_example() -> None: - assert ArrowDigester.hash_schema(_spec_map_schema()).hex() == _SPEC_MAP_HASH - - -def test_map_spec_form_used_with_options() -> None: - """With any option on, Phase 1 uses the spec Section 2.1 Map form (here under the tag).""" - tag = b"\x00starfix-options-v1\x04" - expected = "000001" + hashlib.sha256(tag + _SPEC_MAP_JSON.encode()).hexdigest() - assert ArrowDigester.hash_schema(_spec_map_schema(), nested_validity=True).hex() == expected - - -# Spec Section 9.7: with flags == 0, Rust also checks every batch (Phase 1 JSON equality, -# plus the Phase 2 document with include_metadata). Python has never checked at flags == 0. - - -@pytest.mark.xfail(strict=True, reason="Python does not check batches against the schema with no options") -def test_default_update_rejects_mismatched_batch() -> None: - d = ArrowDigester(pa.schema([pa.field("a", pa.int32())])) - with pytest.raises(ValueError): - d.update(pa.record_batch([pa.array([1], pa.int64())], names=["a"])) - - -@pytest.mark.xfail(strict=True, reason="Python does not check batches against the schema with no options") -def test_default_update_rejects_metadata_mismatch_with_include_metadata() -> None: - d = ArrowDigester(pa.schema([pa.field("a", pa.int32())]), include_metadata=True) - other = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) - with pytest.raises(ValueError): - d.update(pa.record_batch([pa.array([1], pa.int32())], schema=other)) - - -# ── Each pending default-mode fix is one switch: flipping it reproduces Rust ── - - -def _schema_of(vector: dict) -> pa.Schema: - return pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))).schema - - -@pytest.mark.parametrize( - "switches, vector_ids", - [ - (["_FIX_DEFAULT_MAP_JSON"], ["map_struct_ab_schema_f0", "map_struct_ba_schema_f0"]), - ( - ["_FIX_DEFAULT_TYPE_FORMS"], - [ - "type_null_schema_f0", - "type_interval_year_month_schema_f0", - "type_interval_day_time_schema_f0", - "type_interval_month_day_nano_schema_f0", - "type_utf8_view_schema_f0", - "type_binary_view_schema_f0", - ], - ), - ( - # Map metadata vectors also carry a Map schema, so both map switches apply. - ["_FIX_DEFAULT_MAP_JSON", "_FIX_DEFAULT_MAP_METADATA_PATHS"], - ["meta_map_value_schema_f0_im1", "meta_map_key_schema_f0_im1"], - ), - ], -) -def test_flipping_switch_matches_rust_hash_schema(switches, vector_ids, monkeypatch) -> None: - import starfix.arrow_digester as ad - - for name in switches: - monkeypatch.setattr(ad, name, True) - for vid in vector_ids: - if vid in UNREADABLE_HERE: - continue # this pyarrow cannot decode the vector (see _pyarrow_compat) - vector = _golden_vector(vid) - got = ArrowDigester.hash_schema(_schema_of(vector), include_metadata=vector["include_metadata"]) - assert got.hex() == vector["expected_hash"], vid - - -def test_flipping_type_json_switch_matches_rust_hash_array(monkeypatch) -> None: - import starfix.arrow_digester as ad - - monkeypatch.setattr(ad, "_FIX_DEFAULT_TYPE_JSON_UTF8", True) - for vid in ("names_array_struct_f0", "names_array_struct_int8_f0"): - vector = _golden_vector(vid) - batch = next(iter(pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))))) - assert ArrowDigester.hash_array(batch.column(0)).hex() == vector["expected_hash"], vid - - -def test_flipping_batch_check_switch_rejects_mismatched_batches(monkeypatch) -> None: - import starfix.arrow_digester as ad - - monkeypatch.setattr(ad, "_FIX_DEFAULT_BATCH_CHECK", True) - d = ArrowDigester(pa.schema([pa.field("a", pa.int32())])) - with pytest.raises(ValueError, match="does not match"): - d.update(pa.record_batch([pa.array([1], pa.int64())], names=["a"])) - d = ArrowDigester(pa.schema([pa.field("a", pa.int32())]), include_metadata=True) - other = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) - with pytest.raises(ValueError, match="does not match"): - d.update(pa.record_batch([pa.array([1], pa.int32())], schema=other)) - # physically equivalent batches stay accepted - d = ArrowDigester(pa.schema([pa.field("s", pa.utf8())])) - d.update(pa.record_batch([pa.array(["x"], pa.large_utf8())], names=["s"])) diff --git a/tests/test_lossless_fix_scope.py b/tests/test_lossless_fix_scope.py deleted file mode 100644 index e402e30..0000000 --- a/tests/test_lossless_fix_scope.py +++ /dev/null @@ -1,122 +0,0 @@ -"""Scope of the lossless-layout fix (ITL-898 developer ruling, 2026-11-11). - -The lossless layout (byte-layout spec 9.5 / 9.5.1) becomes the default. Under variant (a) -(version prefix unchanged) hashes of *unaffected* inputs must stay byte-identical. Rule: - - a type is AFFECTED iff it contains a Boolean, a nullable struct, or a list whose - element is a nullable list or a nullable struct (dictionaries are looked through). - -``hash_schema`` is never affected (the layout only changes data entries). For -``hash_array`` the root counts as nullable iff the array contains a null. - -"Affected" is a property of the type: some values of an affected type hash the same in -both layouts (for example a single Boolean value packs to the same byte). -""" - -from __future__ import annotations - -import base64 -import io -import json -from pathlib import Path -from typing import Any - -import pyarrow as pa -import pytest -from _pyarrow_compat import UNREADABLE_HERE - -import starfix.arrow_digester as ad -from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester - -_GOLDEN_DIR = Path(__file__).parent / "golden" - - -def _strip_dictionary(t: pa.DataType) -> pa.DataType: - while pa.types.is_dictionary(t): - t = t.value_type - return t - - -def affected(t: pa.DataType, nullable: bool) -> bool: - t = _strip_dictionary(t) - if pa.types.is_boolean(t): - return True - if pa.types.is_struct(t): - return nullable or any(affected(t.field(i).type, t.field(i).nullable) for i in range(t.num_fields)) - if pa.types.is_list(t) or pa.types.is_large_list(t): - element = t.value_field - et = _strip_dictionary(element.type) - if element.nullable and (pa.types.is_struct(et) or pa.types.is_list(et) or pa.types.is_large_list(et)): - return True - return affected(element.type, element.nullable) - return False - - -def _vectors() -> list[dict[str, Any]]: - out = [] - for path in sorted(_GOLDEN_DIR.glob("*.json")): - with path.open(encoding="utf-8") as f: - for v in json.load(f)["vectors"]: - # Only vectors without the (retired) third flag describe the default layout. - if v["id"] in UNREADABLE_HERE: - continue # this pyarrow cannot decode the vector (see _pyarrow_compat) - if not v.get("nested_validity", False): - out.append({**v, "_file": path.name}) - return out - - -def _hash(vector: dict[str, Any]) -> str: - reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))) - schema, batches = reader.schema, list(reader) - options = {k: vector.get(k, False) for k in _OPTION_FLAGS if k != "nested_validity"} - method = vector["method"] - if method == "hash_schema": - return ArrowDigester.hash_schema(schema, include_metadata=vector["include_metadata"], **options).hex() - if method == "hash_array": - return ArrowDigester.hash_array(batches[0].column(0), **options).hex() - d = ArrowDigester(schema, include_metadata=vector["include_metadata"], **options) - for b in batches: - d.update(b) - return d.finalize().hex() - - -def _is_affected(vector: dict[str, Any]) -> bool: - if vector["method"] == "hash_schema": - return False - reader = pa.ipc.open_stream(io.BytesIO(base64.b64decode(vector["ipc_b64"]))) - if vector["method"] == "hash_array": - arr = next(iter(reader)).column(0) - return affected(arr.type, arr.null_count > 0) - return any(affected(f.type, f.nullable) for f in reader.schema) - - -@pytest.mark.parametrize("vector", _vectors(), ids=lambda v: f"{v['_file']}:{v['id']}") -def test_unaffected_inputs_hash_identically_under_lossless_layout(vector, monkeypatch) -> None: - if _is_affected(vector): - return # affected inputs may move; their new values are pinned by the Rust golden file - try: - before = _hash(vector) - except NotImplementedError: - return # types the default serializer rejects (see test_known_divergences.py) - monkeypatch.setattr(ad, "_LOSSLESS_BY_DEFAULT", True) - assert _hash(vector) == before, f"unaffected vector {vector['id']} moved under the lossless layout" - - -@pytest.mark.parametrize( - "dt, nullable, expected", - [ - (pa.int32(), True, False), - (pa.bool_(), False, True), - (pa.dictionary(pa.int8(), pa.utf8()), True, False), - (pa.struct([pa.field("a", pa.int32())]), False, False), - (pa.struct([pa.field("a", pa.int32())]), True, True), - (pa.struct([pa.field("s", pa.struct([pa.field("a", pa.int8())]), nullable=True)]), False, True), - (pa.list_(pa.field("item", pa.int32(), nullable=True)), True, False), - (pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=True)), False, True), - (pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=False)), True, False), - (pa.list_(pa.field("item", pa.struct([pa.field("a", pa.int8())]), nullable=True)), False, True), - (pa.list_(pa.field("item", pa.struct([pa.field("a", pa.int8())]), nullable=False)), True, False), - ], -) -def test_affected_rule(dt, nullable, expected) -> None: - assert affected(dt, nullable) is expected diff --git a/tests/test_metadata_hashing.py b/tests/test_metadata_hashing.py index 8383fe8..bec5d48 100644 --- a/tests/test_metadata_hashing.py +++ b/tests/test_metadata_hashing.py @@ -1,7 +1,7 @@ """Tests for include_metadata hashing option (PLT-1734). Verifies that: -- include_metadata=False (default) ignores all Arrow metadata (hash format 0.0.1 stability) +- include_metadata=False (default) ignores all Arrow metadata - include_metadata=True detects changes to schema-level and field-level metadata - Hashes are deterministic regardless of metadata key insertion order - Empty-metadata invariant: no metadata → same hash regardless of include_metadata @@ -10,88 +10,7 @@ import pyarrow as pa import pytest -from starfix.arrow_digester import ( - ArrowDigester, - _collect_nested_field_metadata, - _sort_metadata, -) - - -class TestSortMetadata: - def test_sorts_by_key(self): - meta = {b"z": b"1", b"a": b"2", b"m": b"3"} - result = _sort_metadata(meta) - assert list(result.keys()) == ["a", "m", "z"] - - def test_decodes_bytes_to_utf8(self): - meta = {b"key": b"value"} - result = _sort_metadata(meta) - assert result == {"key": "value"} - assert isinstance(list(result.keys())[0], str) - - def test_none_returns_empty_dict(self): - assert _sort_metadata(None) == {} - - def test_empty_dict_returns_empty_dict(self): - assert _sort_metadata({}) == {} - - -class TestCollectNestedFieldMetadata: - def test_top_level_field_with_metadata(self): - field = pa.field("x", pa.int32(), metadata={b"unit": b"kg"}) - result = _collect_nested_field_metadata(field, "x") - assert result == {"x": {"unit": "kg"}} - - def test_field_without_metadata_not_included(self): - field = pa.field("x", pa.int32()) - result = _collect_nested_field_metadata(field, "x") - assert result == {} - - def test_struct_child_metadata_uses_slash_separator(self): - child = pa.field("age", pa.int32(), metadata={b"unit": b"years"}) - parent = pa.field("person", pa.struct([child])) - result = _collect_nested_field_metadata(parent, "person") - assert result == {"person/age": {"unit": "years"}} - - def test_list_element_field_uses_trailing_slash(self): - element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) - list_field = pa.field("items", pa.large_list(element)) - result = _collect_nested_field_metadata(list_field, "items") - assert result == {"items/": {"unit": "count"}} - - def test_regular_list_element_field_also_uses_trailing_slash(self): - element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) - list_field = pa.field("items", pa.list_(element)) - result = _collect_nested_field_metadata(list_field, "items") - assert result == {"items/": {"unit": "count"}} - - def test_parent_field_and_child_both_with_metadata(self): - child = pa.field("age", pa.int32(), metadata={b"unit": b"years"}) - parent = pa.field("person", pa.struct([child]), metadata={b"source": b"census"}) - result = _collect_nested_field_metadata(parent, "person") - assert result == { - "person": {"source": "census"}, - "person/age": {"unit": "years"}, - } - - def test_result_is_sorted_by_path(self): - child_z = pa.field("z", pa.int32(), metadata={b"k": b"v"}) - child_a = pa.field("a", pa.int32(), metadata={b"k": b"v"}) - parent = pa.field("s", pa.struct([child_z, child_a])) - result = _collect_nested_field_metadata(parent, "s") - assert list(result.keys()) == ["s/a", "s/z"] - - def test_map_item_field_metadata_uses_trailing_slash(self): - item = pa.field("value", pa.int32(), metadata={b"unit": b"cents"}) - map_field = pa.field("m", pa.map_(pa.utf8(), item)) - result = _collect_nested_field_metadata(map_field, "m") - assert result == {"m/": {"unit": "cents"}} - - def test_fixed_size_list_element_uses_trailing_slash(self): - element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) - list_field = pa.field("items", pa.list_(element, 3)) - result = _collect_nested_field_metadata(list_field, "items") - assert result == {"items/": {"unit": "count"}} +from starfix.arrow_digester import ArrowDigester class TestEmptyMetadataInvariant: @@ -193,8 +112,8 @@ def test_schema_metadata_ignored_by_default(self): ) assert ArrowDigester.hash_schema(schema_plain) == ArrowDigester.hash_schema(schema_meta) - def test_default_matches_hash_format_001_golden_value(self): - """Batch with metadata + include_metadata=False must match the hash format 0.0.1 + def test_default_matches_pinned_golden_value(self): + """Batch with metadata + include_metadata=False must match the pinned golden value from test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table.""" schema = pa.schema([ pa.field("age", pa.int32(), nullable=False, metadata={b"unit": b"years"}), diff --git a/tests/test_ordered_hashing.py b/tests/test_ordered_hashing.py deleted file mode 100644 index 90c1d5c..0000000 --- a/tests/test_ordered_hashing.py +++ /dev/null @@ -1,839 +0,0 @@ -"""Tests for the v0.5 hashing options (ITL-898). - -Spec: ``nauticalab/starfix docs/byte-layout-spec.md`` Section 9. - -* ``ordered_columns`` (flag 0x01): top-level column order is part of the hash. -* ``ordered_struct_fields`` (flag 0x02): struct field order is part of the hash, at every depth. -* ``nested_validity`` (flag 0x04): nullable nested values record their own validity. - -The worked examples (spec Section 9.9) are checked byte for byte: the expected value is built -here from the exact SHA-256 inputs the spec lists, never from the implementation under test. -Cross-language values are pinned separately by ``tests/test_golden_parity_ordered.py``. -""" - -from __future__ import annotations - -import hashlib -import itertools -import struct - -import pyarrow as pa -import pytest - -from starfix.arrow_digester import _OPTION_FLAGS, ArrowDigester - -# Option keyword names. A rename of an option is a one-line change here. -OC = "ordered_columns" -OSF = "ordered_struct_fields" -NV = "nested_validity" - -ALL_FLAGS = range(8) - - -def opts(flags: int) -> dict[str, bool]: - """Keyword arguments for a flags byte (spec Section 9.1).""" - return {name: bool(flags & bit) for name, bit in _OPTION_FLAGS.items()} - - -def tag(flags: int) -> bytes: - """Options tag of spec Section 9.2, written out literally.""" - return bytes.fromhex("0073746172666978 2d6f7074696f6e73 2d7631".replace(" ", "")) + bytes([flags]) - - -def sha(*parts: bytes) -> bytes: - h = hashlib.sha256() - for p in parts: - h.update(p) - return h.digest() - - -def u64(n: int) -> bytes: - return struct.pack(" bytes: - return b"".join(struct.pack(" bytes: - return ArrowDigester.hash_record_batch(batch, **opts(flags), **kw) - - -# ── Spec Section 9.1 / 9.2: option table, tag ───────────────────────── - - -class TestOptionTable: - def test_option_names_and_bits(self): - assert _OPTION_FLAGS == {OC: 0x01, OSF: 0x02, NV: 0x04} - - def test_tag_is_twenty_bytes(self): - t = tag(0x05) - assert len(t) == 20 - assert t[0] == 0x00 - assert t[1:19] == b"starfix-options-v1" - assert t[19] == 0x05 - - -# ── Spec Section 9.9: worked examples, byte level ───────────────────── - - -class TestWorkedExamples: - def test_t1_hash_schema_ordered_columns(self): - schema = pa.schema([ - pa.field("b", pa.int32(), nullable=False), - pa.field("a", pa.utf8(), nullable=True), - ]) - json_ = ( - b'[{"data_type":"Int32","name":"b","nullable":false},' - b'{"data_type":"LargeUtf8","name":"a","nullable":true}]' - ) - expected = V + sha(tag(0x01), json_) - assert ArrowDigester.hash_schema(schema, ordered_columns=True) == expected - - def test_t2_record_batch_ordered_columns(self): - schema = pa.schema([ - pa.field("b", pa.int32(), nullable=False), - pa.field("a", pa.int32(), nullable=False), - ]) - batch = pa.record_batch( - [pa.array([5], pa.int32()), pa.array([6], pa.int32())], schema=schema - ) - schema_digest = sha( - tag(0x01), - b'[{"data_type":"Int32","name":"b","nullable":false},' - b'{"data_type":"Int32","name":"a","nullable":false}]', - ) - expected = V + sha(schema_digest, sha(i32(6)), sha(i32(5))) - assert ArrowDigester.hash_record_batch(batch, ordered_columns=True) == expected - - def test_t3_hash_array_ordered_struct_fields(self): - arr = pa.StructArray.from_arrays( - [pa.array([1], pa.int32()), pa.array([2], pa.int32())], - fields=[pa.field("z", pa.int32(), nullable=False), pa.field("a", pa.int32(), nullable=False)], - ) - expected = V + sha( - tag(0x02), - b'{"Struct":[{"data_type":"Int32","name":"z","nullable":false},' - b'{"data_type":"Int32","name":"a","nullable":false}]}', - sha(i32(2)), - sha(i32(1)), - ) - assert ArrowDigester.hash_array(arr, ordered_struct_fields=True) == expected - - def test_t4_nested_validity_nullable_struct(self): - s = pa.StructArray.from_arrays( - [pa.array([5, None, 1], pa.int32())], - fields=[pa.field("a", pa.int32(), nullable=True)], - mask=pa.array([True, False, False]), # True = null: struct validity [0, 1, 1] - ) - schema = pa.schema([pa.field("s", s.type, nullable=True)]) - batch = pa.record_batch([s], schema=schema) - schema_digest = sha( - tag(0x04), - b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":true}]},' - b'"nullable":true}}', - ) - expected = V + sha( - schema_digest, - u64(3) + b"\x06", # entry "s": validity-only, bits [0,1,1] - u64(3) + b"\x04", # entry "s/a": [1,0,1] AND [0,1,1] = [0,0,1] - sha(i32(1)), # data: only row 2 - ) - assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected - - def test_t5_nested_validity_list_of_nullable_list(self): - inner = pa.field("item", pa.int32(), nullable=True) - outer_elem = pa.field("item", pa.list_(inner), nullable=True) - col_type = pa.list_(outer_elem) - schema = pa.schema([pa.field("c", col_type, nullable=False)]) - batch = pa.record_batch([pa.array([[[1], [2]]], type=col_type)], schema=schema) - schema_digest = sha( - tag(0x04), - b'{"c":{"data_type":{"LargeList":{"data_type":{"LargeList":' - b'{"data_type":"Int32","nullable":true}},"nullable":true}},"nullable":false}}', - ) - expected = V + sha( - schema_digest, - # entry "c/": structural entry kept, null_bits = inner-list validity [1,1] - u64(2) + b"\x03", - sha(u64(2)), # outer lengths [2] - # entry "c//": list-leaf, item validity [1,1], inner lengths [1,1], data [1,2] - u64(2) + b"\x03", - sha(u64(1) + u64(1)), - sha(i32(1, 2)), - ) - assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected - - def test_t6_nested_validity_boolean_column(self): - schema = pa.schema([pa.field("b", pa.bool_(), nullable=True)]) - batch = pa.record_batch([pa.array([True, None, False])], schema=schema) - schema_digest = sha(tag(0x04), b'{"b":{"data_type":"Boolean","nullable":true}}') - expected = V + sha( - schema_digest, - u64(3) + b"\x05", # validity [1,0,1] - sha(b"\x01\x00"), # one byte per VALID value: true, false - ) - assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected - - def test_t6_nested_validity_boolean_hash_array(self): - arr = pa.array([True, False, True]) - expected = V + sha(tag(0x04), b'"Boolean"', sha(b"\x01\x00\x01")) - assert ArrowDigester.hash_array(arr, nested_validity=True) == expected - - -# ── Spec Section 9.3: Phase 1 JSON for every flags value ────────────── - - -_STRUCT_SORTED = ( - b'{"Struct":[{"data_type":"Int32","name":"x","nullable":false},' - b'{"data_type":"Boolean","name":"y","nullable":false}]}' -) -_STRUCT_DECLARED = ( - b'{"Struct":[{"data_type":"Boolean","name":"y","nullable":false},' - b'{"data_type":"Int32","name":"x","nullable":false}]}' -) - - -class TestPhase1Json: - """Spec 9.3 examples, checked as the exact bytes behind ``hash_schema``.""" - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_struct_example_every_flags_value(self, flags): - schema = pa.schema([ - pa.field("s", pa.struct([ - pa.field("y", pa.bool_(), nullable=False), - pa.field("x", pa.int32(), nullable=False), - ]), nullable=False), - ]) - dt = _STRUCT_DECLARED if flags & 0x02 else _STRUCT_SORTED - if flags & 0x01: - json_ = b'[{"data_type":' + dt + b',"name":"s","nullable":false}]' - else: - json_ = b'{"s":{"data_type":' + dt + b',"nullable":false}}' - assert ArrowDigester.hash_schema(schema, **opts(flags)) == V + sha(tag(flags), json_) - - def test_unordered_columns_with_flags_uses_object(self): - schema = pa.schema([ - pa.field("b", pa.int32(), nullable=False), - pa.field("a", pa.utf8(), nullable=True), - ]) - json_ = ( - b'{"a":{"data_type":"LargeUtf8","nullable":true},' - b'"b":{"data_type":"Int32","nullable":false}}' - ) - assert ArrowDigester.hash_schema(schema, nested_validity=True) == V + sha(tag(0x04), json_) - - def test_ordered_struct_fields_inside_list_fixed_size_list_and_dictionary(self): - st = pa.struct([pa.field("z", pa.int8(), nullable=False), pa.field("a", pa.int8(), nullable=False)]) - schema = pa.schema([ - pa.field("d", pa.dictionary(pa.int32(), pa.utf8()), nullable=True), - pa.field("f", pa.list_(pa.field("item", st, nullable=True), 2), nullable=True), - pa.field("l", pa.list_(pa.field("item", st, nullable=False)), nullable=False), - ]) - za = ( - b'{"Struct":[{"data_type":"Int8","name":"z","nullable":false},' - b'{"data_type":"Int8","name":"a","nullable":false}]}' - ) - json_ = ( - b'{"d":{"data_type":"LargeUtf8","nullable":true},' - b'"f":{"data_type":{"FixedSizeList":[{"data_type":' + za + b',"nullable":true},2]},"nullable":true},' - b'"l":{"data_type":{"LargeList":{"data_type":' + za + b',"nullable":false}},"nullable":false}}' - ) - assert ArrowDigester.hash_schema(schema, ordered_struct_fields=True) == V + sha(tag(0x02), json_) - - def test_non_ascii_names_are_raw_utf8(self): - """serde_json writes non-ASCII as raw UTF-8 (no \\u escapes).""" - st = pa.struct([pa.field("é", pa.int8(), nullable=False)]) - schema = pa.schema([pa.field("ü", st, nullable=False)]) - json_ = '[{"data_type":{"Struct":[{"data_type":"Int8","name":"é","nullable":false}]},"name":"ü","nullable":false}]' - assert ArrowDigester.hash_schema(schema, ordered_columns=True) == V + sha(tag(0x01), json_.encode()) - - def test_hash_array_type_json_non_ascii_raw_utf8(self): - arr = pa.StructArray.from_arrays( - [pa.array([1], pa.int8())], fields=[pa.field("é", pa.int8(), nullable=False)] - ) - json_ = '{"Struct":[{"data_type":"Int8","name":"é","nullable":false}]}'.encode() - expected = V + sha(tag(0x02), json_, sha(b"\x01")) - assert ArrowDigester.hash_array(arr, ordered_struct_fields=True) == expected - - def test_metadata_phase2_appended_after_tagged_phase1(self): - schema = pa.schema( - [pa.field("b", pa.int32(), nullable=False, metadata={"unit": "kg"})], - metadata={"version": "2"}, - ) - phase1 = b'[{"data_type":"Int32","name":"b","nullable":false}]' - phase2 = b'{"fields":{"b":{"unit":"kg"}},"schema":{"version":"2"}}' - got = ArrowDigester.hash_schema(schema, ordered_columns=True, include_metadata=True) - assert got == V + sha(tag(0x01), phase1, phase2) - - -class TestSpecSection2Examples: - """Literal examples added to spec Section 2.1 for ITL-898.""" - - def test_fixed_size_list_example(self): - schema = pa.schema([pa.field("f", pa.list_(pa.field("item", pa.int32(), nullable=True), 2), nullable=False)]) - json_ = b'{"f":{"data_type":{"FixedSizeList":[{"data_type":"Int32","nullable":true},2]},"nullable":false}}' - expected = "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696" - assert (V + sha(json_)).hex() == expected - assert ArrowDigester.hash_schema(schema).hex() == expected - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_json_text_rules_control_characters(self, flags): - """`ab` serializes as "a\\nb\\u001b"; '/' and U+007F stay raw.""" - schema = pa.schema([pa.field("a\nb\x1b/\x7f\"\\", pa.int8(), nullable=False)]) - name = b'"a\\nb\\u001b/\x7f\\"\\\\"' - if flags & 0x01: - json_ = b'[{"data_type":"Int8","name":' + name + b',"nullable":false}]' - else: - json_ = b"{" + name + b':{"data_type":"Int8","nullable":false}}' - prefix = tag(flags) if flags else b"" - assert ArrowDigester.hash_schema(schema, **opts(flags)) == V + sha(prefix, json_) - -class TestTypeFormsAndMetadataPathsWithOptions: - """Spec 2.1 forms of Null/Interval/view types and 2.2.1 map metadata paths (options on).""" - - @pytest.mark.parametrize( - "factory, form", - [ - ("null", b'"Null"'), - ("month_day_nano_interval", b'{"Interval":"MonthDayNano"}'), - ("string_view", b'"Utf8View"'), - ("binary_view", b'"BinaryView"'), - ], - ) - def test_type_forms(self, factory, form): - if not hasattr(pa, factory): # view types need pyarrow >= 16 - pytest.skip(f"pyarrow {pa.__version__} has no pa.{factory}()") - dt = getattr(pa, factory)() - schema = pa.schema([pa.field("c", dt, nullable=True)]) - json_ = b'[{"data_type":' + form + b',"name":"c","nullable":true}]' - assert ArrowDigester.hash_schema(schema, ordered_columns=True) == V + sha(tag(0x01), json_) - - def test_default_mode_still_rejects_these_types(self): - with pytest.raises(NotImplementedError): - ArrowDigester.hash_schema(pa.schema([pa.field("c", pa.null())])) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_metadata_paths_look_through_dictionaries(self, flags): - """Spec 2.2.1 paths are the 9.6 node paths, which look through dictionaries.""" - st = pa.struct([pa.field("a", pa.int32(), metadata={"u": "kg"})]) - schema = pa.schema([pa.field("d", pa.dictionary(pa.int32(), st), nullable=True)]) - dt = b'{"Struct":[{"data_type":"Int32","name":"a","nullable":true}]}' - if flags & 0x01: - phase1 = b'[{"data_type":' + dt + b',"name":"d","nullable":true}]' - else: - phase1 = b'{"d":{"data_type":' + dt + b',"nullable":true}}' - phase2 = b'{"fields":{"d/a":{"u":"kg"}}}' - got = ArrowDigester.hash_schema(schema, include_metadata=True, **opts(flags)) - assert got == V + sha(tag(flags), phase1, phase2) - - def test_map_key_and_value_metadata_paths(self): - key = pa.field("key", pa.utf8(), nullable=False, metadata={"role": "id"}) - value = pa.field("value", pa.int32(), metadata={"unit": "kg"}) - schema = pa.schema([pa.field("m", pa.map_(key, value), nullable=True)]) - entries = ( - b'{"data_type":{"Struct":[{"data_type":"LargeUtf8","name":"key","nullable":false},' - b'{"data_type":"Int32","name":"value","nullable":true}]},"name":"entries","nullable":false}' - ) - phase1 = b'{"m":{"data_type":{"Map":[' + entries + b',false]},"nullable":true}}' - phase2 = b'{"fields":{"m//key":{"role":"id"},"m//value":{"unit":"kg"}}}' - got = ArrowDigester.hash_schema(schema, include_metadata=True, nested_validity=True) - assert got == V + sha(tag(0x04), phase1, phase2) - -# ── Spec Section 9.8: invariants ─────────────────────────────────────── - - -def _struct_xy(order: str) -> pa.StructArray: - vals = {"x": pa.array([1, 2], pa.int32()), "y": pa.array([True, False])} - return pa.StructArray.from_arrays( - [vals[n] for n in order], - fields=[pa.field(n, vals[n].type, nullable=False) for n in order], - ) - - -def _batch(cols: dict[str, pa.Array], nullable: bool = False) -> pa.RecordBatch: - schema = pa.schema([pa.field(n, a.type, nullable=nullable) for n, a in cols.items()]) - return pa.record_batch(list(cols.values()), schema=schema) - - -class TestInvariants: - def test_i1_all_off_equals_default(self): - b = _batch({"b": pa.array([1, None], pa.int32()), "s": _struct_xy("yx")}, nullable=True) - assert ArrowDigester.hash_record_batch(b, **opts(0)) == ArrowDigester.hash_record_batch(b) - assert ArrowDigester.hash_schema(b.schema, **opts(0)) == ArrowDigester.hash_schema(b.schema) - assert ArrowDigester.hash_array(b.column(1), **opts(0)) == ArrowDigester.hash_array(b.column(1)) - t = pa.Table.from_batches([b, b]) - assert ArrowDigester.hash_table(t, **opts(0)) == ArrowDigester.hash_table(t) - - @pytest.mark.parametrize("kind", ["schema", "batch", "array", "one_column_table"]) - def test_i2_all_flags_values_distinct(self, kind): - b = _batch({"b": pa.array([1, None], pa.int32()), "s": _struct_xy("yx")}, nullable=True) - if kind == "schema": - hashes = [ArrowDigester.hash_schema(b.schema, **opts(f)) for f in ALL_FLAGS] - elif kind == "batch": - hashes = [batch_hash(b, f) for f in ALL_FLAGS] - elif kind == "array": - hashes = [ArrowDigester.hash_array(b.column(1), **opts(f)) for f in ALL_FLAGS] - else: - t = pa.table({"a": pa.array([1, 2], pa.int64())}) - hashes = [ArrowDigester.hash_table(t, **opts(f)) for f in ALL_FLAGS] - assert len(set(hashes)) == 8 - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i3_column_permutation(self, flags): - a, b = pa.array([1, 2], pa.int32()), pa.array(["x", None]) - h_ab = batch_hash(_batch({"a": a, "b": b}, nullable=True), flags) - h_ba = batch_hash(_batch({"b": b, "a": a}, nullable=True), flags) - s_ab = ArrowDigester.hash_schema(_batch({"a": a, "b": b}).schema, **opts(flags)) - s_ba = ArrowDigester.hash_schema(_batch({"b": b, "a": a}).schema, **opts(flags)) - if flags & 0x01: - assert h_ab != h_ba and s_ab != s_ba - else: - assert h_ab == h_ba and s_ab == s_ba - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i4_struct_field_permutation_depth_1(self, flags): - h_xy = batch_hash(_batch({"s": _struct_xy("xy")}), flags) - h_yx = batch_hash(_batch({"s": _struct_xy("yx")}), flags) - a_xy = ArrowDigester.hash_array(_struct_xy("xy"), **opts(flags)) - a_yx = ArrowDigester.hash_array(_struct_xy("yx"), **opts(flags)) - if flags & 0x02: - assert h_xy != h_yx and a_xy != a_yx - else: - assert h_xy == h_yx and a_xy == a_yx - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i4_struct_field_permutation_nested_and_in_list(self, flags): - def nested(order): - inner = _struct_xy(order) - return pa.StructArray.from_arrays( - [pa.array([7, 8], pa.int64()), inner], - fields=[pa.field("k", pa.int64(), nullable=False), pa.field("p", inner.type, nullable=False)], - ) - - def in_list(order): - inner = _struct_xy(order) - return pa.LargeListArray.from_arrays(pa.array([0, 1, 2], pa.int64()), inner) - - for make in (nested, in_list): - h1 = batch_hash(_batch({"c": make("xy")}), flags) - h2 = batch_hash(_batch({"c": make("yx")}), flags) - assert (h1 != h2) == bool(flags & 0x02), make.__name__ - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i5_physical_equivalence(self, flags): - pairs = [ - (pa.array(["a", None, "c"], pa.utf8()), pa.array(["a", None, "c"], pa.large_utf8())), - (pa.array([b"a", None], pa.binary()), pa.array([b"a", None], pa.large_binary())), - (pa.array([[1], None, [2, 3]], pa.list_(pa.int32())), pa.array([[1], None, [2, 3]], pa.large_list(pa.int32()))), - (pa.array(["a", "b", "a"]).dictionary_encode(), pa.array(["a", "b", "a"], pa.large_utf8())), - ] - for small, large in pairs: - assert ArrowDigester.hash_array(small, **opts(flags)) == ArrowDigester.hash_array(large, **opts(flags)) - assert batch_hash(_batch({"c": small}, nullable=True), flags) == batch_hash( - _batch({"c": large}, nullable=True), flags - ) - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i6_batch_split_independence(self, flags): - s = pa.StructArray.from_arrays( - [pa.array([1, None, 3, 4], pa.int32()), pa.array(["a", "b", None, "d"])], - fields=[pa.field("z", pa.int32(), nullable=True), pa.field("a", pa.utf8(), nullable=True)], - mask=pa.array([False, True, False, False]), - ) - lst = pa.array([[[1], None], None, [[2, None]], []], pa.list_(pa.list_(pa.int32()))) - whole = _batch({"s": s, "l": lst}, nullable=True) - d = ArrowDigester(whole.schema, **opts(flags)) - d.update(whole.slice(0, 1)) - d.update(whole.slice(1, 2)) - d.update(whole.slice(3, 1)) - assert d.finalize() == batch_hash(whole, flags) - table = pa.Table.from_batches([whole.slice(0, 3), whole.slice(3, 1)]) - assert ArrowDigester.hash_table(table, **opts(flags)) == batch_hash(whole, flags) - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i7_empty_metadata_invariant(self, flags): - b = _batch({"b": pa.array([1], pa.int32()), "s": _struct_xy("yx").slice(0, 1)}) - assert ArrowDigester.hash_schema(b.schema, include_metadata=True, **opts(flags)) == ( - ArrowDigester.hash_schema(b.schema, include_metadata=False, **opts(flags)) - ) - assert batch_hash(b, flags, include_metadata=True) == batch_hash(b, flags, include_metadata=False) - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_metadata_still_counts_with_flags(self, flags): - plain = pa.schema([pa.field("a", pa.int32())]) - meta = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) - assert ArrowDigester.hash_schema(plain, include_metadata=True, **opts(flags)) != ( - ArrowDigester.hash_schema(meta, include_metadata=True, **opts(flags)) - ) - - -# ── Spec Section 9.5: the four losses closed by nested_validity (I8) ── - - -def _nv_pairs(): - """Pairs of record batches that collide in the default layout (spec 9.5).""" - a_null = pa.field("a", pa.int32(), nullable=True) - - def s_col(child, mask, field=a_null): - return pa.StructArray.from_arrays([child], fields=[field], mask=pa.array(mask)) - - # 1. null struct vs struct whose fields are all null - p1 = ( - _batch({"s": s_col(pa.array([None, None], pa.int32()), [True, False])}, nullable=True), - _batch({"s": s_col(pa.array([None, None], pa.int32()), [False, False])}, nullable=True), - ) - # 2. nullable struct, non-nullable descendant: null rows vanish (3 rows vs 2 rows) - a_req = pa.field("a", pa.int32(), nullable=False) - p2 = ( - _batch({"s": s_col(pa.array([1, 9, 3], pa.int32()), [False, True, False], a_req)}, nullable=True), - _batch({"s": s_col(pa.array([1, 3], pa.int32()), [False, False], a_req)}, nullable=True), - ) - # 3. List>: outer list lengths lost - lt = pa.list_(pa.field("item", pa.list_(pa.int32()), nullable=True)) - p3 = ( - _batch({"c": pa.array([[[1], [2]]], type=lt)}), - _batch({"c": pa.array([[[1]], [[2]]], type=lt)}), - ) - # 4. List: null element vs element with all-null fields - st = pa.struct([a_null]) - ls = pa.list_(pa.field("item", st, nullable=True)) - p4 = ( - _batch({"c": pa.array([[None]], type=ls)}), - _batch({"c": pa.array([[{"a": None}]], type=ls)}), - ) - # 5. (9.5.1) non-nullable Boolean: padding bits look like false values - bt = pa.field("b", pa.bool_(), nullable=False) - p5 = ( - pa.record_batch([pa.array([True])], schema=pa.schema([bt])), - pa.record_batch([pa.array([True, False, False])], schema=pa.schema([bt])), - ) - return { - "null_struct": p1, - "vanishing_rows": p2, - "list_of_nullable_list": p3, - "list_of_nullable_struct": p4, - "boolean_padding": p5, - } - - -class TestNestedValidity: - @pytest.mark.parametrize("case", list(_nv_pairs())) - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_i8_losses(self, case, flags): - left, right = _nv_pairs()[case] - equal = batch_hash(left, flags) == batch_hash(right, flags) - assert equal == (not flags & 0x04) - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_boolean_padding_hash_array(self, flags): - one = ArrowDigester.hash_array(pa.array([True]), **opts(flags)) - two = ArrowDigester.hash_array(pa.array([True, False]), **opts(flags)) - assert (one == two) == (not flags & 0x04) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f & 0x04]) - def test_boolean_batch_split_and_slices(self, flags): - """Spec 9.5.1 / I8: Boolean leaves are split- and slice-independent with the third switch.""" - st = pa.struct([pa.field("v", pa.bool_(), nullable=False)]) - cols = { - "b": pa.array([True, False, None, True, True, False, True, False, True]), - "s": pa.array([{"v": i % 3 == 0} for i in range(9)], type=st), - "l": pa.array([[True], [False, True], None, [], [True, True, False], [False], [True], [], [False]]), - } - whole = _batch(cols, nullable=True) - ref = batch_hash(whole, flags) - d = ArrowDigester(whole.schema, **opts(flags)) - for start, length in ((0, 3), (3, 1), (4, 5)): - d.update(whole.slice(start, length)) - assert d.finalize() == ref - d = ArrowDigester(whole.schema, **opts(flags)) - d.update(whole.slice(0, 0)) - d.update(whole) - assert d.finalize() == ref - # non-zero offset slices of an array equal the same values built fresh - assert ArrowDigester.hash_array(cols["b"].slice(3, 5), **opts(flags)) == ArrowDigester.hash_array( - pa.array(cols["b"].slice(3, 5).to_pylist()), **opts(flags) - ) - - @pytest.mark.parametrize("chunk", [1, 3, 8, 1 << 16]) - def test_boolean_bytes_hashed_in_bounded_chunks(self, chunk, monkeypatch): - """Chunked hashing gives the spec 9.5.1 bytes across chunk boundaries, nulls and offsets.""" - import starfix.arrow_digester as ad - - monkeypatch.setattr(ad, "_BOOLEAN_CHUNK", chunk) - values = [True, None, False, True, True, None, False, False, True, True, None] - arr = pa.array(values).slice(1, 9) # non-zero offset - valid = [v for v in values[1:10] if v is not None] - bits = sum(1 << i for i, v in enumerate(values[1:10]) if v is not None) - expected = V + sha( - tag(0x04), b'"Boolean"', u64(9) + bits.to_bytes(2, "little"), sha(bytes(int(v) for v in valid)) - ) - assert ArrowDigester.hash_array(arr, nested_validity=True) == expected - no_nulls = pa.array([True, False, True, True, False, True, False]).slice(2, 5) - expected = V + sha(tag(0x04), b'"Boolean"', sha(bytes([1, 1, 0, 1, 0]))) - assert ArrowDigester.hash_array(no_nulls, nested_validity=True) == expected - - def test_hash_array_nullable_struct_root_entry(self): - """A nullable struct array passed to hash_array gets a validity-only entry at "".""" - arr = pa.StructArray.from_arrays( - [pa.array([1, 2], pa.int32())], - fields=[pa.field("a", pa.int32(), nullable=False)], - mask=pa.array([False, True]), - ) - type_json = b'{"Struct":[{"data_type":"Int32","name":"a","nullable":false}]}' - expected = V + sha( - tag(0x04), - type_json, - u64(2) + b"\x01", # entry "": struct validity [1,0] - sha(i32(1)), # entry "a": non-nullable child, only the valid row - ) - assert ArrowDigester.hash_array(arr, nested_validity=True) == expected - - def test_nested_nullable_structs_record_combined_validity(self): - """Inner nullable struct bits = own AND ancestor (spec 9.5 traversal).""" - inner = pa.StructArray.from_arrays( - [pa.array([1, 2, 3], pa.int32())], - fields=[pa.field("a", pa.int32(), nullable=False)], - mask=pa.array([False, False, True]), # inner validity [1,1,0] - ) - outer = pa.StructArray.from_arrays( - [inner], - fields=[pa.field("t", inner.type, nullable=True)], - mask=pa.array([True, False, False]), # outer validity [0,1,1] - ) - batch = _batch({"s": outer}, nullable=True) - schema_digest = sha( - tag(0x04), - b'{"s":{"data_type":{"Struct":[{"data_type":{"Struct":[{"data_type":"Int32","name":"a",' - b'"nullable":false}]},"name":"t","nullable":true}]},"nullable":true}}', - ) - expected = V + sha( - schema_digest, - u64(3) + b"\x06", # "s": [0,1,1] - u64(3) + b"\x02", # "s/t": [1,1,0] AND [0,1,1] = [0,1,0] - sha(i32(2)), # "s/t/a": only row 1 - ) - assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected - - def test_non_nullable_struct_gets_no_entry(self): - s = pa.StructArray.from_arrays( - [pa.array([1, 2], pa.int32()), pa.array([3, 4], pa.int32())], - fields=[pa.field("x", pa.int32(), nullable=False), pa.field("z", pa.int32(), nullable=False)], - ) - batch = _batch({"s": s}, nullable=False) - schema_digest = sha( - tag(0x04), - b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"x","nullable":false},' - b'{"data_type":"Int32","name":"z","nullable":false}]},"nullable":false}}', - ) - # no "s" entry: only "s/x" and "s/z" - expected = V + sha(schema_digest, sha(i32(1, 2)), sha(i32(3, 4))) - assert ArrowDigester.hash_record_batch(batch, nested_validity=True) == expected - - -# ── Spec Section 9.6: rejected schemas (ValueError) ─────────────────── - - -def _rejected_schemas(): - i32_ = pa.int32() - return { - "duplicate_columns": pa.schema([pa.field("a", i32_), pa.field("a", pa.utf8())]), - "duplicate_struct_children": pa.schema([ - pa.field("s", pa.struct([pa.field("x", i32_), pa.field("x", i32_)])), - ]), - "duplicate_children_nested_in_list": pa.schema([ - pa.field("l", pa.list_(pa.struct([pa.field("p", pa.struct([pa.field("q", i32_), pa.field("q", i32_)]))]))), - ]), - "slash_aliases_struct_child": pa.schema([ - pa.field("a/b", i32_), - pa.field("a", pa.struct([pa.field("b", i32_)])), - ]), - "slash_aliases_list_element": pa.schema([ - pa.field("x", pa.list_(i32_)), - pa.field("x/", i32_), - ]), - "slash_aliases_fixed_size_list_element": pa.schema([ - pa.field("x", pa.list_(i32_, 2)), - pa.field("x/", i32_), - ]), - "duplicate_children_in_large_list_struct": pa.schema([ - pa.field("l", pa.large_list(pa.struct([pa.field("x", i32_), pa.field("x", i32_)]))), - ]), - } - - -class TestRejection: - @pytest.mark.parametrize("case", list(_rejected_schemas())) - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_hash_schema_rejects(self, case, flags): - schema = _rejected_schemas()[case] - with pytest.raises(ValueError): - ArrowDigester.hash_schema(schema, **opts(flags)) - with pytest.raises(ValueError): - ArrowDigester(schema, **opts(flags)) - - @pytest.mark.parametrize("case", list(_rejected_schemas())) - def test_default_mode_does_not_reject_schema(self, case): - ArrowDigester.hash_schema(_rejected_schemas()[case]) - ArrowDigester(_rejected_schemas()[case]) - - def test_hash_record_batch_rejects_duplicate_columns(self): - batch = pa.record_batch([pa.array([1]), pa.array([2])], names=["a", "a"]) - ArrowDigester.hash_record_batch(batch) # default: accepted - with pytest.raises(ValueError): - ArrowDigester.hash_record_batch(batch, ordered_columns=True) - - def test_hash_table_rejects_duplicate_columns(self): - table = pa.table([pa.array([1]), pa.array([2])], names=["a", "a"]) - with pytest.raises(ValueError): - ArrowDigester.hash_table(table, nested_validity=True) - - def test_hash_array_rejects_duplicate_children(self): - arr = pa.StructArray.from_arrays( - [pa.array([1]), pa.array([2])], - fields=[pa.field("x", pa.int64()), pa.field("x", pa.int64())], - ) - ArrowDigester.hash_array(arr) # default: accepted - with pytest.raises(ValueError): - ArrowDigester.hash_array(arr, ordered_struct_fields=True) - - def test_hash_array_rejects_child_named_empty_string(self): - """claim("") for the root, then join("", "") == "" for the child (spec 9.6).""" - arr = pa.StructArray.from_arrays([pa.array([1])], fields=[pa.field("", pa.int64())]) - with pytest.raises(ValueError): - ArrowDigester.hash_array(arr, nested_validity=True) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_slash_that_aliases_nothing_is_accepted(self, flags): - schema = pa.schema([pa.field("km/h", pa.float64()), pa.field("km", pa.int32())]) - ArrowDigester.hash_schema(schema, **opts(flags)) - batch = pa.record_batch([pa.array([1.5]), pa.array([1], pa.int32())], schema=schema) - ArrowDigester.hash_record_batch(batch, **opts(flags)) - - def test_update_rejects_batch_with_rejected_schema(self): - good = pa.schema([pa.field("a", pa.int64())]) - d = ArrowDigester(good, ordered_columns=True) - bad = pa.record_batch([pa.array([1]), pa.array([2])], names=["a", "a"]) - with pytest.raises(ValueError): - d.update(bad) - - -# ── Spec Section 9.7: streaming ─────────────────────────────────────── - - -class TestStreaming: - def _schemas(self): - ab = pa.schema([pa.field("a", pa.int32()), pa.field("b", pa.utf8())]) - ba = pa.schema([pa.field("b", pa.utf8()), pa.field("a", pa.int32())]) - return ab, ba - - def _batch(self, schema): - cols = {"a": pa.array([1, 2], pa.int32()), "b": pa.array(["x", None])} - return pa.record_batch([cols[f.name] for f in schema], schema=schema) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f & 0x01]) - def test_reordered_columns_rejected_with_ordered_columns(self, flags): - ab, ba = self._schemas() - d = ArrowDigester(ab, **opts(flags)) - d.update(self._batch(ab)) - with pytest.raises(ValueError, match="does not match"): - d.update(self._batch(ba)) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if not f & 0x01]) - def test_reordered_columns_accepted_without_ordered_columns(self, flags): - ab, ba = self._schemas() - d = ArrowDigester(ab, **opts(flags)) - d.update(self._batch(ab)) - d.update(self._batch(ba)) - ref = ArrowDigester(ab, **opts(flags)) - ref.update(self._batch(ab)) - ref.update(self._batch(ab)) - assert d.finalize() == ref.finalize() - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_reordered_struct_fields(self, flags): - xy, yx = _batch({"s": _struct_xy("xy")}), _batch({"s": _struct_xy("yx")}) - d = ArrowDigester(xy.schema, **opts(flags)) - d.update(xy) - if flags & 0x02: - with pytest.raises(ValueError, match="does not match"): - d.update(yx) - else: - d.update(yx) - ref = ArrowDigester(xy.schema, **opts(flags)) - ref.update(xy) - ref.update(xy) - assert d.finalize() == ref.finalize() - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_different_type_rejected(self, flags): - ab, _ = self._schemas() - d = ArrowDigester(ab, **opts(flags)) - other = pa.record_batch([pa.array([1, 2], pa.int64()), pa.array(["x", None])], names=["a", "b"]) - with pytest.raises(ValueError, match="does not match"): - d.update(other) - - @pytest.mark.parametrize("flags", [f for f in ALL_FLAGS if f]) - def test_metadata_mismatch_rejected_with_include_metadata(self, flags): - """Spec 9.7 rule 2: with include_metadata the Phase 2 documents must be equal.""" - plain = pa.schema([pa.field("a", pa.int32())]) - meta = pa.schema([pa.field("a", pa.int32(), metadata={"k": "v"})]) - batch = pa.record_batch([pa.array([1], pa.int32())], schema=meta) - ArrowDigester(plain, **opts(flags)).update(batch) # metadata ignored without include_metadata - d = ArrowDigester(plain, include_metadata=True, **opts(flags)) - with pytest.raises(ValueError, match="does not match"): - d.update(batch) - - @pytest.mark.parametrize("flags", ALL_FLAGS) - def test_equivalent_physical_types_accepted(self, flags): - ab, _ = self._schemas() - d = ArrowDigester(ab, **opts(flags)) - large = pa.record_batch( - [pa.array([1, 2], pa.int32()), pa.array(["x", None], pa.large_utf8())], - schema=pa.schema([pa.field("a", pa.int32()), pa.field("b", pa.large_utf8())]), - ) - d.update(large) - assert d.finalize() == batch_hash(self._batch(ab), flags) - - -# ── API shape: keyword-only options with the Rust names ─────────────── - - -class TestKeywordOnly: - def test_constructor(self): - schema = pa.schema([pa.field("a", pa.int32())]) - with pytest.raises(TypeError): - ArrowDigester(schema, False, True) # type: ignore[misc] - ArrowDigester(schema, include_metadata=False, ordered_columns=True, ordered_struct_fields=True, nested_validity=True) - - def test_static_entry_points(self): - schema = pa.schema([pa.field("a", pa.int32())]) - batch = pa.record_batch([pa.array([1], pa.int32())], schema=schema) - table = pa.Table.from_batches([batch]) - arr = batch.column(0) - with pytest.raises(TypeError): - ArrowDigester.hash_schema(schema, False, True) # type: ignore[misc] - with pytest.raises(TypeError): - ArrowDigester.hash_record_batch(batch, False, True) # type: ignore[misc] - with pytest.raises(TypeError): - ArrowDigester.hash_table(table, False, True) # type: ignore[misc] - with pytest.raises(TypeError): - ArrowDigester.hash_array(arr, True) # type: ignore[misc] - for name in _OPTION_FLAGS: - ArrowDigester.hash_schema(schema, **{name: True}) - ArrowDigester.hash_record_batch(batch, **{name: True}) - ArrowDigester.hash_table(table, **{name: True}) - ArrowDigester.hash_array(arr, **{name: True}) - - def test_hash_array_has_no_include_metadata(self): - with pytest.raises(TypeError): - ArrowDigester.hash_array(pa.array([1]), include_metadata=True) # type: ignore[call-arg] - - def test_combinations_are_independent_switches(self): - """All 8 combinations are accepted and each is reachable by keywords alone.""" - schema = pa.schema([pa.field("a", pa.int32())]) - for bits in itertools.product([False, True], repeat=3): - ArrowDigester.hash_schema(schema, **dict(zip((OC, OSF, NV), bits, strict=True))) From 217ced9dae5777c7de193d227bfa525005e2f76a Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 03:59:29 -0800 Subject: [PATCH 21/49] docs: README, CHANGELOG and design note for hash format 2 (ITL-898) README documents format 2 (prefix, guarantees, options, rejections, format history); CHANGELOG lists the breaking format change, the fixed format-1 losses and Python/Rust differences, the ITL-908 performance fix and the new options; the superseded options design note is replaced by a format-2 note of the Python-specific decisions. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 55 ++++++ README.md | 164 ++++++++---------- .../specs/2026-11-11-format-2-python.md | 52 ++++++ .../2026-11-11-ordered-hashing-design.md | 83 --------- 4 files changed, 176 insertions(+), 178 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 docs/metamorphic/specs/2026-11-11-format-2-python.md delete mode 100644 docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..5a91f70 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,55 @@ +# Changelog + +## Unreleased (proposed 0.5.0) + +### Changed — hash format 2 (every hash changes) + +starfix-python now computes hash format 2, byte-identical to the Rust starfix crate 0.5. The +3-byte prefix of every hash is `00 00 02` (format 2); starfix-python 0.4 and earlier produced +format 1 (`00 00 01`). **Every hash changes**, and a format-1 hash can always be told from a +format-2 hash by its first three bytes. Format-1 hashes can be computed with starfix 0.4 in a +separate environment. Specification: starfix `docs/byte-layout-spec.md`. + +### Fixed — information losses of format 1 (ITL-898) + +These inputs collided, or hashed differently depending on batch boundaries, in format 1: + +- Booleans were bit-packed per call without a count (`[true]` == `[true, false, false]` in a + one-column non-nullable table; batch splits changed the hash). Now one byte per valid value. +- A null struct equalled a struct whose fields are all null, and null struct rows vanished + under non-nullable fields. Now every nullable node records its validity. +- A list whose element is a nullable list lost its own lengths, and a list of nullable structs + did not distinguish a null element. Now every list records its lengths and every nullable + element its validity. +- The row count of zero-column tables and empty structs was not hashed. Now it is. +- Python only: a list of dictionary-encoded fixed-width values (for example + `list>`) hashed the dictionary indices instead of the values. + +### Fixed — Python/Rust differences of format 1 + +All are gone in format 2: map schemas (the value type and `keys_sorted` were not hashed), +non-ASCII struct field names in `hash_array`, metadata paths of map fields, schemas of `Null`, +`Interval`, `Utf8View` and `BinaryView` types (they raised), and the streaming schema check. + +### Fixed — performance (ITL-908) + +Hashing a list column took time quadratic in the number of rows (every row copied the whole +child values buffer). Format 2 hashes every column type in linear time, working on Arrow +buffers: at 1M rows, `list` takes about 20 ms instead of an estimated 90 s. + +### Added + +- Keyword-only options `ordered_columns` and `ordered_struct_fields` on `ArrowDigester(...)`, + `hash_schema`, `hash_record_batch`, `hash_table` and `hash_array`: make column order and + struct field order (at every depth) part of the hash. Default off. +- Extension types are hashed as their storage type; with `include_metadata`, their + `ARROW:extension:*` keys are hashed, also for types registered with pyarrow. +- Golden vectors `tests/golden/format2_v0.5.json`, generated by Rust and asserted in full. + +### Changed (breaking) + +- In every mode, `ValueError` is raised for schemas with duplicate or `/`-aliased field paths; + for `ListView`, `LargeListView`, `Union` and `RunEndEncoded` types; for hashing data of + `Null`, `FixedSizeList`, `Map`, `Interval` and view types (previously `NotImplementedError` + or accepted); for a non-nullable field holding a null that no enclosing struct null explains; + and for a streamed batch whose schema differs from the digester's. diff --git a/README.md b/README.md index 8a39d73..abf10a8 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,21 @@ Pure-Python implementation of the [starfix](https://github.com/nauticalab/starfix) Arrow logical hasher. -Produces stable SHA-256 hashes of Arrow tables, record batches, and arrays that are: - -- **Column-order independent** by default — reordering columns or struct fields does not change the hash (opt-in order sensitivity: see [Hashing options](#hashing-options-order-sensitivity-and-nested-validity)) -- **Batch-split independent** — splitting data across batches does not change the hash -- **Cross-language compatible** — identical hashes to the Rust implementation for the supported types, with a few known exceptions when no hashing option is on (see [Rust compatibility](#rust-compatibility)) +Produces stable SHA-256 hashes of Arrow schemas, tables, record batches and arrays that are: + +- **Byte-identical to the Rust implementation**: every vector of the shared golden file + (`tests/golden/format2_v0.5.json`, generated by Rust) is matched. +- **Column-order and struct-field-order independent** by default. Both orders can be made part + of the hash (see [Options](#options)). Nothing else is reordered: row order and list element + order are always hashed. +- **Batch-split independent**: splitting rows into batches, slicing, or adding empty batches does + not change the hash; adding or removing rows does. +- **Lossless**: a null struct differs from a struct whose fields are all null, null rows are + counted, every list records its lengths, and the row count is hashed. + +> **Hash format 2 (starfix 0.5).** Every hash starts with the 3-byte format number `00 00 02`. +> All hashes differ from those of starfix 0.4 and earlier (format 1, `00 00 01`); see +> [Hash format](#hash-format). ## Installation @@ -27,112 +37,76 @@ schema = pa.schema([ # Hash a full table table = pa.table({"id": [1, 2, 3], "value": [1.1, 2.2, 3.3]}, schema=schema) -digest = ArrowDigester.hash_table(table) +digest = ArrowDigester.hash_table(table) # 35 bytes: 00 00 02 + SHA-256 -# Streaming: feed record batches incrementally +# Streaming: feed record batches incrementally (same hash as hash_table) digester = ArrowDigester(schema) -for batch in batches: +for batch in table.to_batches(): digester.update(batch) digest = digester.finalize() -``` - -## Metadata hashing - -By default, Arrow schema- and field-level metadata are excluded from the hash, -preserving hash format 0.0.1 stability. Pass `include_metadata=True` to any -entry point to include them: - -```python -# One-shot -digest = ArrowDigester.hash_table(table, include_metadata=True) -# Streaming -digester = ArrowDigester(schema, include_metadata=True) -for batch in batches: - digester.update(batch) -digest = digester.finalize() +# A schema, a single record batch, or a single array +ArrowDigester.hash_schema(schema) +ArrowDigester.hash_record_batch(table.to_batches()[0]) +ArrowDigester.hash_array(pa.array([1, 2, 3], pa.int32())) ``` -When `include_metadata=True`, adding or changing any metadata key or value on -any field (including nested struct children and list element fields) produces a -different hash. Metadata key ordering is deterministic — the hash is stable -regardless of insertion order. - -A schema with no metadata produces the same hash regardless of `include_metadata` -(empty-metadata invariant). - -## Hashing options: order sensitivity and nested validity +## Options -Three further keyword-only options, all `False` by default, are accepted by -`ArrowDigester(...)`, `hash_schema`, `hash_record_batch`, `hash_table` and -`hash_array`. They have the same names as the Rust `HasherConfig` fields. With -at least one of them on, hashes are byte-identical to Rust; the shared golden -vectors in `tests/golden/ordered_v0.5.json` pin this (layout: starfix -`docs/byte-layout-spec.md`, Section 9). +Keyword-only, all `False` by default, the same names as the Rust `HasherConfig` fields, accepted by +`ArrowDigester(...)`, `hash_schema`, `hash_record_batch`, `hash_table` and `hash_array` +(`hash_array` has no `include_metadata`). | Option | Effect | |---|---| | `ordered_columns` | The order of the top-level columns is part of the hash. | -| `ordered_struct_fields` | The order of struct fields, at every nesting depth (inside lists, struct children, …), is part of the hash. | -| `nested_validity` | Every nullable struct, and every nullable list or struct that is a list element, records its own validity. A null struct then differs from a struct whose fields are all null, null struct rows are counted, and the outer lengths of a list of nullable lists are hashed. Every Boolean value (in any column, nullable or not) is also hashed as one byte per valid value. Without this option, `[true]` and `[true, false, false]` in a non-nullable Boolean column hash the same, and a Boolean column's hash depends on how its rows are split into batches. | +| `ordered_struct_fields` | The order of struct fields, at every depth (struct children, list elements, map keys and values, dictionary values), is part of the hash. | +| `include_metadata` | Schema- and field-level Arrow metadata is part of the hash. A schema without metadata hashes the same either way. | ```python -# A pa.Table whose column order and struct field order are part of its identity -digest = ArrowDigester.hash_table( - table, ordered_columns=True, ordered_struct_fields=True, nested_validity=True -) - -# hash_array takes the same options (ordered_columns has no effect on an array's -# layout, but like every option it is part of the hash) -digest = ArrowDigester.hash_array(struct_array, ordered_struct_fields=True) +# A DataFrame-like value whose column order and struct field order are part of its identity +digest = ArrowDigester.hash_table(table, ordered_columns=True, ordered_struct_fields=True) ``` -When to use them: - -- Leave them off to identify *data* independent of how columns or struct fields - happen to be ordered (the default; every existing hash is unchanged). -- Turn on `ordered_columns` / `ordered_struct_fields` when order is part of the - value's identity, as for a DataFrame or a `pa.StructArray` whose type - `struct` differs from `struct`. -- Turn on `nested_validity` when null structs and null nested lists must be - distinguished from their non-null look-alikes. - -Things to know: - -- **A hash taken with any option on never equals a hash taken with a different - set of options**, in particular with all options off, even when order cannot - matter (for example, a one-column table). Choose the options once per use case. -- With any option on, a schema in which two nodes share a path is rejected with - `ValueError`: duplicate column names, duplicate field names within a struct, - or a name containing `/` that aliases another node (a column `"a/b"` next to a - struct column `a` with a child `b`). A `/` that aliases nothing (`"km/h"`) is - fine. -- Streaming with any option on: every batch passed to `update` must have the - digester's schema under those options, otherwise `ValueError` is raised. With - `ordered_columns`, a batch with the same columns in another order is rejected; - without it, the batch is accepted. The same holds for struct field order and - `ordered_struct_fields`. -- `include_metadata` works with every option as described above. - -## Rust compatibility - -With at least one hashing option on, every hash matches the Rust implementation -byte for byte, with one exception: with `include_metadata`, metadata on a map's -*entries* field is not seen, because pyarrow does not keep it when it reads Arrow -data (key and value field metadata are kept). With all options off, the hashes are those of starfix-python 0.4.0, -which differ from Rust in these cases (`tests/test_known_divergences.py` and the -`_f0` entries marked as known divergences in `tests/test_golden_parity_ordered.py`): - -- schemas containing a `Map` column (the map's value type, `keys_sorted` and the - key / entries metadata paths are not hashed as Rust does); -- `hash_array` of a struct whose field names contain non-ASCII characters; -- schemas containing `Null`, `Interval`, `Utf8View` or `BinaryView` columns, which - raise `NotImplementedError` instead of hashing; -- streaming: a batch whose schema differs from the digester's is accepted, while - Rust rejects it. - -Whether to align the default mode with Rust (which would move these existing -Python hashes) is a separate decision. +- Leave the order options off to identify *data* independent of how columns or struct fields + happen to be ordered. Turn them on when order is part of the value's identity, as for a + DataFrame, or a `pa.StructArray` whose type `struct` differs from `struct`. +- Hashes taken with different order options never coincide, even when order cannot matter. +- With `include_metadata`, metadata is keyed by each field's node path (column `c`, struct + child `c/x`, list element `c/`, map key and value `m//key` and `m//value`). Extension types + are hashed as their storage type; with `include_metadata` their `ARROW:extension:name` and + `ARROW:extension:metadata` are hashed too, including for extension types registered with + pyarrow. + +## Rejected inputs + +`ValueError` is raised, in every mode, for: + +- a schema in which two nodes share a path: duplicate column names, duplicate field names + within a struct, or a name containing `/` that aliases another node (a column `"a/b"` next to + a struct column `a` with a child `b`). A `/` that aliases nothing (`"km/h"`) is fine; +- `ListView`, `LargeListView`, `Union` and `RunEndEncoded` types; +- hashing data of a schema that contains `Null`, `FixedSizeList`, `Map`, `Interval`, + `Utf8View` or `BinaryView` (their schemas hash; their data does not), whatever the number of + rows; +- a non-nullable field holding a null that no enclosing struct null explains; +- streaming: a batch whose schema differs from the digester's. Physically different but + equivalent types (`Utf8`/`LargeUtf8`, `Binary`/`LargeBinary`, `List`/`LargeList`, dictionary + and plain values) are accepted; reordered columns or struct fields are accepted unless the + matching order option is on. + +## Hash format + +The byte layout is specified in starfix's `docs/byte-layout-spec.md`. The first three bytes of +every hash are the format number: + +| Format | Prefix | starfix | Notes | +|---|---|---|---| +| 1 | `00 00 01` | ≤ 0.4 | Lost information for some inputs (Booleans, nullable structs, lists of nullable lists or structs, row counts, and in Python a list of numeric dictionary values). | +| 2 | `00 00 02` | 0.5 | Lossless layout, the two order options, rejections in every mode. | + +Format-1 hashes can be computed with starfix 0.4 (`pip install "starfix<0.5"` in a separate +environment). Starfix 0.5 computes format 2 only. ## License diff --git a/docs/metamorphic/specs/2026-11-11-format-2-python.md b/docs/metamorphic/specs/2026-11-11-format-2-python.md new file mode 100644 index 0000000..e9da2ef --- /dev/null +++ b/docs/metamorphic/specs/2026-11-11-format-2-python.md @@ -0,0 +1,52 @@ +# Hash Format 2 in starfix-python + +**Date:** 2026-11-11 +**Issues:** ITL-898 (format 2), ITL-908 (list hashing performance) +**Repos:** nauticalab/starfix (Rust, authoritative), nauticalab/starfix-python (this repo) +**Status:** Format 2 approved by the developer on 2026-11-11. + +## Source of truth + +The byte layout is starfix's `docs/byte-layout-spec.md` (format 2). The design and its +rationale are in starfix's `docs/metamorphic/specs/2026-11-11-format-2-design.md`. The golden +values are generated by Rust and copied here byte for byte (`tests/golden/README.md`). +This note records only the Python-specific decisions. + +## Implementation + +- `src/starfix/_format2.py` implements the spec, written from the spec text alone. + `ArrowDigester` (`src/starfix/arrow_digester.py`) is a thin public wrapper. No format-1 code + is kept: format-1 hashes are computed with starfix 0.4. +- Data is processed per node and per batch on Arrow buffers (`filter`, `flatten`, + `value_lengths`, validity bitmaps appended at arbitrary bit offsets, fixed-width values as + buffer slices, strings and binary from the offsets and data buffers in bounded chunks). Every + type hashes in linear time (ITL-908). `tests/test_format2_scaling.py` guards this + deterministically: no shared buffer is copied, and the number of node visits does not grow + with the row count. +- Extension types: pyarrow hides `ARROW:extension:name` / `ARROW:extension:metadata` for + registered types. They are re-added from `extension_name` and, for Python-defined + `pa.ExtensionType` subclasses, `__arrow_ext_serialize__()`. pyarrow's natively registered + canonical types (`arrow.uuid`, `arrow.fixed_shape_tensor`, ...) have no Python serializer, so + their metadata is read from the field exported through the Arrow C data interface + (`ArrowSchema.metadata`, a fixed ABI). The spec defines their hash only for the canonical + stored form. +- Validity bits, lengths and values follow the spec's one rule. Effective validity (own AND + enclosing struct validity) is computed for every node and written for nullable nodes only. + +## Tests + +- `tests/test_format2.py`: the spec's worked examples and every hash the spec prints, built + from the literal SHA-256 inputs; primitive forms, JSON text rules, metadata paths, names not + hashed, invariants, every rejection, streaming, extension types, dictionary nullability, and + slicing at offsets around byte and word boundaries. +- `tests/test_golden_parity_format2.py`: every vector and relation of `format2_v0.5.json`. + The only skips are version-gated (vectors an older installed pyarrow cannot decode). +- The hand-coded literals of the older test files were moved to Rust-produced format-2 values + (`format1_to_format2.json`). Literals that file did not cover had their inputs recovered by + recording the calls that produced them (`python_literals_format1_inputs.json`), so Rust could + supply their values. + +## Version + +Proposed: 0.5.0, matching the Rust crate. Every hash changes (breaking). The version comes from +git tags (hatch-vcs); nothing is bumped here. diff --git a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md b/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md deleted file mode 100644 index 1cb4e7c..0000000 --- a/docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md +++ /dev/null @@ -1,83 +0,0 @@ -# Ordered and Nested-Validity Hashing Options (Python) - -**Date:** 2026-11-11 -**Issue:** ITL-898 -**Repos:** nauticalab/starfix (Rust, authoritative), nauticalab/starfix-python (this repo) -**Status:** Provisional: the Rust design is not yet approved, and the third option's name may change. - ---- - -## Source of truth - -The byte layout is defined in the Rust repository: `docs/byte-layout-spec.md` Section 9 -(options and flags byte, options tag, ordered Phase 1 JSON, `hash_array` type JSON, nested -validity, Boolean layout under the third option, node-path rejection, streaming, invariants, -worked examples T1 to T6, golden-file format). The design rationale is in the Rust repo at -`docs/metamorphic/specs/2026-11-11-ordered-hashing-design.md`. This document records only the -Python-specific decisions. - -The golden values are produced by Rust (`cargo run --bin emit_golden_ordered`) and copied here -byte for byte as `tests/golden/ordered_v0.5.json`. Python never generates or edits them. - -## API - -Keyword-only arguments with the Rust `HasherConfig` field names, all `False` by default: - -```python -ArrowDigester(schema, *, include_metadata=False, ordered_columns=False, - ordered_struct_fields=False, nested_validity=False) -ArrowDigester.hash_schema(schema, *, include_metadata=..., ordered_columns=..., ordered_struct_fields=..., nested_validity=...) -ArrowDigester.hash_record_batch(batch, *, ...same four...) -ArrowDigester.hash_table(table, *, ...same four...) -ArrowDigester.hash_array(array, *, ordered_columns=..., ordered_struct_fields=..., nested_validity=...) -``` - -Rejections (spec 9.6, 9.7) raise `ValueError`. - -**Renaming an option:** `_OPTION_FLAGS` in `src/starfix/arrow_digester.py` is the single table -of option names and flag bits. A rename changes that table, the keyword in the five -signatures, their docstrings, the README, and the name constants at the top of -`tests/test_ordered_hashing.py`. The golden parity test reads option keys from `_OPTION_FLAGS`. -The name is not hashed, so no hash moves. - -## Implementation notes - -* `flags == 0` takes exactly the previous code paths (`_serialized_schema`, the old - `hash_array` type JSON, the bit-packed Boolean layout, no checks), so every existing hash is - unchanged (invariant I1). All existing tests and golden files pass unmodified. -* With `flags != 0`, JSON is written with raw UTF-8 (`ensure_ascii=False`), as serde_json does, - and `Map` is serialized as the Rust form `{"Map": [, keys_sorted]}`. -* Nested validity threads one boolean through entry extraction and traversal. Booleans are fed - as one byte per valid value under the third option (spec 9.5.1). - -## Known default-mode divergences from Rust (not changed here) - -Found while implementing from the spec. All of these predate ITL-898 and are present in the -released starfix-python 0.4.0. Fixing them moves released hashes, or rejects batches that are -accepted today, which is the developer's decision. `tests/test_known_divergences.py` pins the -Rust behaviour as `xfail(strict=True)` tests; the affected default-mode golden vectors are marked the same way in `tests/test_golden_parity_ordered.py`. - -| Input | Python today (flags 0) | Rust | -|---|---|---| -| `hash_schema` of a `Map` column | `{"Map":[{"data_type":,"name":"entries","nullable":false},false]}`: the value type and `keys_sorted` are ignored | `{"Map":[{"data_type":{"Struct":[key, value]},"name":"entries","nullable":false},keys_sorted]}` | -| `hash_array` of a struct with a non-ASCII child name `é` | type JSON escapes it as the six ASCII characters `\u00e9` | raw UTF-8 (bytes `c3 a9`), spec 2.1 JSON text rules | -| `update` with a batch whose schema differs (spec 9.7, no options) | accepted and hashed as given | rejected: Phase 1 JSON must match, plus the Phase 2 document with `include_metadata` | - -| `hash_schema` with `include_metadata` of a `Map` column with field metadata | value field metadata at `m/`, key skipped | entries at `m/`, key at `m//key`, value at `m//value` (spec 2.2.1) | -| `hash_schema` of `Null`, `Interval`, `Utf8View`, `BinaryView` columns | raises `NotImplementedError` | spec 2.1 forms (`"Null"`, `{"Interval":"DayTime"}`, `"Utf8View"`, `"BinaryView"`) | - -With any option on, Python matches Rust in all of these cases (golden vectors `*_f0` above are -strict xfails; their option-on counterparts pass). - -## pyarrow limitation - -pyarrow does not keep the metadata of a map's *entries* field when it reads Arrow IPC (key -and value field metadata are kept; verified with pyarrow 26). The golden vectors -`meta_map_entries_schema_f1_im1` and `meta_map_all_schema_f1_im1` therefore cannot be -reproduced by any pyarrow-based implementation; they are strict xfails pending a decision in -the Rust spec. - -## Version - -Proposed: 0.5.0, matching the Rust crate (new keyword arguments, new hash modes). The version -comes from git tags (hatch-vcs); nothing is bumped in this change. From e856379e219eaf50ca4166f8d28fdc33d1eeb298 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:00:15 -0800 Subject: [PATCH 22/49] test: format2_v0.5.json at starfix d2b26c6 (canonical tensor vector) (ITL-898) Copied byte for byte (sha256 e7e1ccf1...). Golden parity: 254/254 vectors, 89/89 relations, no skips, no xfails. Co-Authored-By: Claude Opus 5.5 --- tests/golden/format2_v0.5.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/golden/format2_v0.5.json b/tests/golden/format2_v0.5.json index 2ab5937..6b2e650 100644 --- a/tests/golden/format2_v0.5.json +++ b/tests/golden/format2_v0.5.json @@ -2505,13 +2505,13 @@ }, { "id": "ext_tensor_canonical_schema_f0_im1", - "description": "arrow.fixed_shape_tensor with canonical metadata {\"shape\":[2,2]} over FixedSizeList (schema only)", + "description": "arrow.fixed_shape_tensor with canonical metadata {\"shape\":[2,2]} over its canonical storage FixedSizeList (schema only)", "method": "hash_schema", "include_metadata": true, "ordered_columns": false, "ordered_struct_fields": false, - "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAeAAAACAAAAAMAAAAAAABEGAAAAABAAAAJAAAAAAABgAIAAQABgAAAAQAAAAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAQAAABpdGVtAAAAAAEAAABlAAAAAgAAAFgAAAAEAAAAuP///wgAAAAkAAAAGAAAAGFycm93LmZpeGVkX3NoYXBlX3RlbnNvcgAAAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAACAAMAAgABAAIAAAACAAAABgAAAAPAAAAeyJzaGFwZSI6WzIsMl19ABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ddd4ba9ee78b849167c70d47425c15ee3def845916ee62655d5756e98e844733" + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAeAAAACAAAAAMAAAAAAABEGAAAAABAAAAJAAAAAAABgAIAAQABgAAAAQAAAAQABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAQAAABpdGVtAAAAAAEAAABlAAAAAgAAAFgAAAAEAAAAuP///wgAAAAkAAAAGAAAAGFycm93LmZpeGVkX3NoYXBlX3RlbnNvcgAAAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAACAAMAAgABAAIAAAACAAAABgAAAAPAAAAeyJzaGFwZSI6WzIsMl19ABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002953966b9d16f403c2c5cdc37b6fdcb31e760ca7d9c4d7329120a8a491448d81d" }, { "id": "empty_name_child_schema_f0", From 6a4d212600ec1ceadc49a8838e2a58d30347001c Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:00:47 -0800 Subject: [PATCH 23/49] docs: format 2 module docstring (approved) (ITL-898) Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index ddc7c0d..dbe59e5 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -1,8 +1,7 @@ -"""Hash format 2 of the starfix Arrow logical hasher (ITL-898, provisional). +"""Hash format 2 of the starfix Arrow logical hasher (ITL-898). Implements ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2) from the specification alone. Section numbers below refer to that document. - """ from __future__ import annotations From 64eee3488a0ced62da8521abd9f98c955a7edada Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:02:22 -0800 Subject: [PATCH 24/49] test: move the last 69 literals to Rust format-2 values; golden at starfix a4bd86d (ITL-898) format2_v0.5.json (323 vectors, 89 relations; sha256 afd7280d...) and format1_to_format2.json (203 entries; sha256 b06a259e...) copied byte for byte. Every hand-coded literal now carries its Rust-produced format-2 value (69 more via the recovered inputs). Parity 323/323 + 89/89, no skips, no xfails; whole suite green on Python 3.10-3.12. Co-Authored-By: Claude Opus 5.5 --- tests/golden/format1_to_format2.json | 485 ++++++++++++++++++- tests/golden/format2_v0.5.json | 690 +++++++++++++++++++++++++++ tests/test_arrow_digester.py | 7 +- tests/test_golden_parity.py | 59 +-- tests/test_golden_parity_r2.py | 95 ++-- tests/test_metadata_hashing.py | 2 +- 6 files changed, 1258 insertions(+), 80 deletions(-) diff --git a/tests/golden/format1_to_format2.json b/tests/golden/format1_to_format2.json index 710ff6a..dafab3e 100644 --- a/tests/golden/format1_to_format2.json +++ b/tests/golden/format1_to_format2.json @@ -1,5 +1,5 @@ { - "description": "Every format-1 golden or pinned value of this repository and its format-2 value (ITL-898, hash format bump 00 00 01 -> 00 00 02). Every value moves. Entries with format2_vector refer to tests/golden/format2_v0.5.json (same input). format1_defects lists the format-1 information losses that affected that input (byte-layout spec Section 10).", + "description": "Every format-1 golden or pinned value of this repository and its format-2 value (ITL-898, hash format bump 00 00 01 -> 00 00 02). Every value moves. Entries with format2_vector refer to tests/golden/format2_v0.5.json (same input). format1_defects lists the format-1 information losses that affected that input (byte-layout spec Section 10). Entries whose source is a starfix-python test were recovered by the Python side (tests/golden/python_literals_format1_inputs.json) and their format-1 values reproduced with starfix 0.4.", "entries": [ { "source": "tests/golden/include_metadata_v0.3.json", @@ -1067,6 +1067,489 @@ "id": "nested_fields", "format1_hash": "9b52ad7430dea81b35f14a04d828b2424080fbc210570081c6e6cb62b6566c42", "format2_hash": "8038c003912adbecc339cd6b1c1e9a62f59dc68a684c00cc1b29cff72d193361" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestTemporalTypes::test_date64", + "format1_hash": "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb", + "format2_hash": "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8", + "format2_vector": "pylit_testtemporaltypes_test_date64" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_schema_only", + "format1_hash": "0000010e62b3f3317d25413b7a4dc6e7a8a6e7c73a73c513cdbe9f9b1f5e5ec56f0e94", + "format2_hash": "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee", + "format2_vector": "pylit_testmultitypebatch_test_multi_type_schema_only" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_record_batch", + "format1_hash": "0000010f8bb471cb34975f20c4b221abff1a90b2d98f24217a2257e3298ee3d4e9f9c4", + "format2_hash": "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce", + "format2_vector": "pylit_testmultitypebatch_test_multi_type_record_batch" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_d_non_nullable_binary", + "format1_hash": "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d", + "format2_hash": "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1", + "format2_vector": "pylit_testspecexamples_test_example_d_non_nullable_binary" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestTemporalTypes::test_date32", + "format1_hash": "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6", + "format2_hash": "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a", + "format2_vector": "pylit_testtemporaltypes_test_date32" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint8", + "format1_hash": "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd", + "format2_hash": "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d", + "format2_vector": "pylit_testprimitivetypes_test_uint8" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestTemporalTypes::test_time64_nanoseconds", + "format1_hash": "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f", + "format2_hash": "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1", + "format2_vector": "pylit_testtemporaltypes_test_time64_nanoseconds" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint16", + "format1_hash": "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357", + "format2_hash": "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc", + "format2_vector": "pylit_testprimitivetypes_test_uint16" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint64", + "format1_hash": "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b", + "format2_hash": "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a", + "format2_vector": "pylit_testprimitivetypes_test_uint64" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestStructTypes::test_struct_with_nullable_children", + "format1_hash": "0000015f1992c5f9130aaa64aa1360e53ddd00b427855ae02e380f534a629353135680", + "format2_hash": "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351", + "format2_vector": "pylit_teststructtypes_test_struct_with_nullable_children" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int16", + "format1_hash": "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4", + "format2_hash": "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73", + "format2_vector": "pylit_testprimitivetypes_test_int16" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88", + "format2_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f", + "format2_vector": "pylit_testspecexamples_test_example_a_two_column_table" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int64", + "format1_hash": "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf", + "format2_hash": "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05", + "format2_vector": "pylit_testprimitivetypes_test_int64" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int8", + "format1_hash": "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc", + "format2_hash": "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a", + "format2_vector": "pylit_testprimitivetypes_test_int8" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_n_list_of_struct", + "format1_hash": "0000019c9cc6230a42e646a475ec1c8125fe396dcace351d64ff6e63e8f53d329c4895", + "format2_hash": "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361", + "format2_vector": "pylit_testspecexamples_test_example_n_list_of_struct" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestTemporalTypes::test_time32_milliseconds", + "format1_hash": "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564", + "format2_hash": "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd", + "format2_vector": "pylit_testtemporaltypes_test_time32_milliseconds" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float64", + "format1_hash": "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b", + "format2_hash": "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda", + "format2_vector": "pylit_testprimitivetypes_test_float64" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint32", + "format1_hash": "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e", + "format2_hash": "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389", + "format2_vector": "pylit_testprimitivetypes_test_uint32" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_i_empty_table", + "format1_hash": "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922", + "format2_hash": "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84", + "format2_vector": "pylit_testspecexamples_test_example_i_empty_table" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_k_struct_column", + "format1_hash": "000001e3516302d68fd1fc4860fa4b7e0d4a6d60d500a9d7ccae79e445c5980021e4ec", + "format2_hash": "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0", + "format2_vector": "pylit_testspecexamples_test_example_k_struct_column" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_o_nested_struct", + "format1_hash": "000001e732b8458782d9a331722698883617eec7cd1492028947b4ce3e97c7d6201550", + "format2_hash": "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c", + "format2_vector": "pylit_testspecexamples_test_example_o_nested_struct" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_bool", + "format1_hash": "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1", + "format2_hash": "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f", + "format2_vector": "pylit_testprimitivetypes_test_bool" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_f_utf8_equivalence", + "format1_hash": "000001f14d076ffc02533c6560f867b86cde7e15b1a0ac5a892b53697a609191cf307f", + "format2_hash": "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286", + "format2_vector": "pylit_testspecexamples_test_example_f_utf8_equivalence" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float32", + "format1_hash": "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa", + "format2_hash": "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2", + "format2_vector": "pylit_testprimitivetypes_test_float32" + }, + { + "source": "starfix-python tests/test_golden_parity.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_e_column_order_independence", + "format1_hash": "000001f68bf6319f8ec4aa938e52dd911974348289fbdfb9b5ebed5e14e239a6d8a3a9", + "format2_hash": "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae", + "format2_vector": "pylit_testspecexamples_test_example_e_column_order_independence" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestBinaryVariedSizes::test_binary_varied_sizes", + "format1_hash": "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05", + "format2_hash": "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1", + "format2_vector": "pylit_testbinaryvariedsizes_test_binary_varied_sizes" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_int32", + "format1_hash": "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65", + "format2_hash": "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33", + "format2_vector": "pylit_testallnullarrays_test_all_null_int32" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_hash_array", + "format1_hash": "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc", + "format2_hash": "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa", + "format2_vector": "pylit_testlistoflist_test_list_of_list_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListOfStruct::test_list_of_struct_hash_array", + "format1_hash": "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626", + "format2_hash": "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2", + "format2_vector": "pylit_testlistofstruct_test_list_of_struct_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_batch", + "format1_hash": "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac", + "format2_hash": "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de", + "format2_vector": "pylit_testrealisticbatch_test_realistic_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_string", + "format1_hash": "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070", + "format2_hash": "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc", + "format2_vector": "pylit_testallnullarrays_test_all_null_string" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_bool_false", + "format1_hash": "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df", + "format2_hash": "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155", + "format2_vector": "pylit_testsingleelementarrays_test_single_bool_false" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_schema", + "format1_hash": "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356", + "format2_hash": "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792", + "format2_vector": "pylit_testrealisticbatch_test_realistic_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_hash_array", + "format1_hash": "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0", + "format2_hash": "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26", + "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestNullableStructHashArray::test_nullable_struct_hash_array", + "format1_hash": "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5", + "format2_hash": "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21", + "format2_vector": "pylit_testnullablestructhasharray_test_nullable_struct_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_schema", + "format1_hash": "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45", + "format2_hash": "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da", + "format2_vector": "pylit_testmixedstructlistbatch_test_mixed_struct_list_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestStructEmptyBatch::test_struct_empty_batch", + "format1_hash": "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773", + "format2_hash": "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93", + "format2_vector": "pylit_teststructemptybatch_test_struct_empty_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestBatchAllNullColumn::test_batch_all_null_column", + "format1_hash": "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494", + "format2_hash": "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752", + "format2_vector": "pylit_testbatchallnullcolumn_test_batch_all_null_column" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_batch", + "format1_hash": "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a", + "format2_hash": "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0", + "format2_vector": "pylit_testmixedstructlistbatch_test_mixed_struct_list_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_nullable_inner_field", + "format1_hash": "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c", + "format2_hash": "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a", + "format2_vector": "pylit_testliststructnullableinnerfield_test_nullable_inner_field" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_schema", + "format1_hash": "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed", + "format2_hash": "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2", + "format2_vector": "pylit_teststructwithlistchild_test_struct_with_list_child_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestNullableStructBatch::test_nullable_struct_batch", + "format1_hash": "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048", + "format2_hash": "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b", + "format2_vector": "pylit_testnullablestructbatch_test_nullable_struct_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_schema", + "format1_hash": "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330", + "format2_hash": "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835", + "format2_vector": "pylit_testlistoflist_test_list_of_list_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_string", + "format1_hash": "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb", + "format2_hash": "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648", + "format2_vector": "pylit_testsingleelementarrays_test_single_string" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestNonNullableList::test_list_non_nullable", + "format1_hash": "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b", + "format2_hash": "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96", + "format2_vector": "pylit_testnonnullablelist_test_list_non_nullable" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_int32_array", + "format1_hash": "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a", + "format2_hash": "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f", + "format2_vector": "pylit_testemptyarrays_test_empty_int32_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_batch", + "format1_hash": "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10", + "format2_hash": "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f", + "format2_vector": "pylit_testlistoflist_test_list_of_list_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_non_nullable_inner_field", + "format1_hash": "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c", + "format2_hash": "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f", + "format2_vector": "pylit_testliststructnullableinnerfield_test_non_nullable_inner_field" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestSchema4LevelNestedStruct::test_schema_4_level_nested_struct", + "format1_hash": "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e", + "format2_hash": "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162", + "format2_vector": "pylit_testschema4levelnestedstruct_test_schema_4_level_nested_struct" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestSchemaListOfStructWithList::test_schema_list_of_struct_with_list", + "format1_hash": "0000017f5258ff48e85b2a63cd1a29590ff3bfca39bf718365200ad74a8232bb654ec6", + "format2_hash": "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb", + "format2_vector": "pylit_testschemalistofstructwithlist_test_schema_list_of_struct_with_list" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema", + "format1_hash": "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83", + "format2_hash": "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd", + "format2_vector": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestNullableListStructNullableChildren::test_nullable_list_struct_nullable_children_batch", + "format1_hash": "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96", + "format2_hash": "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104", + "format2_vector": "pylit_testnullableliststructnullablechildren_test_nullable_list_struct_nullable_children_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestFloatSpecialValues::test_float64_special_values", + "format1_hash": "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a", + "format2_hash": "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc", + "format2_vector": "pylit_testfloatspecialvalues_test_float64_special_values" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema_hash", + "format1_hash": "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654", + "format2_hash": "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe", + "format2_vector": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema_hash" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestStructMixedTypes::test_struct_mixed_types_hash_array", + "format1_hash": "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3", + "format2_hash": "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590", + "format2_vector": "pylit_teststructmixedtypes_test_struct_mixed_types_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_bool_array", + "format1_hash": "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea", + "format2_hash": "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4", + "format2_vector": "pylit_testemptyarrays_test_empty_bool_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestListOfStruct::test_nullable_list_of_struct_hash_array", + "format1_hash": "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8", + "format2_hash": "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca", + "format2_vector": "pylit_testlistofstruct_test_nullable_list_of_struct_hash_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestStructFieldOrderIndependence::test_struct_3field_order_independence", + "format1_hash": "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25", + "format2_hash": "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283", + "format2_vector": "pylit_teststructfieldorderindependence_test_struct_3field_order_independence" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestUnicodeStrings::test_unicode_string_array", + "format1_hash": "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40", + "format2_hash": "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486", + "format2_vector": "pylit_testunicodestrings_test_unicode_string_array" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestNestedNullableInnerStruct::test_nested_nullable_inner_struct", + "format1_hash": "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c", + "format2_hash": "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820", + "format2_vector": "pylit_testnestednullableinnerstruct_test_nested_nullable_inner_struct" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestLargeSchema::test_large_schema_12_fields", + "format1_hash": "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd", + "format2_hash": "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d", + "format2_vector": "pylit_testlargeschema_test_large_schema_12_fields" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestMultiBatchStruct::test_multi_batch_struct", + "format1_hash": "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c", + "format2_hash": "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2", + "format2_vector": "pylit_testmultibatchstruct_test_multi_batch_struct" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_int64", + "format1_hash": "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f", + "format2_hash": "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770", + "format2_vector": "pylit_testsingleelementarrays_test_single_int64" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_batch", + "format1_hash": "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d", + "format2_hash": "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83", + "format2_vector": "pylit_teststructwithlistchild_test_struct_with_list_child_batch" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_schema", + "format1_hash": "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7", + "format2_hash": "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8", + "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_schema" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestBooleanArrays::test_bool_17_elements", + "format1_hash": "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a", + "format2_hash": "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068", + "format2_vector": "pylit_testbooleanarrays_test_bool_17_elements" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestMultiBatchList::test_multi_batch_list", + "format1_hash": "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3", + "format2_hash": "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519", + "format2_vector": "pylit_testmultibatchlist_test_multi_batch_list" + }, + { + "source": "starfix-python tests/test_golden_parity_r2.py", + "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_batch", + "format1_hash": "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a", + "format2_hash": "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db", + "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_batch" + }, + { + "source": "starfix-python tests/test_metadata_hashing.py", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88", + "format2_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f", + "format2_vector": "pylit_testspecexamples_test_example_a_two_column_table_2" } ] } diff --git a/tests/golden/format2_v0.5.json b/tests/golden/format2_v0.5.json index 6b2e650..60889f1 100644 --- a/tests/golden/format2_v0.5.json +++ b/tests/golden/format2_v0.5.json @@ -2542,6 +2542,696 @@ "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + }, + { + "id": "pylit_testtemporaltypes_test_date64", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestTemporalTypes::test_date64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnO8SfgEAAAAAAAAAAAAAAKTZ+v////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8" + }, + { + "id": "pylit_testmultitypebatch_test_multi_type_schema_only", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_schema_only", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gFAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAABgAAABABQAA9AQAAKwEAABoBAAAOAQAAAQEAADUAwAAoAMAAHADAAA4AwAACAMAANgCAACsAgAAdAIAAEACAAD8AQAAxAEAAJgBAABkAQAAOAEAAAgBAACoAAAARAAAAAQAAAAw+///HAAAAAwAAAAAAAEHHAAAAAAAAAAIAAwACAAEAAgAAAAFAAAAJgAAAAoAAABkZWNpbWFsMTI4AABs+///GAAAAAwAAAAAAAEVQAAAAAEAAAAIAAAAYPv//4z7//8QAAAAGAAAAAAAAQIUAAAAxPv//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAoAAABsYXJnZV9saXN0AADM+///GAAAAAwAAAAAAAEMQAAAAAEAAAAIAAAAwPv//+z7//8QAAAAGAAAAAAAAQIUAAAAJPz//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABsaXN0AAAAACj8//8UAAAADAAAAAAAARQMAAAAAAAAABj8//8KAAAAbGFyZ2VfdXRmOAAAVPz//xQAAAAMAAAAAAABBQwAAAAAAAAARPz//wQAAAB1dGY4AAAAAHz8//8UAAAADAAAAAAAARMMAAAAAAAAAGz8//8MAAAAbGFyZ2VfYmluYXJ5AAAAAKz8//8UAAAADAAAAAAAAQQMAAAAAAAAAJz8//8GAAAAYmluYXJ5AAAc/f//FAAAAAwAAAAAAAAJFAAAAAAAAADM////AAADAEAAAAALAAAAdGltZTY0X25hbm8AUP3//xwAAAAMAAAAAAAACRwAAAAAAAAACAAMAAYACAAIAAAAAAACAEAAAAAMAAAAdGltZTY0X21pY3JvAAAAAJD9//8UAAAADAAAAAAAAAkMAAAAAAAAADj9//8NAAAAdGltZTMyX21pbGxpcwAAAMD9//8UAAAADAAAAAAAAAkQAAAAAAAAAE7///8AAAAADQAAAHRpbWUzMl9zZWNvbmQAAAD0/f//FAAAAAwAAAAAAAAIDAAAAAAAAACc/f//BgAAAGRhdGU2NAAAHP7//xQAAAAMAAAAAAAACBAAAAAAAAAAqv///wAAAAAGAAAAZGF0ZTMyAABI/v//EAAAABQAAAAAAAADEAAAANL///8AAAIAAAAAAAcAAABmbG9hdDY0ALj+//8YAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAAHAAAAZmxvYXQzMgCo/v//EAAAABQAAAAAAAACEAAAANr+//9AAAAAAAAAAAYAAAB1aW50NjQAANT+//8QAAAAGAAAAAAAAAIUAAAAxP7//0AAAAAAAAABAAAAAAUAAABpbnQ2NAAAAAT///8QAAAAFAAAAAAAAAIQAAAANv///yAAAAAAAAAABgAAAHVpbnQzMgAAMP///xAAAAAYAAAAAAAAAhQAAAAg////IAAAAAAAAAEAAAAABQAAAGludDMyAAAAYP///xAAAAAUAAAAAAAAAhAAAACS////EAAAAAAAAAAGAAAAdWludDE2AACM////EAAAABgAAAAAAAACFAAAAHz///8QAAAAAAAAAQAAAAAFAAAAaW50MTYAAAAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAhgAAAAAAAYACAAEAAYAAAAIAAAAAAAAAAUAAAB1aW50OAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAAgAAAAAAAABAAAAAAQAAABpbnQ4AAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAQAAABib29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee" + }, + { + "id": "pylit_testmultitypebatch_test_multi_type_record_batch", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_record_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce" + }, + { + "id": "pylit_testspecexamples_test_example_d_non_nullable_binary", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_d_non_nullable_binary", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1" + }, + { + "id": "pylit_testtemporaltypes_test_date32", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestTemporalTypes::test_date32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFKAAAAAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a" + }, + { + "id": "pylit_testprimitivetypes_test_uint8", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_uint8", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d" + }, + { + "id": "pylit_testtemporaltypes_test_time64_nanoseconds", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestTemporalTypes::test_time64_nanoseconds", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKmjsAAAAAAAAAAAAAAAAA8gUqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1" + }, + { + "id": "pylit_testprimitivetypes_test_uint16", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_uint16", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoAwAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc" + }, + { + "id": "pylit_testprimitivetypes_test_uint64", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_uint64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAypo7AAAAAAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a" + }, + { + "id": "pylit_teststructtypes_test_struct_with_nullable_children", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestStructTypes::test_struct_with_nullable_children", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAApP///xwAAAAMAAAAAAAADZAAAAACAAAAVAAAABgAAADU////EAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351" + }, + { + "id": "pylit_testprimitivetypes_test_int16", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_int16", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOgDAAAY/P9/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73" + }, + { + "id": "pylit_testspecexamples_test_example_a_two_column_table", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAMAAABhZ2UA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBbGljZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" + }, + { + "id": "pylit_testprimitivetypes_test_int64", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_int64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBCDwAAAAAAAAAAAAAAAADAvfD//////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05" + }, + { + "id": "pylit_testprimitivetypes_test_int8", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_int8", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA/38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a" + }, + { + "id": "pylit_testspecexamples_test_example_n_list_of_struct", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_n_list_of_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARWwAAAAAQAAAAgAAADA////sP///xwAAAAMAAAAAAAADYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABpdGVtcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361" + }, + { + "id": "pylit_testtemporaltypes_test_time32_milliseconds", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestTemporalTypes::test_time32_milliseconds", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIPAAAAAABAS0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd" + }, + { + "id": "pylit_testprimitivetypes_test_float64", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_float64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+D8AAAAAAAAAAB+F61G4HgnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda" + }, + { + "id": "pylit_testprimitivetypes_test_uint32", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_uint32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBCDwAAAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389" + }, + { + "id": "pylit_testspecexamples_test_example_i_empty_table", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_i_empty_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84" + }, + { + "id": "pylit_testspecexamples_test_example_k_struct_column", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_k_struct_column", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///xwAAAAMAAAAAAAADYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAEAAAAbmFtZQAAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAADAAAAYWdlAAYAAABwZXJzb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABgAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFsaWNlQm9iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0" + }, + { + "id": "pylit_testspecexamples_test_example_o_nested_struct", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_o_nested_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAUP///xwAAAAMAAAAAAAADeQAAAACAAAAqAAAAAgAAADc////dP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAJz///8QAAAAGAAAAAAAAAIUAAAAjP///yAAAAAAAAABAAAAAAEAAABxAAAAyP///xAAAAAYAAAAAAAAAhQAAAC4////IAAAAAAAAAEAAAAAAQAAAHAAAAAGAAAAbmVzdGVkAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c" + }, + { + "id": "pylit_testprimitivetypes_test_bool", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_bool", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f" + }, + { + "id": "pylit_testspecexamples_test_example_f_utf8_equivalence", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_f_utf8_equivalence", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286" + }, + { + "id": "pylit_testprimitivetypes_test_float32", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestPrimitiveTypes::test_float32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAPwAAAADD9UjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2" + }, + { + "id": "pylit_testspecexamples_test_example_e_column_order_independence", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_e_column_order_independence", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae" + }, + { + "id": "pylit_testbinaryvariedsizes_test_binary_varied_sizes", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestBinaryVariedSizes::test_binary_varied_sizes", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABEAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgMEBQYHCAkKCwwNDg//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1" + }, + { + "id": "pylit_testallnullarrays_test_all_null_int32", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_int32", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33" + }, + { + "id": "pylit_testlistoflist_test_list_of_list_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAKAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAFAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa" + }, + { + "id": "pylit_testlistofstruct_test_list_of_struct_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListOfStruct::test_list_of_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAkP///xgAAAAMAAAAAAAAFbAAAAABAAAACAAAAMD///+w////HAAAAAwAAAAAAAANhAAAAAIAAABIAAAACAAAAOT////U////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2" + }, + { + "id": "pylit_testrealisticbatch_test_realistic_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAgAQAAZAAAAAQAAAD8/v//GAAAAAwAAAAAAAEVPAAAAAEAAAAIAAAA8P7//6D///8QAAAAFAAAAAAAAAMQAAAAVv///wAAAQAAAAAABAAAAGl0ZW0AAAAACAAAAHJlYWRpbmdzAAAAANz///8cAAAADAAAAAAAAA2MAAAAAgAAAFQAAAAYAAAAUP///xAAFAAQAAAADwAEAAAACAAQAAAAEAAAABQAAAAAAAADEAAAAMb///8AAAIAAAAAAAMAAABsb24AEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAADAAAAbGF0AAYAAABjb29yZHMAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////94AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAMAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAB8AAAAEAAAAAMAAAAAAAAAAAAAAAYAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAACAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAABgAAAAAAAAAAAIAAAAAAAABAAAAAAAAAEACAAAAAAAAIAAAAAAAAACAAgAAAAAAAAEAAAAAAAAAwAIAAAAAAAAUAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpmZmZlZREAAAAAAAABBQAAAAAAAwElAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBSwM3MzMzMjF3AmpmZmZmZub8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAPwAAAEAAAEBAAACAQAAAoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de" + }, + { + "id": "pylit_testallnullarrays_test_all_null_string", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_string", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAADAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc" + }, + { + "id": "pylit_testsingleelementarrays_test_single_bool_false", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_bool_false", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155" + }, + { + "id": "pylit_testrealisticbatch_test_realistic_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAgAQAAZAAAAAQAAAD8/v//GAAAAAwAAAAAAAEVPAAAAAEAAAAIAAAA8P7//6D///8QAAAAFAAAAAAAAAMQAAAAVv///wAAAQAAAAAABAAAAGl0ZW0AAAAACAAAAHJlYWRpbmdzAAAAANz///8cAAAADAAAAAAAAA2MAAAAAgAAAFQAAAAYAAAAUP///xAAFAAQAAAADwAEAAAACAAQAAAAEAAAABQAAAAAAAADEAAAAMb///8AAAIAAAAAAAMAAABsb24AEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAADAAAAbGF0AAYAAABjb29yZHMAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792" + }, + { + "id": "pylit_testthreelevelstruct_test_three_level_struct_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xwAAAAMAAAAAAAADdwAAAACAAAAOAAAAAgAAACU////iP///xAAAAAYAAAAAAAAAhQAAAB4////IAAAAAAAAAEAAAAAAQAAAHgAAAC0////HAAAAAwAAAAAAAANgAAAAAIAAABEAAAACAAAAOT////Y////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAEAAAB6AAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHkAAAAFAAAAaW5uZXIAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAACAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAIABAAAAAAAAAgAAAAAAAADAAQAAAAAAAAEAAAAAAAAAAAIAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26" + }, + { + "id": "pylit_testnullablestructhasharray_test_nullable_struct_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestNullableStructHashArray::test_nullable_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ2AAAAAAgAAAEQAAAAIAAAA5P///9j///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAACAAAAAAAAAAQAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh5egAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21" + }, + { + "id": "pylit_testmixedstructlistbatch_test_mixed_struct_list_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAIAQAAXAAAAAQAAACI////GAAAAAwAAAAAAAEVOAAAAAEAAAAIAAAATP///6j///8UAAAADAAAAAAAARQMAAAAAAAAAGj///8EAAAAaXRlbQAAAAAEAAAAdGFncwAAAABo////HAAAAAwAAAAAAAANfAAAAAIAAABMAAAAGAAAAKT///8QABQAEAAOAA8ABAAAAAgAEAAAABAAAAAYAAAAAAABAhQAAACM////IAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAzP///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABtZXRhAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da" + }, + { + "id": "pylit_teststructemptybatch_test_struct_empty_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestStructEmptyBatch::test_struct_empty_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAYP///yAAAAAMAAAAAAAADcwAAAADAAAAmAAAAFAAAAAYAAAAXP///xAAFgAQAAAADwAEAAAACAAQAAAAGAAAABwAAAAAAAADGAAAAAAABgAIAAYABgAAAAAAAgAAAAAABQAAAHNjb3JlAAAAzP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAADAAAAYWdlABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAAAYAAABwZXJzb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93" + }, + { + "id": "pylit_testbatchallnullcolumn_test_batch_all_null_column", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestBatchAllNullColumn::test_batch_all_null_column", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAMAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752" + }, + { + "id": "pylit_testmixedstructlistbatch_test_mixed_struct_list_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0" + }, + { + "id": "pylit_testliststructnullableinnerfield_test_nullable_inner_field", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_nullable_inner_field", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAgP///xgAAAAMAAAAAAAAFcAAAAABAAAAGAAAALD///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a" + }, + { + "id": "pylit_teststructwithlistchild_test_struct_with_list_child_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAbP///xwAAAAMAAAAAAAADcgAAAACAAAAjAAAAAgAAADg////3P///xwAAAAMAAAAAAABDFQAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAtP///yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAAB0YWdzAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABgAAAHJlY29yZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2" + }, + { + "id": "pylit_testnullablestructbatch_test_nullable_struct_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestNullableStructBatch::test_nullable_struct_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ2AAAAAAgAAAEQAAAAIAAAA5P///9j///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b" + }, + { + "id": "pylit_testlistoflist_test_list_of_list_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAADAAAAY29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835" + }, + { + "id": "pylit_testsingleelementarrays_test_single_string", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_string", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhlbGxvIHdvcmxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648" + }, + { + "id": "pylit_testnonnullablelist_test_list_non_nullable", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestNonNullableList::test_list_non_nullable", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAYAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96" + }, + { + "id": "pylit_testemptyarrays_test_empty_int32_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_int32_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAACAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f" + }, + { + "id": "pylit_testlistoflist_test_list_of_list_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAADAAAAY29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAKAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAFAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f" + }, + { + "id": "pylit_testliststructnullableinnerfield_test_non_nullable_inner_field", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_non_nullable_inner_field", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAkP///xgAAAAMAAAAAAAAFbAAAAABAAAACAAAAMD///+w////HAAAAAwAAAAAAAANhAAAAAIAAABIAAAACAAAAOT////U////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAUAAABsYWJlbAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f" + }, + { + "id": "pylit_testschema4levelnestedstruct_test_schema_4_level_nested_struct", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestSchema4LevelNestedStruct::test_schema_4_level_nested_struct", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAfP///xgAAAAMAAAAAAAADdQAAAABAAAACAAAAKD///+c////GAAAAAwAAAAAAAANrAAAAAEAAAAIAAAAwP///7z///8YAAAADAAAAAAAAA2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGxlYWYAAAAAAgAAAGwzAAACAAAAbDIAAAIAAABsMQAABAAAAHJvb3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162" + }, + { + "id": "pylit_testschemalistofstructwithlist_test_schema_list_of_struct_with_list", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestSchemaListOfStructWithList::test_schema_list_of_struct_with_list", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABFRQBAAABAAAACAAAAFj///9M////IAAAAAwAAAAAAAAN6AAAAAMAAACsAAAAcAAAAAgAAACA////rP///xgAAAAMAAAAAAABFTgAAAABAAAACAAAAKD///+U////FAAAAAwAAAAAAAAUDAAAAAAAAAC8////BAAAAGl0ZW0AAAAABAAAAHRhZ3MAAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAwAAAG1zZwAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAABAAAAAAAAAAQAAAAACAAAAdHMAAAQAAABpdGVtAAAAAAYAAABldmVudHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb" + }, + { + "id": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAADkAAAAqAAAAAQAAAA4////HAAAAAwAAAAAAAANeAAAAAIAAABMAAAAGAAAAGj///8QABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAIAAAAAAAEAAABiAAAAnP///xQAAAAMAAAAAAAABgwAAAAAAAAAxP///wEAAABhAAAAAQAAAHoAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd" + }, + { + "id": "pylit_testnullableliststructnullablechildren_test_nullable_list_struct_nullable_children_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestNullableListStructNullableChildren::test_nullable_list_struct_nullable_children_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFcAAAAABAAAACAAAALD///+g////HAAAAAwAAAAAAAANlAAAAAIAAABYAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABpdGVtcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104" + }, + { + "id": "pylit_testfloatspecialvalues_test_float64_special_values", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestFloatSpecialValues::test_float64_special_values", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+H8AAAAAAADwfwAAAAAAAPD/AAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc" + }, + { + "id": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema_hash", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema_hash", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAADkAAAAqAAAAAQAAAA4////HAAAAAwAAAAAAAANeAAAAAIAAABMAAAAGAAAAGj///8QABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAIAAAAAAAEAAABiAAAAnP///xQAAAAMAAAAAAAABgwAAAAAAAAAxP///wEAAABhAAAAAQAAAHoAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe" + }, + { + "id": "pylit_teststructmixedtypes_test_struct_mixed_types_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestStructMixedTypes::test_struct_mixed_types_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590" + }, + { + "id": "pylit_testemptyarrays_test_empty_bool_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_bool_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////eAAAABAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoADAAAAAgABAAKAAAAIAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4" + }, + { + "id": "pylit_testlistofstruct_test_nullable_list_of_struct_hash_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestListOfStruct::test_nullable_list_of_struct_hash_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARWsAAAAAQAAAAgAAADA////tP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAADAAAAdmFsABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca" + }, + { + "id": "pylit_teststructfieldorderindependence_test_struct_3field_order_independence", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestStructFieldOrderIndependence::test_struct_3field_order_independence", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAjP///yAAAAAMAAAAAAAADagAAAADAAAAbAAAADAAAAAIAAAAwP///7T///8UAAAADAAAAAAAAAYMAAAAAAAAANz///8BAAAAYwAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAABhcnJheQAAAP////84AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAIAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABcAAAAEAAAAAIAAAAAAAAAAAAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAYAAAAAAAAAEABAAAAAAAAAgAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283" + }, + { + "id": "pylit_testunicodestrings_test_unicode_string_array", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestUnicodeStrings::test_unicode_string_array", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAMAAAAAAAAACAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAsAAAAAAAAAFwAAAAAAAAAXAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhlbGxv5LiW55WM8J+MjfCfjI7wn4yPY2Fmw6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486" + }, + { + "id": "pylit_testnestednullableinnerstruct_test_nested_nullable_inner_struct", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestNestedNullableInnerStruct::test_nested_nullable_inner_struct", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAQP///xwAAAAMAAAAAAAADfQAAAACAAAAuAAAABgAAADM////EAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQ1wAAAAAgAAADwAAAAMAAAABAAEAAQAAACc////EAAAABgAAAAAAAACFAAAAIz///8gAAAAAAAAAQAAAAABAAAAcQAAAMj///8QAAAAGAAAAAAAAAIUAAAAuP///yAAAAAAAAABAAAAAAEAAABwAAAABQAAAGlubmVyAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAADAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAUAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820" + }, + { + "id": "pylit_testlargeschema_test_large_schema_12_fields", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestLargeSchema::test_large_schema_12_fields", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgDAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAwAAAC4AgAAeAIAADgCAAAIAgAA1AEAAJgBAABsAQAARAEAABwBAADwAAAAYAAAAAQAAADE/f//GAAAAAwAAAAAAAEVQAAAAAEAAAAIAAAAsP7//+T9//8QAAAAGAAAAAAAAQIUAAAAmP3//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAMAAABmMTIA4P3//xwAAAAMAAAAAAAADXQAAAACAAAAOAAAAAgAAAAM////QP7//xQAAAAMAAAAAAABFAwAAAAAAAAAKP///wgAAABuZXN0ZWRfYgAAAAAw/v//EAAAABgAAAAAAAACFAAAACD+//8gAAAAAAAAAQAAAAAIAAAAbmVzdGVkX2EAAAAAAwAAAGYxMQCo/v//FAAAAAwAAAAAAAEIEAAAAAAAAAAy////AAAAAAMAAABmMTAAlP7//xQAAAAMAAAAAAAAEwwAAAAAAAAAuP///wMAAABmMDkA9P7//xQAAAAMAAAAAAABFAwAAAAAAAAA3P///wMAAABmMDgA3P7//xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAADAAAAZjA3AED///8QAAAAFAAAAAAAAQMQAAAAxv///wAAAgAAAAAAAwAAAGYwNgAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAMAAABmMDUAqP///xAAAAAYAAAAAAABAhQAAABc////QAAAAAAAAAEAAAAAAwAAAGYwNACY////EAAAABgAAAAAAAACFAAAAIj///8gAAAAAAAAAQAAAAADAAAAZjAzABAAFAAQAA4ADwAEAAAACAAQAAAAEAAAABgAAAAAAAECFAAAAMT///8QAAAAAAAAAQAAAAADAAAAZjAyABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAAgAAAAAAAABAAAAAAMAAABmMDEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d" + }, + { + "id": "pylit_testmultibatchstruct_test_multi_batch_struct", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestMultiBatchStruct::test_multi_batch_struct", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAnP///yAAAAAMAAAAAAAADZgAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAEAAAABgAAAAAAAECFAAAAMT///8gAAAAAAAAAQAAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2" + }, + { + "id": "pylit_testsingleelementarrays_test_single_int64", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_int64", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/jC1QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770" + }, + { + "id": "pylit_teststructwithlistchild_test_struct_with_list_child_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAbP///xwAAAAMAAAAAAAADcgAAAACAAAAjAAAAAgAAADg////3P///xwAAAAMAAAAAAABDFQAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAtP///yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAAB0YWdzAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABgAAAHJlY29yZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAwAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83" + }, + { + "id": "pylit_testthreelevelstruct_test_three_level_struct_schema", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_schema", + "method": "hash_schema", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAAB6AAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAHkAAAADAAAAbWlkABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAwAAAHRvcAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8" + }, + { + "id": "pylit_testbooleanarrays_test_bool_17_elements", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestBooleanArrays::test_bool_17_elements", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAARAAAAAAAAAAAAAAABAAAAEQAAAAAAAAADAAAAAAAAAAAAAAACAAAAAAAAAAAAAAADAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvfQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATTUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068" + }, + { + "id": "pylit_testmultibatchlist_test_multi_batch_list", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestMultiBatchList::test_multi_batch_list", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABQAAAGl0ZW1zAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAEAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519" + }, + { + "id": "pylit_testthreelevelstruct_test_three_level_struct_batch", + "description": "starfix-python test literal input: tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_batch", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAAB6AAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAHkAAAADAAAAbWlkABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAwAAAHRvcAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db" + }, + { + "id": "pylit_testspecexamples_test_example_a_two_column_table_2", + "description": "starfix-python test literal input: tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAMAAABhZ2UA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBbGljZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" } ], "relations": [ diff --git a/tests/test_arrow_digester.py b/tests/test_arrow_digester.py index 9e64258..bbb9af5 100644 --- a/tests/test_arrow_digester.py +++ b/tests/test_arrow_digester.py @@ -1,7 +1,10 @@ """Tests for the pure-Python Arrow digester. -Golden hash values are taken from the Rust test suite to ensure -byte-for-byte compatibility. +Hash format 2: every expected value is a Rust-produced format-2 value from +tests/golden/format1_to_format2.json (ITL-898); the format-1 values these tests +pinned originally map to them one to one. +The Rust values are the authoritative source of truth; these tests fail +immediately if the Python implementation diverges. """ import pyarrow as pa diff --git a/tests/test_golden_parity.py b/tests/test_golden_parity.py index 5fb8349..205c97a 100644 --- a/tests/test_golden_parity.py +++ b/tests/test_golden_parity.py @@ -1,9 +1,10 @@ """Golden-hash parity tests: Python must produce byte-for-byte identical hashes to Rust. -Every expected value below was generated by `cargo run --bin emit_golden` against -the Rust starfix crate *after* PR #11 was merged (commit on 2026-03-20). The Rust -values are treated as the authoritative source of truth; these tests are regression -guards that will fail immediately if the Python implementation diverges. +Hash format 2: every expected value is a Rust-produced format-2 value from +tests/golden/format1_to_format2.json (ITL-898); the format-1 values these tests +pinned originally map to them one to one. +The Rust values are the authoritative source of truth; these tests fail +immediately if the Python implementation diverges. Covers 36 distinct Arrow tables / arrays: - spec examples A, B, C, D, E, F, G, H, I, J, K, N, O @@ -46,7 +47,7 @@ def test_example_a_two_column_table(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + assert result == "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" def test_example_b_bool_array_with_nulls(self): """Example B: BooleanArray [true, NULL, false, true].""" @@ -64,7 +65,7 @@ def test_example_d_non_nullable_binary(self): """Example D: BinaryArray [b'hi', b''] — non-nullable; tests Binary→LargeBinary canonicalization.""" array = pa.array([b"hi", b""], type=pa.binary()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d" + assert result == "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1" def test_example_e_column_order_independence(self): """Example E: columns [x: Int32, y: Boolean nullable] — order must not matter.""" @@ -84,7 +85,7 @@ def test_example_e_column_order_independence(self): {"y": pa.array([True], type=pa.bool_()), "x": pa.array([10], type=pa.int32())}, schema=schema_yx, ) - expected = "000001f68bf6319f8ec4aa938e52dd911974348289fbdfb9b5ebed5e14e239a6d8a3a9" + expected = "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae" assert ArrowDigester.hash_record_batch(batch_xy).hex() == expected assert ArrowDigester.hash_record_batch(batch_yx).hex() == expected @@ -92,7 +93,7 @@ def test_example_f_utf8_equivalence(self): """Example F: Utf8 and LargeUtf8 arrays with the same data must hash identically.""" small = pa.array(["ab"], type=pa.utf8()) large = pa.array(["ab"], type=pa.large_utf8()) - expected = "000001f14d076ffc02533c6560f867b86cde7e15b1a0ac5a892b53697a609191cf307f" + expected = "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -116,7 +117,7 @@ def test_example_i_empty_table(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922" + assert result == "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84" def test_example_j_multi_batch_streaming(self): """Example J: batch-split independence — two batches == one combined batch.""" @@ -142,7 +143,7 @@ def test_example_k_struct_column(self): ) batch = pa.record_batch({"person": person_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001e3516302d68fd1fc4860fa4b7e0d4a6d60d500a9d7ccae79e445c5980021e4ec" + assert result == "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0" def test_example_n_list_of_struct(self): """Example N: {items: LargeList> nullable}. @@ -166,7 +167,7 @@ def test_example_n_list_of_struct(self): ) batch = pa.record_batch({"items": items_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000019c9cc6230a42e646a475ec1c8125fe396dcace351d64ff6e63e8f53d329c4895" + assert result == "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361" def test_example_o_nested_struct(self): """Example O: {s: Struct>} — two levels.""" @@ -185,7 +186,7 @@ def test_example_o_nested_struct(self): ) batch = pa.record_batch({"s": s_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001e732b8458782d9a331722698883617eec7cd1492028947b4ce3e97c7d6201550" + assert result == "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c" # --------------------------------------------------------------------------- @@ -197,17 +198,17 @@ class TestPrimitiveTypes: def test_bool(self): array = pa.array([True, False, None, True], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1" + assert result == "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f" def test_int8(self): array = pa.array([1, None, -1, 127], type=pa.int8()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc" + assert result == "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a" def test_int16(self): array = pa.array([1000, None, -1000, 32767], type=pa.int16()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4" + assert result == "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73" def test_int32(self): array = pa.array([42, None, -7, 0], type=pa.int32()) @@ -217,37 +218,37 @@ def test_int32(self): def test_int64(self): array = pa.array([1_000_000, None, -1_000_000, 0], type=pa.int64()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf" + assert result == "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05" def test_uint8(self): array = pa.array([0, 1, None, 255], type=pa.uint8()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd" + assert result == "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d" def test_uint16(self): array = pa.array([0, 1000, None, 65535], type=pa.uint16()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357" + assert result == "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc" def test_uint32(self): array = pa.array([0, 1_000_000, None, 4_294_967_295], type=pa.uint32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e" + assert result == "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389" def test_uint64(self): array = pa.array([0, 1_000_000_000, None, 18_446_744_073_709_551_615], type=pa.uint64()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b" + assert result == "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a" def test_float32(self): array = pa.array([1.5, None, -3.14, 0.0], type=pa.float32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa" + assert result == "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2" def test_float64(self): array = pa.array([1.5, None, -3.14, 0.0], type=pa.float64()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b" + assert result == "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda" # --------------------------------------------------------------------------- @@ -260,13 +261,13 @@ def test_date32(self): """Date32: days since Unix epoch.""" array = pa.array([0, 18993, None, -1], type=pa.date32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6" + assert result == "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a" def test_date64(self): """Date64: ms since Unix epoch.""" array = pa.array([0, 1_640_995_200_000, None, -86_400_000], type=pa.date64()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb" + assert result == "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8" def test_time32_seconds(self): """Time32(s): seconds since midnight.""" @@ -278,7 +279,7 @@ def test_time32_milliseconds(self): """Time32(ms): milliseconds since midnight.""" array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time32("ms")) result = ArrowDigester.hash_array(array).hex() - assert result == "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564" + assert result == "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd" def test_time64_microseconds(self): """Time64(us): microseconds since midnight.""" @@ -290,7 +291,7 @@ def test_time64_nanoseconds(self): """Time64(ns): nanoseconds since midnight.""" array = pa.array([1_000_000_000, None, 5_000_000_000, 0], type=pa.time64("ns")) result = ArrowDigester.hash_array(array).hex() - assert result == "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f" + assert result == "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1" # --------------------------------------------------------------------------- @@ -426,7 +427,7 @@ def test_struct_with_nullable_children(self): ) batch = pa.record_batch({"s": s_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000015f1992c5f9130aaa64aa1360e53ddd00b427855ae02e380f534a629353135680" + assert result == "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351" def test_struct_field_order_independence(self): """Struct fields in different order must hash identically (order-independence).""" @@ -524,7 +525,7 @@ def test_multi_type_record_batch(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000010f8bb471cb34975f20c4b221abff1a90b2d98f24217a2257e3298ee3d4e9f9c4" + assert result == "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce" def test_multi_type_schema_only(self): """Empty (no-rows) digester over the large multi-type schema.""" @@ -555,7 +556,7 @@ def test_multi_type_schema_only(self): pa.field("decimal128", pa.decimal128(38, 5), nullable=True), ]) result = ArrowDigester(schema).finalize().hex() - assert result == "0000010e62b3f3317d25413b7a4dc6e7a8a6e7c73a73c513cdbe9f9b1f5e5ec56f0e94" + assert result == "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee" # --------------------------------------------------------------------------- diff --git a/tests/test_golden_parity_r2.py b/tests/test_golden_parity_r2.py index b2a1886..4cc362a 100644 --- a/tests/test_golden_parity_r2.py +++ b/tests/test_golden_parity_r2.py @@ -1,9 +1,10 @@ """Golden-hash parity tests — Round 2. -Every expected value below was generated by `cargo run --bin emit_golden` against -the Rust starfix crate. The Rust values are treated as the authoritative source -of truth; these tests are regression guards that will fail immediately if the -Python implementation diverges. +Hash format 2: every expected value is a Rust-produced format-2 value from +tests/golden/format1_to_format2.json (ITL-898); the format-1 values these tests +pinned originally map to them one to one. +The Rust values are the authoritative source of truth; these tests fail +immediately if the Python implementation diverges. Covers 40+ distinct Arrow tables / arrays across categories: - Empty arrays (0 elements) @@ -48,13 +49,13 @@ def test_empty_int32_array(self): """Empty Int32 array (0 elements).""" array = pa.array([], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a" + assert result == "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f" def test_empty_bool_array(self): """Empty Boolean array (0 elements).""" array = pa.array([], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea" + assert result == "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4" # --------------------------------------------------------------------------- @@ -67,13 +68,13 @@ def test_all_null_int32(self): """Int32 array where every element is null.""" array = pa.array([None, None, None, None], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65" + assert result == "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33" def test_all_null_string(self): """LargeString array where every element is null.""" array = pa.array([None, None, None], type=pa.large_utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070" + assert result == "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc" # --------------------------------------------------------------------------- @@ -95,7 +96,7 @@ def test_bool_17_elements(self): type=pa.bool_(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a" + assert result == "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068" # --------------------------------------------------------------------------- @@ -108,19 +109,19 @@ def test_single_int64(self): """Single Int64 value: 9_999_999_999.""" array = pa.array([9_999_999_999], type=pa.int64()) result = ArrowDigester.hash_array(array).hex() - assert result == "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f" + assert result == "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770" def test_single_string(self): """Single LargeString value: 'hello world'.""" array = pa.array(["hello world"], type=pa.large_utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb" + assert result == "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648" def test_single_bool_false(self): """Single Boolean value: false.""" array = pa.array([False], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df" + assert result == "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155" # --------------------------------------------------------------------------- @@ -148,7 +149,7 @@ def test_nullable_struct_hash_array(self): mask=mask, ) result = ArrowDigester.hash_array(struct_array).hex() - assert result == "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5" + assert result == "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21" # --------------------------------------------------------------------------- @@ -178,7 +179,7 @@ def test_three_level_struct_batch(self): ) batch = pa.record_batch({"top": col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a" + assert result == "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db" def test_three_level_struct_schema(self): """Schema hash for three-level nested struct.""" @@ -192,7 +193,7 @@ def test_three_level_struct_schema(self): ]) schema = pa.schema([pa.field("top", outer_type, nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7" + assert result == "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8" def test_three_level_struct_hash_array(self): """Three-level struct via hash_array. @@ -221,7 +222,7 @@ def test_three_level_struct_hash_array(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0" + assert result == "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26" # --------------------------------------------------------------------------- @@ -252,7 +253,7 @@ def test_struct_with_list_child_batch(self): schema = pa.schema([pa.field("record", struct_type, nullable=False)]) batch = pa.record_batch([struct_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d" + assert result == "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83" def test_struct_with_list_child_schema(self): """Schema hash for struct with list child.""" @@ -262,7 +263,7 @@ def test_struct_with_list_child_schema(self): ]) schema = pa.schema([pa.field("record", struct_type, nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed" + assert result == "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2" # --------------------------------------------------------------------------- @@ -292,7 +293,7 @@ def test_nullable_struct_batch(self): schema = pa.schema([pa.field("s", struct_type, nullable=True)]) batch = pa.record_batch([struct_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048" + assert result == "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b" # --------------------------------------------------------------------------- @@ -325,7 +326,7 @@ def test_list_of_struct_hash_array(self): offsets = pa.array([0, 2, 4], type=pa.int64()) list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field)) result = ArrowDigester.hash_array(list_array).hex() - assert result == "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626" + assert result == "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2" def test_nullable_list_of_struct_hash_array(self): """Nullable LargeList via hash_array — row 1 is null. @@ -350,7 +351,7 @@ def test_nullable_list_of_struct_hash_array(self): mask = pa.array([False, True, False], type=pa.bool_()) list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field), mask=mask) result = ArrowDigester.hash_array(list_array).hex() - assert result == "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8" + assert result == "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca" # --------------------------------------------------------------------------- @@ -371,7 +372,7 @@ def test_list_non_nullable(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) result = ArrowDigester.hash_array(array).hex() - assert result == "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b" + assert result == "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96" # --------------------------------------------------------------------------- @@ -404,7 +405,7 @@ def test_struct_mixed_types_hash_array(self): fields=struct_fields, ) result = ArrowDigester.hash_array(struct_arr).hex() - assert result == "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3" + assert result == "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590" # --------------------------------------------------------------------------- @@ -446,7 +447,7 @@ def test_mixed_struct_list_batch(self): batch = pa.record_batch([id_arr, meta_arr, tags_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a" + assert result == "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0" def test_mixed_struct_list_schema(self): """Schema hash for mixed struct + list batch.""" @@ -460,7 +461,7 @@ def test_mixed_struct_list_schema(self): pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45" + assert result == "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da" # --------------------------------------------------------------------------- @@ -481,7 +482,7 @@ def test_empty_batch_complex_schema(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83" + assert result == "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd" def test_empty_batch_complex_schema_hash(self): """Schema hash (hash_schema) for same complex schema.""" @@ -494,7 +495,7 @@ def test_empty_batch_complex_schema_hash(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654" + assert result == "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe" # --------------------------------------------------------------------------- @@ -520,7 +521,7 @@ def test_batch_all_null_column(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494" + assert result == "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752" # --------------------------------------------------------------------------- @@ -536,7 +537,7 @@ def test_unicode_string_array(self): type=pa.large_utf8(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40" + assert result == "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486" # --------------------------------------------------------------------------- @@ -558,7 +559,7 @@ def test_binary_varied_sizes(self): type=pa.binary(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05" + assert result == "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1" # --------------------------------------------------------------------------- @@ -589,7 +590,7 @@ def test_struct_3field_order_independence(self): h1 = ArrowDigester.hash_array(s1).hex() h2 = ArrowDigester.hash_array(s2).hex() assert h1 == h2, "struct field order should not affect hash_array" - assert h1 == "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25" + assert h1 == "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283" # --------------------------------------------------------------------------- @@ -628,7 +629,7 @@ def test_nested_nullable_inner_struct(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c" + assert result == "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820" # --------------------------------------------------------------------------- @@ -657,7 +658,7 @@ def test_list_of_list_hash_array(self): type=pa.large_list(outer_field), ) result = ArrowDigester.hash_array(outer_list).hex() - assert result == "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc" + assert result == "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa" def test_list_of_list_batch(self): """Record batch with LargeList> column.""" @@ -677,7 +678,7 @@ def test_list_of_list_batch(self): schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) batch = pa.record_batch([outer_list], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10" + assert result == "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f" def test_list_of_list_schema(self): """Schema hash for list-of-list column.""" @@ -685,7 +686,7 @@ def test_list_of_list_schema(self): outer_field = pa.field("item", pa.large_list(inner_field), nullable=False) schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330" + assert result == "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835" # --------------------------------------------------------------------------- @@ -715,7 +716,7 @@ def test_large_schema_12_fields(self): pa.field("item", pa.int32(), nullable=True)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd" + assert result == "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d" # --------------------------------------------------------------------------- @@ -737,7 +738,7 @@ def test_schema_list_of_struct_with_list(self): ]), nullable=False)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000017f5258ff48e85b2a63cd1a29590ff3bfca39bf718365200ad74a8232bb654ec6" + assert result == "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb" # --------------------------------------------------------------------------- @@ -760,7 +761,7 @@ def test_schema_4_level_nested_struct(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e" + assert result == "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162" # --------------------------------------------------------------------------- @@ -800,7 +801,7 @@ def test_nullable_list_struct_nullable_children_batch(self): ]) batch = pa.record_batch([list_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96" + assert result == "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104" # --------------------------------------------------------------------------- @@ -820,7 +821,7 @@ def test_struct_empty_batch(self): ]) d = ArrowDigester(schema) result = d.finalize().hex() - assert result == "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773" + assert result == "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93" # --------------------------------------------------------------------------- @@ -858,7 +859,7 @@ def test_multi_batch_struct(self): d.update(batch1) d.update(batch2) result = d.finalize().hex() - assert result == "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c" + assert result == "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2" # --------------------------------------------------------------------------- @@ -892,7 +893,7 @@ def test_multi_batch_list(self): d.update(batch1) d.update(batch2) result = d.finalize().hex() - assert result == "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3" + assert result == "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519" # --------------------------------------------------------------------------- @@ -940,7 +941,7 @@ def test_nullable_inner_field(self): Golden value confirmed against Rust (PLT-1048). """ result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=True)).hex() - assert result == "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c" + assert result == "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a" def test_non_nullable_inner_field(self): """LargeList with nullable=False item field. @@ -950,7 +951,7 @@ def test_non_nullable_inner_field(self): Golden value confirmed against Rust (PLT-1048). """ result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=False)).hex() - assert result == "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c" + assert result == "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f" def test_nullable_differs_from_non_nullable(self): """Nullable vs non-nullable inner field must produce different hashes.""" @@ -976,7 +977,7 @@ def test_float64_special_values(self): type=pa.float64(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a" + assert result == "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc" # --------------------------------------------------------------------------- @@ -1021,7 +1022,7 @@ def test_realistic_batch(self): batch = pa.record_batch([name_arr, coords_arr, readings_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac" + assert result == "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de" def test_realistic_schema(self): """Schema hash for realistic batch.""" @@ -1035,4 +1036,4 @@ def test_realistic_schema(self): pa.field("item", pa.float32(), nullable=False)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356" + assert result == "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792" diff --git a/tests/test_metadata_hashing.py b/tests/test_metadata_hashing.py index bec5d48..ef5c6b8 100644 --- a/tests/test_metadata_hashing.py +++ b/tests/test_metadata_hashing.py @@ -127,7 +127,7 @@ def test_default_matches_pinned_golden_value(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch, include_metadata=False).hex() - assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + assert result == "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" class TestSchemaMetadataChangesHash: From c0f99f59af68ef461ee40a7c5b2672cb0e1f717d Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:03:06 -0800 Subject: [PATCH 25/49] ci: fetch format-2 fixtures with the raw media type (no 1 MB limit) (ITL-898) Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 72f1542..2143e4d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -110,10 +110,11 @@ jobs: - name: Fetch authoritative format-2 fixtures from starfix run: | + # Raw media type: no 1 MB limit (format2_v0.5.json is append-only and grows). # Tolerate missing files here so the next step prints the explanation. for f in format2_v0.5.json format1_to_format2.json; do - gh api "repos/nauticalab/starfix/contents/tests/golden/$f" \ - --jq '.content' | base64 -d > "/tmp/upstream_$f" || true + gh api -H "Accept: application/vnd.github.raw" \ + "repos/nauticalab/starfix/contents/tests/golden/$f" > "/tmp/upstream_$f" || true done env: GH_TOKEN: ${{ steps.app-token.outputs.token }} From e3831f3297d1e9e338bb4fe1bd6b35c38a68d0a9 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:04:33 -0800 Subject: [PATCH 26/49] ci: report a missing upstream fixture as missing, not as drift (ITL-898) On a 404 gh api prints the error body to stdout; keep the fetched file only when the request succeeds. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2143e4d..908a06d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -112,9 +112,12 @@ jobs: run: | # Raw media type: no 1 MB limit (format2_v0.5.json is append-only and grows). # Tolerate missing files here so the next step prints the explanation. + # On failure gh prints the error body to stdout, so keep the file only on success. for f in format2_v0.5.json format1_to_format2.json; do - gh api -H "Accept: application/vnd.github.raw" \ - "repos/nauticalab/starfix/contents/tests/golden/$f" > "/tmp/upstream_$f" || true + if ! gh api -H "Accept: application/vnd.github.raw" \ + "repos/nauticalab/starfix/contents/tests/golden/$f" > "/tmp/upstream_$f"; then + rm -f "/tmp/upstream_$f" + fi done env: GH_TOKEN: ${{ steps.app-token.outputs.token }} From 110aa1aa4825038361c7372d4baa306961b32d5e Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:11:01 -0800 Subject: [PATCH 27/49] build!: require pyarrow >= 19; remove old-pyarrow skips; CI job on pyarrow 19.0.0 (ITL-898) Developer decision 2026-11-11. Older pyarrow cannot read Decimal32/64 from Arrow IPC; with the floor at 19 every golden vector is decoded and matched on every supported version, so the version-gated skips (_pyarrow_compat, list_view, arrow.uuid) are removed. tests/test_golden_parity_r2.py builds its struct columns with the schema's field types (pyarrow 19 cannot cast nullable struct children to non-nullable ones); same data, same hashes. New CI job test-min-pyarrow runs the suite on Python 3.10 with exactly pyarrow 19.0.0. CHANGELOG and README state the requirement. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 20 +++++++++++++ CHANGELOG.md | 3 ++ README.md | 2 ++ pyproject.toml | 2 +- tests/_pyarrow_compat.py | 22 -------------- tests/test_format2.py | 4 --- tests/test_golden_parity_format2.py | 12 +------- tests/test_golden_parity_r2.py | 46 +++++++++++++++++++++-------- 8 files changed, 61 insertions(+), 50 deletions(-) delete mode 100644 tests/_pyarrow_compat.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 908a06d..87da0dd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,6 +30,26 @@ jobs: - name: Run tests run: uv run --python ${{ matrix.python-version }} pytest tests/ -v + test-min-pyarrow: + # The oldest supported pyarrow (pyproject: pyarrow>=19.0.0) on the oldest Python. + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + + - name: Install uv + uses: astral-sh/setup-uv@e58605a9b6da7c637471fab8847a5e5a6b8df081 # v5 + + - name: Set up Python 3.10 + run: uv python install 3.10 + + - name: Install dependencies + run: uv sync --dev --python 3.10 + + - name: Run tests on pyarrow 19.0.0 + run: | + uv run --python 3.10 --with pyarrow==19.0.0 python -c "import pyarrow; assert pyarrow.__version__ == '19.0.0', pyarrow.__version__; print('pyarrow', pyarrow.__version__)" + uv run --python 3.10 --with pyarrow==19.0.0 pytest tests/ -v + license-check: runs-on: ubuntu-latest steps: diff --git a/CHANGELOG.md b/CHANGELOG.md index 5a91f70..f2fc351 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -48,6 +48,9 @@ buffers: at 1M rows, `list` takes about 20 ms instead of an estimated 90 ### Changed (breaking) +- **Requires pyarrow >= 19** (was >= 14): older pyarrow cannot read Decimal32/Decimal64 data + from Arrow IPC, so the golden parity (every vector matched) holds for every supported + pyarrow version only from 19 on. - In every mode, `ValueError` is raised for schemas with duplicate or `/`-aliased field paths; for `ListView`, `LargeListView`, `Union` and `RunEndEncoded` types; for hashing data of `Null`, `FixedSizeList`, `Map`, `Interval` and view types (previously `NotImplementedError` diff --git a/README.md b/README.md index abf10a8..7c91750 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,8 @@ Produces stable SHA-256 hashes of Arrow schemas, tables, record batches and arra pip install starfix ``` +Requires Python >= 3.10 and pyarrow >= 19. + ## Usage ```python diff --git a/pyproject.toml b/pyproject.toml index d34f988..91af9e5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,7 +14,7 @@ keywords = ["arrow", "hashing"] classifiers = [ "Programming Language :: Python :: 3", ] -dependencies = ["pyarrow>=14.0.0"] +dependencies = ["pyarrow>=19.0.0"] [dependency-groups] dev = ["pytest>=9.0.2", "pip-licenses>=5.0.0"] diff --git a/tests/_pyarrow_compat.py b/tests/_pyarrow_compat.py deleted file mode 100644 index 1b39b64..0000000 --- a/tests/_pyarrow_compat.py +++ /dev/null @@ -1,22 +0,0 @@ -"""Golden vectors that older pyarrow versions cannot decode from Arrow IPC. - -pyproject allows pyarrow >= 14. Decimal32/Decimal64 IPC needs pyarrow >= 19 and the -Utf8View/BinaryView types need pyarrow >= 16. Tests that decode these vectors mark them -as strict expected failures, or leave them out, on such versions only. -""" - -from __future__ import annotations - -import pyarrow as pa - -_NEEDS = { - "decimal32": ({"type_decimal32_schema_f0", "type_decimal64_negative_scale_schema_f0"}, "Decimal32/Decimal64"), - "string_view": ({"type_utf8_view_schema_f0", "type_binary_view_schema_f0"}, "Utf8View/BinaryView"), -} - -UNREADABLE_HERE: dict[str, str] = { - vid: f"pyarrow {pa.__version__} cannot read {what} IPC" - for feature, (ids, what) in _NEEDS.items() - if not hasattr(pa, feature) - for vid in ids -} diff --git a/tests/test_format2.py b/tests/test_format2.py index 7e1daf1..049cb6e 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -411,8 +411,6 @@ def test_rejected_schemas(schema) -> None: def test_list_view_rejected() -> None: - if not hasattr(pa, "list_view"): - pytest.skip("pyarrow without list_view") with pytest.raises(ValueError): f2.hash_schema(pa.schema([pa.field("v", pa.list_view(pa.int8()))])) @@ -571,8 +569,6 @@ def test_extension_name_without_metadata_key_is_hashed_as_empty_metadata() -> No def test_builtin_uuid_extension_with_canonical_metadata() -> None: """arrow.uuid stored with an empty metadata value: exact (E1 covers other stored forms).""" - if not hasattr(pa, "uuid"): - pytest.skip("pyarrow without a registered arrow.uuid") stored = pa.schema([pa.field("u", pa.binary(16), metadata={ "ARROW:extension:name": "arrow.uuid", "ARROW:extension:metadata": ""})]) batch = pa.record_batch([pa.array([b"\x01" * 16, None], pa.binary(16))], schema=stored) diff --git a/tests/test_golden_parity_format2.py b/tests/test_golden_parity_format2.py index 0272655..4ed8501 100644 --- a/tests/test_golden_parity_format2.py +++ b/tests/test_golden_parity_format2.py @@ -3,8 +3,7 @@ Every expected hash in ``tests/golden/format2_v0.5.json`` was generated by ``cargo run --bin emit_golden_format2`` in the Rust starfix crate and is the authoritative source of truth; the file is a byte-for-byte copy and is never edited here. Every vector -and every relation is checked. The only skips are version-gated: vectors the installed -pyarrow cannot decode (see ``_pyarrow_compat``); CI runs a pyarrow that decodes all. +and every relation is checked, with no skips (pyarrow >= 19 decodes every vector). """ from __future__ import annotations @@ -19,7 +18,6 @@ import pyarrow as pa import pytest -from _pyarrow_compat import UNREADABLE_HERE from starfix import ArrowDigester @@ -66,12 +64,6 @@ def _hash(vector: dict[str, Any]) -> str: return result.hex() -def _skip_if_unreadable(*ids: str) -> None: - unreadable = [i for i in ids if i in UNREADABLE_HERE] - if unreadable: - pytest.skip(f"{unreadable}: {UNREADABLE_HERE[unreadable[0]]}") - - def test_fixture_is_well_formed() -> None: fixture = _fixture() assert fixture["format"] == 2 @@ -88,7 +80,6 @@ def test_fixture_is_well_formed() -> None: @pytest.mark.parametrize("vector", _vectors(), ids=lambda v: v["id"]) def test_golden_vector(vector: dict[str, Any]) -> None: - _skip_if_unreadable(vector["id"]) got = _hash(vector) assert got == vector["expected_hash"], ( f"Vector '{vector['id']}' mismatch: {vector['description']}\n" @@ -99,7 +90,6 @@ def test_golden_vector(vector: dict[str, Any]) -> None: @pytest.mark.parametrize("relation", _relations(), ids=lambda r: f"{r['kind']}:{'|'.join(r['ids'])}") def test_golden_relation(relation: dict[str, Any]) -> None: """Each relation holds for the pinned values and for the live Python hashes.""" - _skip_if_unreadable(*relation["ids"]) by_id = {v["id"]: v for v in _vectors()} ids = relation["ids"] pinned = {i: by_id[i]["expected_hash"] for i in ids} diff --git a/tests/test_golden_parity_r2.py b/tests/test_golden_parity_r2.py index 4cc362a..c22e2c4 100644 --- a/tests/test_golden_parity_r2.py +++ b/tests/test_golden_parity_r2.py @@ -39,6 +39,28 @@ from starfix.arrow_digester import ArrowDigester +def _with_type(arr: pa.Array, t: pa.DataType) -> pa.Array: + """`arr` rebuilt with the field nullability of struct type `t` (same data). + + pyarrow 19 cannot cast a struct whose children are nullable to one whose children + are not, which pa.record_batch(..., schema=...) would otherwise do. + """ + if not pa.types.is_struct(t) or not pa.types.is_struct(arr.type): + return arr + children = [_with_type(arr.field(i), t.field(i).type) for i in range(t.num_fields)] + mask = arr.is_null() if arr.null_count else None + return pa.StructArray.from_arrays(children, fields=list(t), mask=mask) + + +def _record_batch(columns, schema: pa.Schema) -> pa.RecordBatch: + if isinstance(columns, dict): + columns = [columns[f.name] for f in schema] + return pa.record_batch( + [_with_type(c, f.type) if isinstance(c, pa.Array) else c for c, f in zip(columns, schema)], + schema=schema, + ) + + # --------------------------------------------------------------------------- # Empty arrays # --------------------------------------------------------------------------- @@ -177,7 +199,7 @@ def test_three_level_struct_batch(self): [{"x": 100, "mid": {"y": 200, "z": 300}}], type=outer_type, ) - batch = pa.record_batch({"top": col}, schema=schema) + batch = _record_batch({"top": col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db" @@ -251,7 +273,7 @@ def test_struct_with_list_child_batch(self): names=["id", "tags"], ) schema = pa.schema([pa.field("record", struct_type, nullable=False)]) - batch = pa.record_batch([struct_arr], schema=schema) + batch = _record_batch([struct_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83" @@ -291,7 +313,7 @@ def test_nullable_struct_batch(self): pa.field("b", pa.bool_(), nullable=False), ]) schema = pa.schema([pa.field("s", struct_type, nullable=True)]) - batch = pa.record_batch([struct_array], schema=schema) + batch = _record_batch([struct_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b" @@ -445,7 +467,7 @@ def test_mixed_struct_list_batch(self): type=pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), ) - batch = pa.record_batch([id_arr, meta_arr, tags_arr], schema=schema) + batch = _record_batch([id_arr, meta_arr, tags_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0" @@ -513,7 +535,7 @@ def test_batch_all_null_column(self): pa.field("id", pa.int32(), nullable=False), pa.field("value", pa.large_utf8(), nullable=True), ]) - batch = pa.record_batch( + batch = _record_batch( { "id": pa.array([1, 2, 3], type=pa.int32()), "value": pa.array([None, None, None], type=pa.large_utf8()), @@ -676,7 +698,7 @@ def test_list_of_list_batch(self): type=pa.large_list(outer_field), ) schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) - batch = pa.record_batch([outer_list], schema=schema) + batch = _record_batch([outer_list], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f" @@ -799,7 +821,7 @@ def test_nullable_list_struct_nullable_children_batch(self): schema = pa.schema([ pa.field("items", pa.large_list(inner_field), nullable=True), ]) - batch = pa.record_batch([list_array], schema=schema) + batch = _record_batch([list_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104" @@ -847,13 +869,13 @@ def test_multi_batch_struct(self): [pa.array([1, 2], type=pa.int32()), pa.array([10, None], type=pa.int32())], names=["x", "y"], ) - batch1 = pa.record_batch([s1], schema=schema) + batch1 = _record_batch([s1], schema=schema) s2 = pa.StructArray.from_arrays( [pa.array([3], type=pa.int32()), pa.array([30], type=pa.int32())], names=["x", "y"], ) - batch2 = pa.record_batch([s2], schema=schema) + batch2 = _record_batch([s2], schema=schema) d = ArrowDigester(schema) d.update(batch1) @@ -881,13 +903,13 @@ def test_multi_batch_list(self): [[1, 2], None], type=list_type, ) - batch1 = pa.record_batch([arr1], schema=schema) + batch1 = _record_batch([arr1], schema=schema) arr2 = pa.array( [[3, 4, 5]], type=list_type, ) - batch2 = pa.record_batch([arr2], schema=schema) + batch2 = _record_batch([arr2], schema=schema) d = ArrowDigester(schema) d.update(batch1) @@ -1020,7 +1042,7 @@ def test_realistic_batch(self): mask=reading_mask, ) - batch = pa.record_batch([name_arr, coords_arr, readings_arr], schema=schema) + batch = _record_batch([name_arr, coords_arr, readings_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() assert result == "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de" From 40da996822c6f4e4a081635d03162f5cd309ab5f Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:12:39 -0800 Subject: [PATCH 28/49] fix(format2): atomic batch updates, dictionary-of-extension metadata, byte-bounded binary hashing (ITL-898) Copilot review on PR #9: - a batch rejected while traversed (unmasked null) no longer leaves earlier columns' entries updated: entries are snapshotted in O(nodes) (bit length, byte length, last partial byte, copies of the SHA-256 states) and restored on failure - a dictionary of a registered extension type keeps its ARROW:extension:* keys in Phase 2 (dictionaries are looked through, extensions are not) - variable-length values are serialized in updates of about 1 MiB; a value of at least that size is hashed straight from the data buffer - regression tests: unmasked nulls rejected (column, struct child, dictionary index to a null value), masked child null accepted, rollback with and without partial validity bytes, dictionary-of-extension metadata, byte budget Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 71 ++++++++++++++++++++++++++++++++------ tests/test_format2.py | 76 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 136 insertions(+), 11 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index dbe59e5..f2c4ea5 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -26,7 +26,8 @@ _SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" _U64 = struct.Struct(" int: @@ -270,7 +271,10 @@ def read_bytes(n: int) -> bytes: def _field_metadata(field: pa.Field) -> dict[str, str]: meta = _decode(field.metadata) - meta.update(_extension_metadata(field.type)) + t = field.type + while pa.types.is_dictionary(t): # a dictionary of an extension type keeps its keys + t = t.value_type + meta.update(_extension_metadata(t)) # Section 2.3: an absent ARROW:extension:metadata is hashed as "" (absent == empty). if "ARROW:extension:name" in meta: meta.setdefault("ARROW:extension:metadata", "") @@ -341,6 +345,17 @@ def _append_int(self, value: int, n: int) -> None: def entry_bytes(self) -> bytes: return _U64.pack(self._len) + bytes(self._bytes) + def snapshot(self) -> tuple[int, int, int | None]: + """O(1) state: appends only add bytes or change the last (partial) byte.""" + return self._len, len(self._bytes), (self._bytes[-1] if self._bytes else None) + + def restore(self, state: tuple[int, int, int | None]) -> None: + bit_len, byte_len, last = state + del self._bytes[byte_len:] + if last is not None: + self._bytes[-1] = last + self._len = bit_len + class _Entry: __slots__ = ("validity", "lengths", "values", "kind") @@ -352,6 +367,18 @@ def __init__(self, field: pa.Field) -> None: self.lengths = hashlib.sha256() if self.kind == "list" else None self.values = hashlib.sha256() if self.kind == "leaf" else None + def snapshot(self) -> tuple: + return ( + self.validity.snapshot() if self.validity is not None else None, + self.lengths.copy() if self.lengths is not None else None, + self.values.copy() if self.values is not None else None, + ) + + def restore(self, state: tuple) -> None: + validity, self.lengths, self.values = state + if validity is not None: + self.validity.restore(validity) + def to_bytes(self) -> bytes: out = b"" if self.validity is not None: @@ -417,12 +444,26 @@ def _hash_values(arr: pa.Array, digest) -> None: bufs = arr.buffers() offsets = memoryview(bufs[1])[arr.offset * size:(arr.offset + n + 1) * size].cast("q" if large else "i") data = memoryview(bufs[2]) if bufs[2] is not None else memoryview(b"") - for start in range(0, n, _CHUNK): - parts = [] - for i in range(start, min(start + _CHUNK, n)): - a, b = offsets[i], offsets[i + 1] - parts.append(_U64.pack(b - a)) - parts.append(data[a:b]) + # Small values are joined into updates of about _BYTE_BUDGET bytes; a value of at + # least that size is fed straight from the data buffer (no copy). + parts: list = [] + pending = 0 + for i in range(n): + a, b = offsets[i], offsets[i + 1] + size = b - a + if size >= _BYTE_BUDGET: + parts.append(_U64.pack(size)) + digest.update(b"".join(parts)) + digest.update(data[a:b]) + parts, pending = [], 0 + continue + parts.append(_U64.pack(size)) + parts.append(data[a:b]) + pending += 8 + size + if pending >= _BYTE_BUDGET: + digest.update(b"".join(parts)) + parts, pending = [], 0 + if parts: digest.update(b"".join(parts)) return raise ValueError(f"Hashing data of type {t} is not supported") # checked earlier (Section 7) @@ -522,9 +563,17 @@ def update(self, batch: pa.RecordBatch) -> None: schema_nodes(schema) # Section 7 if schema_key(schema, self._include_metadata, self._flags) != self._key: raise ValueError(_SCHEMA_MISMATCH) - for i in range(batch.num_columns): - field = schema.field(i) - _visit(field, batch.column(i), field.name, None, self._entries) + # A batch rejected while it is traversed (Section 7 item 4) leaves the digester + # exactly as it was. + saved = {path: entry.snapshot() for path, entry in self._entries.items()} + try: + for i in range(batch.num_columns): + field = schema.field(i) + _visit(field, batch.column(i), field.name, None, self._entries) + except BaseException: + for path, state in saved.items(): + self._entries[path].restore(state) + raise self._rows += batch.num_rows def finalize(self) -> bytes: diff --git a/tests/test_format2.py b/tests/test_format2.py index 049cb6e..36f5990 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -614,3 +614,79 @@ def test_slices_at_bit_and_byte_boundaries(offset: int) -> None: b_sliced = pa.record_batch([sliced], names=["c"]) b_fresh = pa.record_batch([fresh], names=["c"]) assert f2.hash_record_batch(b_sliced) == f2.hash_record_batch(b_fresh), (arr.type, offset) + + +# ── Copilot review round (PR #9) ───────────────────────────────────────── + + +def test_unmasked_null_in_non_nullable_column_rejected() -> None: + schema = pa.schema([pa.field("a", pa.int32(), nullable=False)]) + batch = pa.record_batch([pa.array([1, None], pa.int32())], schema=schema) + with pytest.raises(ValueError, match="Non-nullable"): + f2.hash_record_batch(batch) + + +def test_unmasked_null_in_non_nullable_struct_child_rejected() -> None: + st = pa.struct([pa.field("x", pa.int32(), nullable=False)]) + s = pa.StructArray.from_arrays([pa.array([1, None], pa.int32())], fields=list(st)) # struct valid, child null + with pytest.raises(ValueError, match="Non-nullable"): + f2.hash_record_batch(pa.record_batch([s], schema=pa.schema([pa.field("s", st, nullable=True)]))) + + +def test_dictionary_index_to_null_value_in_non_nullable_column_rejected() -> None: + arr = pa.DictionaryArray.from_arrays(pa.array([0, 1], pa.int8()), pa.array(["a", None])) + schema = pa.schema([pa.field("d", arr.type, nullable=False)]) + with pytest.raises(ValueError, match="Non-nullable"): + f2.hash_record_batch(pa.record_batch([arr], schema=schema)) + + +def test_child_null_masked_by_null_parent_is_accepted() -> None: + st = pa.struct([pa.field("x", pa.int32(), nullable=False)]) + s = pa.StructArray.from_arrays([pa.array([1, None], pa.int32())], fields=list(st), mask=pa.array([False, True])) + schema = pa.schema([pa.field("s", st, nullable=True)]) + final = sha(f2.hash_schema(schema)[3:], u64(2), u64(2) + b"\x01", sha(i32(1))) + assert f2.hash_record_batch(pa.record_batch([s], schema=schema)) == V + final + + +def test_rejected_batch_leaves_the_digester_unchanged() -> None: + """A batch rejected while it is traversed must not change the digester's state.""" + schema = pa.schema([pa.field("a", pa.int32(), nullable=False), pa.field("b", pa.int32(), nullable=False)]) + good = pa.record_batch([pa.array([1], pa.int32()), pa.array([2], pa.int32())], schema=schema) + bad = pa.record_batch([pa.array([7], pa.int32()), pa.array([None], pa.int32())], schema=schema) + d = f2.Digester(schema) + d.update(good) + with pytest.raises(ValueError): + d.update(bad) + assert d.finalize() == f2.hash_record_batch(good) + + +def test_dictionary_of_extension_metadata_is_hashed(point_type) -> None: + km = pa.schema([pa.field("p", pa.dictionary(pa.int32(), point_type("km")))]) + m = pa.schema([pa.field("p", pa.dictionary(pa.int32(), point_type("m")))]) + assert f2.hash_schema(km, include_metadata=True) != f2.hash_schema(m, include_metadata=True) + phase2 = f2.phase2_json(km) + assert '"ARROW:extension:name":"starfix.test.point"' in phase2 + assert '"ARROW:extension:metadata":"{\\"unit\\":\\"km\\"}"' in phase2 + + +def test_binary_values_hashed_with_a_byte_budget(monkeypatch) -> None: + """Large values are not copied into one joined buffer; the bytes are unchanged.""" + monkeypatch.setattr(f2, "_BYTE_BUDGET", 10) + values = [b"x" * 25, b"", b"abc", None, b"y" * 9, b"z" * 11] + arr = pa.array(values, pa.binary()) + expected = b"".join(u64(len(v)) + v for v in values if v is not None) + valid = u64(6) + bytes([0b110111]) + assert f2.hash_array(arr) == V + sha(header(0), b'"LargeBinary"', u64(6), valid, sha(expected)) + + +def test_rejected_batch_restores_partial_validity_bytes() -> None: + """Rollback restores validity bits that end mid-byte, and the hash states.""" + schema = pa.schema([pa.field("a", pa.int32(), nullable=True), pa.field("b", pa.utf8(), nullable=False)]) + good = pa.record_batch([pa.array([1, None, 3], pa.int32()), pa.array(["x", "y", "z"])], schema=schema) + bad = pa.record_batch([pa.array([None] * 7 + [4], pa.int32()), pa.array(["p"] * 7 + [None])], schema=schema) + d = f2.Digester(schema) + d.update(good) + with pytest.raises(ValueError): + d.update(bad) + d.update(good) + assert d.finalize() == f2.hash_table(pa.Table.from_batches([good, good])) From f85a1fa31933347ea4aec04247b2ef6e09cd812b Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:26:40 -0800 Subject: [PATCH 29/49] fix(format2): bounded memory for nullable leaves and finalization (ITL-898) Copilot review on PR #9: - nullable leaves are no longer filtered as a whole column: Booleans and fixed-width values are filtered in chunks (fixed-width chunks bounded by _BYTE_BUDGET bytes); strings and binary skip nulls while reading the original offsets/data buffers, so the valid payload is never copied - entries are fed to the final SHA-256 one by one (validity bits as a memoryview) instead of being joined into one byte string Same bytes: goldens and a chunk-size sweep test (budgets 1, 7, 64, 1 MiB) over nullable string, Int32, Boolean and FixedSizeBinary leaves. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 97 +++++++++++++++++++++++++---------------- tests/test_format2.py | 23 ++++++++++ 2 files changed, 83 insertions(+), 37 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index f2c4ea5..fba1b91 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -342,8 +342,9 @@ def _append_int(self, value: int, n: int) -> None: self._bytes += value.to_bytes((n + shift + 7) >> 3, "little") self._len += n - def entry_bytes(self) -> bytes: - return _U64.pack(self._len) + bytes(self._bytes) + def feed(self, digest) -> None: + digest.update(_U64.pack(self._len)) + digest.update(memoryview(self._bytes)) def snapshot(self) -> tuple[int, int, int | None]: """O(1) state: appends only add bytes or change the last (partial) byte.""" @@ -379,15 +380,14 @@ def restore(self, state: tuple) -> None: if validity is not None: self.validity.restore(validity) - def to_bytes(self) -> bytes: - out = b"" + def feed(self, digest) -> None: + """Section 3.2: [validity][lengths][values], fed without copying the bits.""" if self.validity is not None: - out += self.validity.entry_bytes() + self.validity.feed(digest) if self.lengths is not None: - out += self.lengths.digest() + digest.update(self.lengths.digest()) if self.values is not None: - out += self.values.digest() - return out + digest.update(self.values.digest()) def _resolve(arr: pa.Array) -> pa.Array: @@ -421,20 +421,33 @@ def _value_width(t: pa.DataType) -> int | None: return None -def _hash_values(arr: pa.Array, digest) -> None: - """Section 3.2 leaf value bytes of every element of `arr` (already valid-only).""" +def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: + """Section 3.2 leaf value bytes of the elements of `arr` whose bit in `bits` is 1. + + Works in bounded chunks: the valid values are never materialized as a whole. + """ t = arr.type n = len(arr) if pa.types.is_boolean(t): for start in range(0, n, _CHUNK): - chunk = pc.cast(arr.slice(start, _CHUNK), pa.uint8()) + chunk = arr.slice(start, _CHUNK) + if bits is not None: + chunk = chunk.filter(bits.slice(start, _CHUNK)) + chunk = pc.cast(chunk, pa.uint8()) digest.update(memoryview(chunk.buffers()[1])[chunk.offset:chunk.offset + len(chunk)]) return width = _value_width(t) if width is not None: - if n: - raw = memoryview(arr.buffers()[1]) - digest.update(raw[arr.offset * width:(arr.offset + n) * width]) + if bits is None: + if n: + digest.update(memoryview(arr.buffers()[1])[arr.offset * width:(arr.offset + n) * width]) + return + rows = max(1, _BYTE_BUDGET // width) + for start in range(0, n, rows): + chunk = arr.slice(start, rows).filter(bits.slice(start, rows)) + if len(chunk): + raw = memoryview(chunk.buffers()[1]) + digest.update(raw[chunk.offset * width:(chunk.offset + len(chunk)) * width]) return if pa.types.is_string(t) or pa.types.is_large_string(t) or pa.types.is_binary(t) or pa.types.is_large_binary(t): if n == 0: @@ -444,25 +457,33 @@ def _hash_values(arr: pa.Array, digest) -> None: bufs = arr.buffers() offsets = memoryview(bufs[1])[arr.offset * size:(arr.offset + n + 1) * size].cast("q" if large else "i") data = memoryview(bufs[2]) if bufs[2] is not None else memoryview(b"") - # Small values are joined into updates of about _BYTE_BUDGET bytes; a value of at - # least that size is fed straight from the data buffer (no copy). + # Nulls are skipped while reading the original buffers. Small values are joined + # into updates of about _BYTE_BUDGET bytes; a value of at least that size is fed + # straight from the data buffer (no copy). parts: list = [] pending = 0 - for i in range(n): - a, b = offsets[i], offsets[i + 1] - size = b - a - if size >= _BYTE_BUDGET: - parts.append(_U64.pack(size)) - digest.update(b"".join(parts)) - digest.update(data[a:b]) - parts, pending = [], 0 - continue - parts.append(_U64.pack(size)) - parts.append(data[a:b]) - pending += 8 + size - if pending >= _BYTE_BUDGET: - digest.update(b"".join(parts)) - parts, pending = [], 0 + pack = _U64.pack + for chunk_start in range(0, n, _CHUNK): + chunk_end = min(chunk_start + _CHUNK, n) + offs = offsets[chunk_start:chunk_end + 1].tolist() + pairs = zip(offs, offs[1:]) + if bits is not None: + flags = bits.slice(chunk_start, chunk_end - chunk_start).to_pylist() + pairs = (pair for pair, ok in zip(pairs, flags) if ok) + for a, b in pairs: + size_i = b - a + if size_i >= _BYTE_BUDGET: + parts.append(pack(size_i)) + digest.update(b"".join(parts)) + digest.update(data[a:b]) + parts, pending = [], 0 + continue + parts.append(pack(size_i)) + parts.append(data[a:b]) + pending += 8 + size_i + if pending >= _BYTE_BUDGET: + digest.update(b"".join(parts)) + parts, pending = [], 0 if parts: digest.update(b"".join(parts)) return @@ -498,8 +519,8 @@ def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None _visit(child, arr.field(i), f"{path}/{child.name}", bits, entries) return - valid = arr if bits is None else arr.filter(bits) if entry.kind == "list": + valid = arr if bits is None else arr.filter(bits) if len(valid): lengths = pc.cast(valid.value_lengths(), pa.uint64()) entry.lengths.update(memoryview(lengths.buffers()[1])[lengths.offset * 8:(lengths.offset + len(lengths)) * 8]) @@ -507,7 +528,7 @@ def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None _visit(arr.type.value_field, valid.flatten(), path + "/", None, entries) return - _hash_values(valid, entry.values) + _hash_values(arr, bits, entry.values) def _is_unsupported_data(t: pa.DataType) -> bool: @@ -530,8 +551,10 @@ def _new_entries(nodes: list[tuple[str, pa.Field]]) -> dict[str, _Entry]: return {path: _Entry(field) for path, field in nodes} -def _finish_entries(entries: dict[str, _Entry]) -> bytes: - return b"".join(entries[path].to_bytes() for path in sorted(entries)) +def _feed_entries(entries: dict[str, _Entry], digest) -> None: + """All entries in byte-wise node-path order, fed one by one (no joined copy).""" + for path in sorted(entries): + entries[path].feed(digest) # --------------------------------------------------------------------------- @@ -579,7 +602,7 @@ def update(self, batch: pa.RecordBatch) -> None: def finalize(self) -> bytes: final = hashlib.sha256(self._schema_digest) final.update(_U64.pack(self._rows)) - final.update(_finish_entries(self._entries)) + _feed_entries(self._entries, final) return VERSION_BYTES + final.digest() @@ -616,5 +639,5 @@ def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct final = hashlib.sha256(header(flags)) final.update(type_json(array.type, flags).encode()) final.update(_U64.pack(len(array))) - final.update(_finish_entries(entries)) + _feed_entries(entries, final) return VERSION_BYTES + final.digest() diff --git a/tests/test_format2.py b/tests/test_format2.py index 36f5990..09d05ac 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -690,3 +690,26 @@ def test_rejected_batch_restores_partial_validity_bytes() -> None: d.update(bad) d.update(good) assert d.finalize() == f2.hash_table(pa.Table.from_batches([good, good])) + + +@pytest.mark.parametrize("budget", [1, 7, 64, 1 << 20]) +def test_nullable_leaves_hashed_in_bounded_chunks(budget, monkeypatch) -> None: + """Chunked processing of nullable leaves gives the spec bytes at any chunk size.""" + monkeypatch.setattr(f2, "_BYTE_BUDGET", budget) + monkeypatch.setattr(f2, "_CHUNK", max(1, budget // 8)) + strs = ["a", None, "bcd", "", None, "é" * 3, "z"] + ints = [1, None, 3, None, 5, 6, 7] + bools = [True, None, False, True, None, False, True] + fsb = [b"\x01\x02", None, b"\x03\x04", b"\x05\x06", None, b"\x07\x08", b"\x09\x0a"] + cases = [ + (pa.array(strs).slice(1), b"".join(u64(len(s.encode())) + s.encode() for s in strs[1:] if s is not None)), + (pa.array(ints, pa.int32()).slice(1), i32(*[v for v in ints[1:] if v is not None])), + (pa.array(bools).slice(1), bytes(int(v) for v in bools[1:] if v is not None)), + (pa.array(fsb, pa.binary(2)).slice(1), b"".join(v for v in fsb[1:] if v is not None)), + ] + for arr, value_bytes in cases: + valid = [v is not None for v in arr.to_pylist()] + bits = sum(1 << i for i, ok in enumerate(valid) if ok) + validity = u64(len(arr)) + bits.to_bytes((len(arr) + 7) // 8, "little") + expected = V + sha(header(0), f2.type_json(arr.type, 0).encode(), u64(len(arr)), validity, sha(value_bytes)) + assert f2.hash_array(arr) == expected, (arr.type, budget) From 3085d954f4408424bcc453dbb8c0c183bd7446f9 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:37:34 -0800 Subject: [PATCH 30/49] feat: legacy 0.4 mode, starfix.legacy.v0_4, byte-identical to starfix-python 0.4.0 (ITL-898) Developer decision 2026-11-11: keep the 0.4 behaviour available under an explicitly labelled legacy name; the main API stays format 2. - src/starfix/legacy/v0_4.py: starfix-python v0.4.0 src/starfix/arrow_digester.py (tag v0.4.0, d2ed97e) VERBATIM below a frozen-module header (its sha256 equals the PyPI starfix==0.4.0 module); stdlib + pyarrow imports only; nothing shared with format 2. starfix/legacy/__init__.py re-exports nothing. - tests/test_legacy_v0_4_*.py: the five v0.4.0 test files restored with their original format-1 values (import pointed at the legacy module; the r2 file builds struct inputs so pyarrow 19 can construct them), including the include_metadata_v0.3.json golden: 193 passed - tests/test_legacy_v0_4_frozen.py: sha256 pin of the legacy file, and no imports between the legacy and format-2 modules - scripts/legacy_differential.py + CI job legacy-differential: ~2800 results over 400 seeded random inputs and the Python-0.4 quirks, against the released starfix==0.4.0 in an isolated environment: 0 differ (a one-character mutation of the legacy file is caught) - README 'Legacy 0.4 mode' (purpose, never for new data, defects, Python-vs-Rust 0.4 divergence table), CHANGELOG, tests/golden/README.md Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 18 + CHANGELOG.md | 5 + README.md | 46 +- scripts/legacy_differential.py | 223 ++++ src/starfix/legacy/__init__.py | 8 + src/starfix/legacy/v0_4.py | 924 ++++++++++++++ tests/golden/README.md | 2 +- tests/test_legacy_v0_4_arrow_digester.py | 556 +++++++++ tests/test_legacy_v0_4_frozen.py | 41 + tests/test_legacy_v0_4_golden_parity.py | 710 +++++++++++ ...test_legacy_v0_4_golden_parity_metadata.py | 130 ++ tests/test_legacy_v0_4_golden_parity_r2.py | 1063 +++++++++++++++++ tests/test_legacy_v0_4_metadata_hashing.py | 382 ++++++ 13 files changed, 4105 insertions(+), 3 deletions(-) create mode 100644 scripts/legacy_differential.py create mode 100644 src/starfix/legacy/__init__.py create mode 100644 src/starfix/legacy/v0_4.py create mode 100644 tests/test_legacy_v0_4_arrow_digester.py create mode 100644 tests/test_legacy_v0_4_frozen.py create mode 100644 tests/test_legacy_v0_4_golden_parity.py create mode 100644 tests/test_legacy_v0_4_golden_parity_metadata.py create mode 100644 tests/test_legacy_v0_4_golden_parity_r2.py create mode 100644 tests/test_legacy_v0_4_metadata_hashing.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 87da0dd..11558bf 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -50,6 +50,24 @@ jobs: uv run --python 3.10 --with pyarrow==19.0.0 python -c "import pyarrow; assert pyarrow.__version__ == '19.0.0', pyarrow.__version__; print('pyarrow', pyarrow.__version__)" uv run --python 3.10 --with pyarrow==19.0.0 pytest tests/ -v + legacy-differential: + # starfix.legacy.v0_4 must stay byte-identical to the released starfix-python 0.4.0 (PyPI). + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + + - name: Install uv + uses: astral-sh/setup-uv@e58605a9b6da7c637471fab8847a5e5a6b8df081 # v5 + + - name: Set up Python 3.12 + run: uv python install 3.12 + + - name: Install dependencies + run: uv sync --dev --python 3.12 + + - name: Compare starfix.legacy.v0_4 with starfix==0.4.0 from PyPI + run: uv run --python 3.12 python scripts/legacy_differential.py + license-check: runs-on: ubuntu-latest steps: diff --git a/CHANGELOG.md b/CHANGELOG.md index f2fc351..30aa897 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,6 +39,11 @@ buffers: at 1M rows, `list` takes about 20 ms instead of an estimated 90 ### Added +- **Legacy 0.4 mode**, `starfix.legacy.v0_4`: the starfix-python 0.4.0 hasher (format 1), + byte for byte, frozen, for reading or matching data hashed by 0.4.x only. Never use it for + new data. Pinned by the restored 0.4.0 tests and golden file and by a differential test + against the released `starfix==0.4.0`. + - Keyword-only options `ordered_columns` and `ordered_struct_fields` on `ArrowDigester(...)`, `hash_schema`, `hash_record_batch`, `hash_table` and `hash_array`: make column order and struct field order (at every depth) part of the hash. Default off. diff --git a/README.md b/README.md index 7c91750..449690e 100644 --- a/README.md +++ b/README.md @@ -107,8 +107,50 @@ every hash are the format number: | 1 | `00 00 01` | ≤ 0.4 | Lost information for some inputs (Booleans, nullable structs, lists of nullable lists or structs, row counts, and in Python a list of numeric dictionary values). | | 2 | `00 00 02` | 0.5 | Lossless layout, the two order options, rejections in every mode. | -Format-1 hashes can be computed with starfix 0.4 (`pip install "starfix<0.5"` in a separate -environment). Starfix 0.5 computes format 2 only. +Format-1 hashes of starfix-python 0.4 are still available through the frozen +[legacy 0.4 mode](#legacy-04-mode). + +## Legacy 0.4 mode + +```python +from starfix.legacy.v0_4 import ArrowDigester as LegacyArrowDigester # hash format 1 + +old_key = LegacyArrowDigester.hash_table(table) # 00 00 01 ..., as starfix-python 0.4.x +``` + +`starfix.legacy.v0_4` reproduces **starfix-python 0.4.0 byte for byte**: same API +(`ArrowDigester(schema, *, include_metadata=False)`, `update`, `finalize`, `hash_schema`, +`hash_record_batch`, `hash_table`, `hash_array`), same hashes, same exceptions. It exists **only +to read or match data hashed by starfix-python 0.4.x** (for example to find stored data under +its old key). **Never hash new data with it**: use `starfix.ArrowDigester`. + +It is frozen: never fixed and never extended (no order options). Its code is the 0.4.0 module +verbatim, kept apart from the format-2 code. Its output is pinned by the restored 0.4.0 tests and golden file, and by a differential +test against the released `starfix==0.4.0` package. + +Known defects, kept on purpose (all fixed in format 2): + +- Booleans are bit-packed per batch without a count: `[true]` and `[true, false, false]` in a + non-nullable column hash the same, and splitting rows into batches can change the hash. +- A null struct hashes like a struct whose fields are all null, and null struct rows vanish + under non-nullable fields. +- A list whose element is a nullable list loses its own lengths; a list of nullable structs + does not distinguish a null element. +- The row count of zero-column tables and empty structs is not hashed. +- A list of dictionary-encoded fixed-width values (for example `list>`) + hashes the dictionary indices instead of the values. + +starfix-python 0.4 also differed from the Rust crate 0.4 on these inputs. The legacy mode keeps +the **Python** behaviour, because that is what data hashed with starfix-python 0.4 used: + +| Input | starfix-python 0.4 (legacy mode) | Rust starfix 0.4 | +|---|---|---| +| schema with a `Map` column | Map JSON without the value type and `keys_sorted` | entries field (key and value) and `keys_sorted` | +| `include_metadata` with metadata on map fields | value field metadata at `m/`; key ignored | entries field metadata at `m/` | +| `hash_array` of a struct with non-ASCII field names | names escaped as `\uXXXX` | raw UTF-8 | +| schema with `Null`, `Interval`, `Utf8View` or `BinaryView` columns | raises `NotImplementedError` | hashes | +| list of dictionary-encoded fixed-width values | hashes the dictionary indices | hashes the values | +| streamed batch whose schema differs from the digester's | accepted | rejected | ## License diff --git a/scripts/legacy_differential.py b/scripts/legacy_differential.py new file mode 100644 index 0000000..dece655 --- /dev/null +++ b/scripts/legacy_differential.py @@ -0,0 +1,223 @@ +"""Differential test: starfix.legacy.v0_4 against the released starfix-python 0.4.0. + +Usage (from the repository root): + + uv run python scripts/legacy_differential.py [--seeds N] + +The driver hashes seeded random inputs with ``starfix.legacy.v0_4`` (this checkout), then runs +this same script with ``--impl release`` in an isolated environment containing the released +``starfix==0.4.0`` from PyPI and the same pyarrow version, and requires every result to be +byte-identical (exceptions must match by type). Both processes build the inputs themselves +from the seeds, so sliced arrays keep their offsets. Exit status 0 means identical. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import random +import subprocess +import sys +import tempfile +from pathlib import Path + +import pyarrow as pa + +RELEASE_SHA256 = "fc67e0622b484d3dd3ba94bf906571d1bd3565eb854d40feb2da1dcbaa431bec" # 0.4.0 arrow_digester.py + +_LEAVES = [ + pa.int8(), pa.int16(), pa.int32(), pa.int64(), pa.uint8(), pa.uint64(), pa.float32(), pa.float64(), + pa.date32(), pa.timestamp("us"), pa.timestamp("ms", tz="UTC"), pa.duration("s"), pa.time32("ms"), + pa.decimal128(10, 2), pa.binary(4), pa.utf8(), pa.large_utf8(), pa.binary(), pa.bool_(), "dict", "dict_int", +] + + +def _random_type(rng: random.Random, depth: int) -> pa.DataType: + kind = rng.random() + if depth >= 3 or kind < 0.45: + leaf = rng.choice(_LEAVES) + if leaf == "dict": + return pa.dictionary(pa.int32(), pa.utf8()) + if leaf == "dict_int": + return pa.dictionary(pa.int32(), pa.int64()) + return leaf + if kind < 0.75: + element = pa.field("item", _random_type(rng, depth + 1), nullable=rng.random() < 0.6) + return pa.large_list(element) if rng.random() < 0.3 else pa.list_(element) + names = rng.sample(["a", "b", "c", "d"], rng.randint(1, 3)) + return pa.struct([pa.field(n, _random_type(rng, depth + 1), nullable=rng.random() < 0.6) for n in names]) + + +def _leaf_values(t: pa.DataType, n: int, nullable: bool, rng: random.Random) -> pa.Array: + from decimal import Decimal + + def value(): + if pa.types.is_boolean(t): + return rng.random() < 0.5 + if pa.types.is_floating(t): + return rng.uniform(-1e3, 1e3) + if pa.types.is_decimal(t): + return Decimal(rng.randint(-99999, 99999)) / 100 + if pa.types.is_fixed_size_binary(t): + return bytes(rng.randrange(256) for _ in range(t.byte_width)) + if pa.types.is_binary(t) or pa.types.is_large_binary(t): + return bytes(rng.randrange(256) for _ in range(rng.randint(0, 5))) + if pa.types.is_string(t) or pa.types.is_large_string(t): + return "".join(rng.choice("xyzé") for _ in range(rng.randint(0, 5))) + if pa.types.is_dictionary(t): + return rng.choice(["p", "q", "r"] if pa.types.is_string(t.value_type) else [7, 8, 9]) + if pa.types.is_temporal(t): + return rng.randint(0, 20000) + if pa.types.is_unsigned_integer(t): + return rng.randint(0, 2 ** min(t.bit_width, 16) - 1) + return rng.randint(-(2 ** (t.bit_width - 1)), 2 ** (t.bit_width - 1) - 1) + + values = [None if nullable and rng.random() < 0.25 else value() for _ in range(n)] + if pa.types.is_dictionary(t): + return pa.array(values, t.value_type).dictionary_encode() + if pa.types.is_temporal(t) and not pa.types.is_date(t): + return pa.array(values, pa.int64() if t.bit_width == 64 else pa.int32()).cast(t) + if pa.types.is_date(t): + return pa.array(values, pa.int32()).cast(t) + return pa.array(values, t) + + +def _random_array(t: pa.DataType, n: int, nullable: bool, rng: random.Random) -> pa.Array: + pad = rng.randint(0, 3) + total = n + pad + mask = pa.array([rng.random() < 0.25 for _ in range(total)], pa.bool_()) if nullable else None + if pa.types.is_list(t) or pa.types.is_large_list(t): + lengths = [rng.choice([0, 0, 1, 2, 3]) for _ in range(total)] + offsets = [0] + for length in lengths: + offsets.append(offsets[-1] + length) + child = _random_array(t.value_type, offsets[-1], t.value_field.nullable, rng) + cls = pa.LargeListArray if pa.types.is_large_list(t) else pa.ListArray + index_type = pa.int64() if pa.types.is_large_list(t) else pa.int32() + arr = cls.from_arrays(pa.array(offsets, index_type), child, mask=mask) + if arr.type != t: + arr = arr.cast(t) + elif pa.types.is_struct(t): + children = [_random_array(f.type, total, f.nullable, rng) for f in t] + arr = pa.StructArray.from_arrays(children, fields=list(t), mask=mask) + else: + arr = _leaf_values(t, total, nullable, rng) + return arr.slice(rng.randint(0, pad), n) + + +def _metadata(rng: random.Random) -> dict[str, str] | None: + if rng.random() < 0.5: + return None + return {rng.choice(["unit", "z", "é", "a"]): rng.choice(["kg", "", "v1", "ü"]) for _ in range(rng.randint(1, 2))} + + +def _random_batch(rng: random.Random, rows: int) -> pa.RecordBatch: + fields, columns = [], [] + for i in range(rng.randint(1, 3)): + t = _random_type(rng, 0) + nullable = rng.random() < 0.6 + fields.append(pa.field(f"col{i}", t, nullable=nullable, metadata=_metadata(rng))) + columns.append(_random_array(t, rows, nullable, rng)) + return pa.record_batch(columns, schema=pa.schema(fields, metadata=_metadata(rng))) + + +def _quirk_cases(): + """Inputs on which starfix-python 0.4.0 differed from Rust 0.4.0 (kept in legacy).""" + value = pa.struct([pa.field("z", pa.int32()), pa.field("a", pa.int8())]) + map_schema = pa.schema([pa.field("m", pa.map_(pa.utf8(), pa.field("value", value, metadata={"u": "kg"})))]) + yield "map_schema", lambda D: D.hash_schema(map_schema) + yield "map_schema_metadata", lambda D: D.hash_schema(map_schema, include_metadata=True) + non_ascii = pa.StructArray.from_arrays([pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32())]) + yield "non_ascii_hash_array", lambda D: D.hash_array(non_ascii) + for name, t in (("null", pa.null()), ("interval", pa.month_day_nano_interval()), ("utf8_view", pa.string_view())): + yield f"schema_{name}", lambda D, t=t: D.hash_schema(pa.schema([pa.field("c", t)])) + child = pa.array([10, 20, 30, 10]).dictionary_encode() + lst = pa.ListArray.from_arrays(pa.array([0, 2, 3, 4], pa.int32()), child) + yield "list_of_int_dictionary", lambda D: D.hash_array(lst) + good = pa.record_batch([pa.array([1], pa.int32())], names=["a"]) + other = pa.record_batch([pa.array([1], pa.int64())], names=["a"]) + + def unchecked_stream(D): + d = D(good.schema) + d.update(other) # 0.4.0 does not check batches against the schema + return d.finalize() + + yield "stream_without_batch_check", unchecked_stream + + +def _cases(seeds: int): + yield from _quirk_cases() + for seed in range(seeds): + rng = random.Random(seed) + rows = rng.choice([0, 1, 2, 5, 17, 40]) + batch = _random_batch(rng, rows) + cuts = sorted(rng.sample(range(rows + 1), k=min(rows + 1, rng.randint(1, 3)))) + pieces = [batch.slice(a, b - a) for a, b in zip([0, *cuts], [*cuts, rows], strict=True)] + + def stream(D, schema=batch.schema, pieces=pieces): + d = D(schema) + for piece in pieces: + d.update(piece) + return d.finalize() + + yield f"{seed}:batch", lambda D, b=batch: D.hash_record_batch(b) + yield f"{seed}:batch_metadata", lambda D, b=batch: D.hash_record_batch(b, include_metadata=True) + yield f"{seed}:schema_metadata", lambda D, b=batch: D.hash_schema(b.schema, include_metadata=True) + yield f"{seed}:stream", stream + yield f"{seed}:table", lambda D, s=batch.schema, p=pieces: D.hash_table(pa.Table.from_batches(p, schema=s)) + for i, column in enumerate(batch.columns): + yield f"{seed}:array{i}", lambda D, c=column: D.hash_array(c) + + +def _run(impl: str, seeds: int) -> dict[str, str]: + if impl == "release": + import starfix.arrow_digester as module + + digest = hashlib.sha256(Path(module.__file__).read_bytes()).hexdigest() + if digest != RELEASE_SHA256: + raise SystemExit(f"not the starfix 0.4.0 release module: {module.__file__} ({digest})") + else: + import starfix.legacy.v0_4 as module + D = module.ArrowDigester + results = {} + for name, call in _cases(seeds): + try: + results[name] = call(D).hex() + except Exception as e: # noqa: BLE001 - exceptions must match by type + results[name] = f"raises {type(e).__name__}" + return results + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + parser.add_argument("--impl", choices=["driver", "legacy", "release"], default="driver") + parser.add_argument("--seeds", type=int, default=400) + parser.add_argument("--out") + args = parser.parse_args() + if args.impl != "driver": + results = _run(args.impl, args.seeds) + Path(args.out).write_text(json.dumps(results)) + return 0 + + legacy = _run("legacy", args.seeds) + with tempfile.TemporaryDirectory() as tmp: + out = Path(tmp) / "release.json" + python = f"{sys.version_info.major}.{sys.version_info.minor}" + subprocess.run( + ["uv", "run", "--no-project", "--python", python, "--with", "starfix==0.4.0", + "--with", f"pyarrow=={pa.__version__}", "python", str(Path(__file__).resolve()), + "--impl", "release", "--seeds", str(args.seeds), "--out", str(out)], + check=True, cwd=tmp, + ) + release = json.loads(out.read_text()) + differ = sorted(k for k in legacy if legacy[k] != release.get(k)) + sorted(set(release) - set(legacy)) + raised = sum(1 for v in legacy.values() if v.startswith("raises")) + print(f"{len(legacy)} results compared ({raised} raise the same exception in both); {len(differ)} differ") + for key in differ[:20]: + print(f" DIFFER {key}: legacy={legacy.get(key)} release={release.get(key)}") + return 1 if differ else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/starfix/legacy/__init__.py b/src/starfix/legacy/__init__.py new file mode 100644 index 0000000..8375e7c --- /dev/null +++ b/src/starfix/legacy/__init__.py @@ -0,0 +1,8 @@ +"""Frozen legacy hash formats of starfix-python. + +Each submodule reproduces one released version byte for byte, so that data hashed by that +version stays findable. Import the version explicitly, for example +``from starfix.legacy.v0_4 import ArrowDigester``; nothing is re-exported here. + +Never hash new data with a legacy module: use ``starfix.ArrowDigester`` (hash format 2). +""" diff --git a/src/starfix/legacy/v0_4.py b/src/starfix/legacy/v0_4.py new file mode 100644 index 0000000..0fe954d --- /dev/null +++ b/src/starfix/legacy/v0_4.py @@ -0,0 +1,924 @@ +# ===================================================================================== +# FROZEN LEGACY MODULE: starfix-python 0.4 hash format (format 1, prefix 00 00 01). +# +# This file is starfix-python v0.4.0's src/starfix/arrow_digester.py (tag v0.4.0, commit +# d2ed97e), VERBATIM below this header. It exists ONLY to read or match data hashed by +# starfix-python 0.4.x; never hash new data with it (use starfix.ArrowDigester, format 2). +# Its known defects (collisions, batch-split dependence, differences from Rust 0.4) are +# kept on purpose and listed in the README section "Legacy 0.4 mode". +# +# DO NOT EDIT: tests/test_legacy_v0_4_frozen.py pins this file's sha256, and the restored +# v0.4.0 tests (tests/test_legacy_v0_4_*.py) pin its output. +# ===================================================================================== +"""Pure-Python implementation of the starfix Arrow logical hasher. + +Implements the byte-layout specification defined in the starfix Rust crate +(``nauticalab/starfix docs/byte-layout-spec.md``). +""" + +from __future__ import annotations + +import hashlib +import json +import struct +from collections import OrderedDict +from typing import TYPE_CHECKING, Protocol + +if TYPE_CHECKING: + import pyarrow as pa + + +class _Hasher(Protocol): + """Minimal protocol for a hash accumulator (e.g. ``hashlib.sha256()``).""" + + def update(self, data: bytes | bytearray, /) -> None: ... + + +VERSION_BYTES = b"\x00\x00\x01" +DELIMITER = "/" + + +# --------------------------------------------------------------------------- +# Bit-vector helper (LSB-first packing, matching bitvec) +# --------------------------------------------------------------------------- + +class _BitVec: + """Minimal LSB-first u8 bit vector compatible with Rust bitvec. + + Matches Arrow's native validity bitmap layout. + """ + + __slots__ = ("_bytes", "_len") + + def __init__(self) -> None: + self._bytes = bytearray() + self._len = 0 + + def push(self, bit: bool) -> None: + byte_idx = self._len >> 3 + bit_idx = self._len & 7 # LSB-first: bit 0 is least significant + if byte_idx >= len(self._bytes): + self._bytes.append(0) + if bit: + self._bytes[byte_idx] |= 1 << bit_idx + self._len += 1 + + def extend_true(self, count: int) -> None: + for _ in range(count): + self.push(True) + + def __len__(self) -> int: + return self._len + + def raw_bytes(self) -> bytes: + return bytes(self._bytes) + + +# --------------------------------------------------------------------------- +# Schema / DataType serialization (spec Section 2) +# --------------------------------------------------------------------------- + +def _data_type_to_value(dt: pa.DataType) -> object: + """Convert a pyarrow DataType to the JSON-compatible value that matches + the canonical form described in spec Section 2.1. + + Types are normalized: Utf8→LargeUtf8, Binary→LargeBinary, List→LargeList, + Dictionary→value_type. Struct fields are sorted alphabetically. + """ + import pyarrow as pa + + # Normalize: Dictionary → recurse on value type + if pa.types.is_dictionary(dt): + return _data_type_to_value(dt.value_type) + + if pa.types.is_struct(dt): + # Sort struct fields alphabetically by name + fields = [dt.field(i) for i in range(dt.num_fields)] + fields.sort(key=lambda f: f.name) + fields_json = [_inner_field_to_value(f) for f in fields] + return {"Struct": fields_json} + if pa.types.is_list(dt) or pa.types.is_large_list(dt): + return {"LargeList": _element_type_to_value(dt.value_field)} + if pa.types.is_fixed_size_list(dt): + return {"FixedSizeList": [_element_type_to_value(dt.value_field), dt.list_size]} + if pa.types.is_map(dt): + return {"Map": [_inner_field_to_value(dt.key_field.with_name("entries")), False]} + + # Primitive / leaf types – must match Arrow-Rust serde + return _primitive_data_type_string(dt) + + +def _primitive_data_type_string(dt: pa.DataType) -> object: + """Return the serde_json representation that arrow-rs produces.""" + import pyarrow as pa + + _simple = { + pa.bool_(): "Boolean", + pa.int8(): "Int8", + pa.uint8(): "UInt8", + pa.int16(): "Int16", + pa.uint16(): "UInt16", + pa.int32(): "Int32", + pa.uint32(): "UInt32", + pa.int64(): "Int64", + pa.uint64(): "UInt64", + pa.float16(): "Float16", + pa.float32(): "Float32", + pa.float64(): "Float64", + pa.date32(): "Date32", + pa.date64(): "Date64", + pa.utf8(): "LargeUtf8", + pa.large_utf8(): "LargeUtf8", + pa.binary(): "LargeBinary", + pa.large_binary(): "LargeBinary", + } + if dt in _simple: + return _simple[dt] + + if pa.types.is_decimal(dt): + if dt.bit_width == 32: + return {"Decimal32": [dt.precision, dt.scale]} + if dt.bit_width == 64: + return {"Decimal64": [dt.precision, dt.scale]} + if dt.bit_width == 128: + return {"Decimal128": [dt.precision, dt.scale]} + if dt.bit_width == 256: + return {"Decimal256": [dt.precision, dt.scale]} + + if pa.types.is_time32(dt): + unit = "Second" if dt.unit == "s" else "Millisecond" + return {"Time32": unit} + if pa.types.is_time64(dt): + unit = "Microsecond" if dt.unit == "us" else "Nanosecond" + return {"Time64": unit} + + if pa.types.is_timestamp(dt): + unit_map = {"s": "Second", "ms": "Millisecond", "us": "Microsecond", "ns": "Nanosecond"} + unit = unit_map[dt.unit] + if dt.tz is None: + return {"Timestamp": [unit, None]} + return {"Timestamp": [unit, dt.tz]} + + if pa.types.is_duration(dt): + unit_map = {"s": "Second", "ms": "Millisecond", "us": "Microsecond", "ns": "Nanosecond"} + return {"Duration": unit_map[dt.unit]} + + if pa.types.is_fixed_size_binary(dt): + return {"FixedSizeBinary": dt.byte_width} + + raise NotImplementedError(f"Unsupported data type: {dt}") + + +def _inner_field_to_value(field: pa.Field) -> dict: + """Convert a field to JSON with name, data_type, and nullable.""" + return { + "name": field.name, + "data_type": _data_type_to_value(field.type), + "nullable": field.nullable, + } + + +def _element_type_to_value(field: pa.Field) -> dict: + """Convert a container element field to JSON with only data_type and nullable (no name). + + Used for list and fixed-size list element types, matching Rust ``element_type_to_value``. + """ + return { + "data_type": _data_type_to_value(field.type), + "nullable": field.nullable, + } + + +def _sort_json_value(value: object) -> object: + """Recursively sort JSON object keys (matching Rust ``sort_json_value``).""" + if isinstance(value, dict): + return OrderedDict(sorted((k, _sort_json_value(v)) for k, v in value.items())) + if isinstance(value, list): + return [_sort_json_value(v) for v in value] + return value + + +def _serialized_schema(schema: pa.Schema) -> str: + fields: dict[str, object] = {} + for i in range(len(schema)): + field = schema.field(i) + value = { + "data_type": _data_type_to_value(field.type), + "nullable": field.nullable, + } + fields[field.name] = _sort_json_value(value) + # Sort by field name (BTreeMap ordering) + sorted_fields = OrderedDict(sorted(fields.items())) + return json.dumps(sorted_fields, separators=(",", ":"), ensure_ascii=False) + + +# --------------------------------------------------------------------------- +# Metadata helpers (Phase 2 schema hashing — PLT-1734) +# --------------------------------------------------------------------------- + +def _sort_metadata(metadata) -> dict[str, str]: + """Decode PyArrow's bytes-keyed/valued metadata into a sorted str-keyed/valued dict. + + Returns an empty dict when metadata is None or empty. + Arrow IPC spec guarantees metadata keys and values are valid UTF-8. + The str fallback in the key/value decoding is defensive for direct callers. + """ + if not metadata: + return {} + return dict(sorted( + (k.decode("utf-8") if isinstance(k, bytes) else k, + v.decode("utf-8") if isinstance(v, bytes) else v) + for k, v in metadata.items() + )) + + +def _collect_nested_field_metadata( + field, path: str +) -> dict[str, dict[str, str]]: + """Recursively collect metadata from a field and its nested children. + + Returns a dict sorted by path: {path: sorted_metadata_dict}. + Only fields with non-empty metadata are included. + + Path convention (matches the data-hashing BTreeMap paths): + - Struct children: "{parent_path}/{child_name}" + - List/LargeList/FixedSizeList/Map element: "{parent_path}/" (trailing slash, no element name) + + For Map types, only the value/item field is traversed; Map key fields are + intentionally skipped (no path exists for them in the data-hashing BTreeMap). + """ + import pyarrow as pa + + result: dict[str, dict[str, str]] = {} + + if field.metadata: + result[path] = _sort_metadata(field.metadata) + + if pa.types.is_struct(field.type): + for i in range(field.type.num_fields): + child = field.type.field(i) + child_path = f"{path}{DELIMITER}{child.name}" + result.update(_collect_nested_field_metadata(child, child_path)) + elif ( + pa.types.is_list(field.type) + or pa.types.is_large_list(field.type) + or pa.types.is_fixed_size_list(field.type) + ): + element_path = f"{path}{DELIMITER}" + result.update(_collect_nested_field_metadata(field.type.value_field, element_path)) + elif pa.types.is_map(field.type): + element_path = f"{path}{DELIMITER}" + result.update(_collect_nested_field_metadata(field.type.item_field, element_path)) + + return dict(sorted(result.items())) + + +def _update_metadata_hash(hasher: _Hasher, schema: pa.Schema) -> None: + """Feed Phase 2 metadata JSON into ``hasher`` (only when metadata is present). + + Builds a compact JSON string of the form: + {"fields": {"": {"": "", ...}, ...}, "schema": {"": "", ...}} + + ``"fields"`` is omitted when no field (at any nesting level) has metadata. + ``"schema"`` is omitted when the schema has no metadata. + Nothing is written when both would be absent (empty-metadata invariant). + """ + import pyarrow as pa + + # Collect all field metadata recursively. + # _collect_nested_field_metadata returns per-subtree sorted paths, but + # cross-field order depends on schema field order, so we sort globally below. + all_field_meta: dict[str, dict[str, str]] = {} + for i in range(len(schema)): + field = schema.field(i) + all_field_meta.update(_collect_nested_field_metadata(field, field.name)) + + meta_doc: dict[str, object] = {} + if all_field_meta: + meta_doc["fields"] = dict(sorted(all_field_meta.items())) + if schema.metadata: + meta_doc["schema"] = _sort_metadata(schema.metadata) + + if meta_doc: + hasher.update(json.dumps(meta_doc, separators=(",", ":"), ensure_ascii=False).encode()) + + +def _hash_schema(schema: pa.Schema, include_metadata: bool = False) -> bytes: + h = hashlib.sha256() + h.update(_serialized_schema(schema).encode()) + if include_metadata: + _update_metadata_hash(h, schema) + return h.digest() + + +# --------------------------------------------------------------------------- +# DigestBufferType (spec Section 3: null_bits, structural, data) +# +# Each entry is a 3-tuple: (BitVec|None, sha256|None, sha256|None) +# [0] null_bits – present when nullable +# [1] structural – present for list entries +# [2] data – present for leaf and list-leaf entries +# --------------------------------------------------------------------------- + +def _new_data_only(nullable: bool) -> tuple: + """Leaf field entry (spec Section 3 — data-only or validity+data).""" + return (_BitVec() if nullable else None, None, hashlib.sha256()) + + +def _new_structural_only(nullable: bool) -> tuple: + """List-level entry whose value is a struct or nested list (spec Section 3).""" + return (_BitVec() if nullable else None, hashlib.sha256(), None) + + +def _new_list_leaf(nullable: bool) -> tuple: + """List-level entry whose value is a leaf type (spec Section 3).""" + return (_BitVec() if nullable else None, hashlib.sha256(), hashlib.sha256()) + + +def _new_validity_only() -> tuple: + """Nullable parent entry — just null_bits, no structural or data (spec Section 3).""" + return (_BitVec(), None, None) + + +# --------------------------------------------------------------------------- +# Type decomposition into BTreeMap entries (spec Sections 3.4, 3.5) +# --------------------------------------------------------------------------- + +def _extract_type_entries( + data_type: pa.DataType, + nullable: bool, + path: str, + out: dict[str, tuple], +) -> None: + """Recursively decompose a data type into BTreeMap entries. + + This implements the recursive decomposition described in spec Section 3: + - Structs are transparent — no entry, recurse into sorted children + - Lists create validity-only + structural/data entries + - Leaves create data entries + """ + import pyarrow as pa + canonical = _normalize_data_type(data_type) + + if pa.types.is_struct(canonical): + # Struct is transparent — no entry for the struct itself. + # Recurse into children sorted alphabetically (spec Section 3.5). + children = [canonical.field(i) for i in range(canonical.num_fields)] + children.sort(key=lambda f: f.name) + for child in children: + child_path = f"{path}{DELIMITER}{child.name}" if path else child.name + _extract_type_entries(child.type, child.nullable, child_path, out) + + elif pa.types.is_large_list(canonical) or pa.types.is_list(canonical): + # Nullable list: validity-only entry at `path` (spec Section 3.4) + if nullable: + out[path] = _new_validity_only() + + # List level: entry at path + "/" (spec Section 3.4) + list_path = f"{path}{DELIMITER}" + inner_field = canonical.value_field + inner_canonical = _normalize_data_type(inner_field.type) + + if pa.types.is_struct(inner_canonical): + # List: structural-only at list_path, struct children get own entries + out[list_path] = _new_structural_only(inner_field.nullable) + _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out) + elif pa.types.is_large_list(inner_canonical) or pa.types.is_list(inner_canonical): + # List: structural-only, recurse into inner list + out[list_path] = _new_structural_only(inner_field.nullable) + _extract_type_entries(inner_field.type, inner_field.nullable, list_path, out) + else: + # List: list-leaf entry with both structural + data + out[list_path] = _new_list_leaf(inner_field.nullable) + + else: + # Leaf type: data entry + out[path] = _new_data_only(nullable) + + +def _extract_fields(field: pa.Field, parent: str, out: dict[str, tuple]) -> None: + """Extract BTreeMap entries from a schema field (record-batch path).""" + full_name = f"{parent}{DELIMITER}{field.name}" if parent else field.name + _extract_type_entries(field.type, field.nullable, full_name, out) + + +# --------------------------------------------------------------------------- +# Type normalization (spec Section 2.1 — type canonicalization) +# --------------------------------------------------------------------------- + +def _normalize_data_type(dt: pa.DataType) -> pa.DataType: + """Recursively normalize a DataType to its canonical large equivalent.""" + import pyarrow as pa + + if pa.types.is_dictionary(dt): + return _normalize_data_type(dt.value_type) + if dt == pa.utf8(): + return pa.large_utf8() + if dt == pa.binary(): + return pa.large_binary() + if pa.types.is_list(dt) or pa.types.is_large_list(dt): + inner = _normalize_field(dt.value_field) + return pa.large_list(inner) + if pa.types.is_struct(dt): + fields = [_normalize_field(dt.field(i)) for i in range(dt.num_fields)] + return pa.struct(fields) + if pa.types.is_fixed_size_list(dt): + inner = _normalize_field(dt.value_field) + return pa.list_(inner, dt.list_size) + if pa.types.is_map(dt): + key_field = _normalize_field(dt.key_field) + item_field = _normalize_field(dt.item_field) + return pa.map_(key_field.type, item_field.type, keys_sorted=dt.keys_sorted) + return dt + + +def _normalize_field(field: pa.Field) -> pa.Field: + """Normalize a single field: keep name and nullability, normalize the data type.""" + import pyarrow as pa + return pa.field(field.name, _normalize_data_type(field.type), field.nullable) + + +# --------------------------------------------------------------------------- +# Array normalization helper +# --------------------------------------------------------------------------- + +def _normalize_array(data_type, array): + """Normalize small Arrow variants to their large canonical equivalents. + + Returns (effective_data_type, effective_array). + """ + import pyarrow as pa + + if pa.types.is_string(data_type) and not pa.types.is_large_string(data_type): + return pa.large_utf8(), array.cast(pa.large_utf8()) + if pa.types.is_binary(data_type) and not pa.types.is_large_binary(data_type): + return pa.large_binary(), array.cast(pa.large_binary()) + if pa.types.is_list(data_type) and not pa.types.is_large_list(data_type): + target = pa.large_list(data_type.value_field) + return target, array.cast(target) + if pa.types.is_dictionary(data_type): + effective_type = data_type.value_type + return _normalize_array(effective_type, array.cast(effective_type)) + return data_type, array + + +# --------------------------------------------------------------------------- +# Recursive traversal — populates BTreeMap entries from array data +# (spec Sections 3.1–3.5) +# --------------------------------------------------------------------------- + +def _combine_null_masks(own_valid, ancestor_valid): + """AND-combine two validity lists. Returns None if all valid.""" + if own_valid is None and ancestor_valid is None: + return None + if own_valid is None: + return ancestor_valid + if ancestor_valid is None: + return own_valid + return [a and b for a, b in zip(own_valid, ancestor_valid)] + + +def _get_validity_list(array): + """Return a list of bools (True=valid) or None if no nulls.""" + if array.null_count == 0: + return None + return [array[i].is_valid for i in range(len(array))] + + +def _traverse_and_update(data_type, nullable, array, path, ancestor_nulls, fields): + """Top-down recursive traversal that routes data to BTreeMap entries. + + Parameters: + data_type: Arrow data type of the array + nullable: whether this position is nullable + array: the Arrow array to hash + path: current BTreeMap key path + ancestor_nulls: list of bools from ancestor struct nulls, or None + fields: the BTreeMap of entries to populate + """ + import pyarrow as pa + + effective_type, effective_array = _normalize_array(data_type, array) + canonical = _normalize_data_type(effective_type) + + if pa.types.is_large_list(canonical): + _traverse_list(effective_array, canonical.value_field, nullable, path, ancestor_nulls, fields) + elif pa.types.is_struct(canonical): + _traverse_struct(effective_array, nullable, path, ancestor_nulls, fields) + else: + _traverse_leaf(effective_type, effective_array, path, ancestor_nulls, fields) + + +def _traverse_list(array, value_field, nullable, path, ancestor_nulls, fields): + """Traverse a list array, populating validity/structural/data entries (spec Section 3.4).""" + import pyarrow as pa + + # If nullable, record list-level validity at `path` + if nullable: + entry = fields.get(path) + if entry is not None: + null_bits = entry[0] + if null_bits is not None: + own_valid = _get_validity_list(array) + effective = _combine_null_masks(own_valid, ancestor_nulls) + if effective is not None: + for v in effective: + null_bits.push(v) + else: + null_bits.extend_true(len(array)) + + list_path = f"{path}{DELIMITER}" + + # Determine effective null buffer for skipping null list elements + own_valid = _get_validity_list(array) + effective_nulls = _combine_null_masks(own_valid, ancestor_nulls) + + # For each row, write structural info and recurse into non-null elements + offsets = array.offsets + for i in range(len(array)): + is_valid = effective_nulls is None or effective_nulls[i] + if is_valid: + start = offsets[i].as_py() + end = offsets[i + 1].as_py() + sub_array = array.values.slice(start, end - start) + sub_len = len(sub_array) + + # Write list length to structural digest at list_path + entry = fields.get(list_path) + if entry is not None and entry[1] is not None: + entry[1].update(struct.pack(" int | None: + """Return byte width for fixed-size types, or None for variable-length.""" + import pyarrow as pa + + _sizes = { + pa.int8(): 1, pa.uint8(): 1, + pa.int16(): 2, pa.uint16(): 2, pa.float16(): 2, + pa.int32(): 4, pa.uint32(): 4, pa.float32(): 4, pa.date32(): 4, + pa.int64(): 8, pa.uint64(): 8, pa.float64(): 8, pa.date64(): 8, + } + if dt in _sizes: + return _sizes[dt] + if pa.types.is_time32(dt): + return 4 + if pa.types.is_time64(dt): + return 8 + if pa.types.is_timestamp(dt): + return 8 # int64 physical storage; unit/tz are schema metadata + if pa.types.is_duration(dt): + return 8 # int64 physical storage; unit is schema metadata + if pa.types.is_decimal(dt): + return dt.bit_width // 8 + if pa.types.is_fixed_size_binary(dt): + return dt.byte_width + return None + + +def _hash_fixed_size_data(arr, data_digest, element_size: int, effective_nulls) -> None: + """Hash a fixed-width array's data bytes (spec Section 3.1).""" + bufs = arr.buffers() + data_buf = bufs[1] + offset = arr.offset + + raw = data_buf.to_pybytes() + start = offset * element_size + + if effective_nulls is None: + # Non-nullable or all valid: feed entire contiguous buffer + end = start + len(arr) * element_size + data_digest.update(raw[start:end]) + else: + # Nullable: feed only valid elements + has_nulls = any(not v for v in effective_nulls) + if has_nulls: + for i in range(len(arr)): + if effective_nulls[i]: + pos = start + i * element_size + data_digest.update(raw[pos:pos + element_size]) + else: + end = start + len(arr) * element_size + data_digest.update(raw[start:end]) + + +def _hash_boolean_data(arr, data_digest, effective_nulls) -> None: + """Hash boolean array data bits (spec Section 3.2).""" + bv = _BitVec() + if effective_nulls is None: + for i in range(len(arr)): + bv.push(arr[i].as_py()) + else: + for i in range(len(arr)): + if effective_nulls[i]: + bv.push(arr[i].as_py()) + data_digest.update(bv.raw_bytes()) + + +def _hash_binary_data(arr, data_digest, effective_nulls) -> None: + """Hash binary array data (spec Section 3.3).""" + if effective_nulls is None: + for i in range(len(arr)): + val = arr[i].as_py() + data_digest.update(struct.pack(" None: + """Hash string array data (spec Section 3.3).""" + if effective_nulls is None: + for i in range(len(arr)): + val = arr[i].as_py().encode("utf-8") + data_digest.update(struct.pack(" None: + """Finalize a single BTreeMap entry into the final combining digest (spec Section 4).""" + null_bits, structural, data = entry + + # 1. null_bits (if present — nullable entries only) + if null_bits is not None: + final_digest.update(struct.pack(" None: + """Initialize a streaming Arrow hasher. + + Args: + schema: The Arrow schema all record batches must conform to. + include_metadata: When True, schema-level and per-field Arrow + metadata are included in the hash. Default is False, + preserving hash format 0.0.1 stability. A schema with no + metadata produces the same hash regardless of this flag + (empty-metadata invariant). + """ + self._schema = schema + self._include_metadata = include_metadata # captured in _schema_digest; stored for repr/diagnostics + self._schema_digest = _hash_schema(schema, include_metadata=include_metadata) + # BTreeMap — sorted by key + self._fields: dict[str, tuple] = {} + for i in range(len(schema)): + _extract_fields(schema.field(i), "", self._fields) + # Ensure sorted order (Python 3.7+ dicts are insertion-ordered) + self._fields = dict(sorted(self._fields.items())) + + def update(self, record_batch: pa.RecordBatch) -> None: + """Feed a RecordBatch into the running digest (spec Sections 3–5).""" + # Build a mapping from top-level column name to (field, array) + schema = record_batch.schema + # Traverse each top-level field using the recursive traversal + for i in range(len(schema)): + field = schema.field(i) + col = record_batch.column(i) + _traverse_and_update( + field.type, + field.nullable, + col, + field.name, + None, # no ancestor struct nulls at top level + self._fields, + ) + + def finalize(self) -> bytes: + """Consume the digester and return the versioned hash (spec Section 5).""" + final_digest = hashlib.sha256() + final_digest.update(self._schema_digest) + for _path, entry in sorted(self._fields.items()): + _finalize_digest(final_digest, entry) + return VERSION_BYTES + final_digest.digest() + + # -- Convenience class methods ------------------------------------------ + + @staticmethod + def hash_schema(schema: pa.Schema, *, include_metadata: bool = False) -> bytes: + """Hash an Arrow schema. + + Args: + schema: The schema to hash. + include_metadata: When True, schema-level and per-field Arrow + metadata are included in the hash. Default is False, + preserving hash format 0.0.1 stability. A schema with no + metadata produces the same hash regardless of this flag + (empty-metadata invariant). + """ + return VERSION_BYTES + _hash_schema(schema, include_metadata=include_metadata) + + @staticmethod + def hash_record_batch(record_batch: pa.RecordBatch, *, include_metadata: bool = False) -> bytes: + """Hash an Arrow record batch. + + Args: + record_batch: The record batch to hash. + include_metadata: When True, schema-level and per-field Arrow + metadata are included in the hash. Default is False, + preserving hash format 0.0.1 stability. A schema with no + metadata produces the same hash regardless of this flag + (empty-metadata invariant). + """ + d = ArrowDigester(record_batch.schema, include_metadata=include_metadata) + d.update(record_batch) + return d.finalize() + + @staticmethod + def hash_table(table: pa.Table, *, include_metadata: bool = False) -> bytes: + """Hash a full Arrow table (iterates over all batches). + + Args: + table: The table to hash. + include_metadata: When True, schema-level and per-field Arrow + metadata are included in the hash. Default is False, + preserving hash format 0.0.1 stability. A schema with no + metadata produces the same hash regardless of this flag + (empty-metadata invariant). + """ + d = ArrowDigester(table.schema, include_metadata=include_metadata) + for batch in table.to_batches(): + d.update(batch) + return d.finalize() + + @staticmethod + def hash_array(array: pa.Array) -> bytes: + """Hash a single array (spec Section 6). + + Uses the same recursive BTreeMap decomposition as the record-batch path. + + Note: + ``include_metadata`` is intentionally absent here — standalone arrays + carry no schema or field metadata. This matches the Rust ``starfix`` API. + """ + import pyarrow as pa + + # Resolve dictionary arrays to their plain value type + effective_type = array.type + effective_array = array + if pa.types.is_dictionary(effective_type): + effective_type = effective_type.value_type + effective_array = array.cast(effective_type) + + # Normalize to canonical large types + normalized_type = _normalize_data_type(effective_type) + + # Step 1: Type metadata (canonical JSON string) + dt_value = _data_type_to_value(normalized_type) + dt_value = _sort_json_value(dt_value) + dt_json = json.dumps(dt_value, separators=(",", ":")) + + final_digest = hashlib.sha256() + final_digest.update(dt_json.encode()) + + # Determine nullability: arrays with null_count > 0 are nullable + nullable = effective_array.null_count > 0 + + # Step 2: Build BTreeMap entries from the type tree (same as record-batch) + fields: dict[str, tuple] = {} + _extract_type_entries(effective_type, nullable, "", fields) + fields = dict(sorted(fields.items())) + + # Step 3: Traverse and populate entries + _traverse_and_update( + effective_type, + nullable, + effective_array, + "", + None, + fields, + ) + + # Step 4: Finalize all entries into the digest + for _path, entry in sorted(fields.items()): + _finalize_digest(final_digest, entry) + + return VERSION_BYTES + final_digest.digest() diff --git a/tests/golden/README.md b/tests/golden/README.md index 3fe47f0..6460044 100644 --- a/tests/golden/README.md +++ b/tests/golden/README.md @@ -5,4 +5,4 @@ | `format2_v0.5.json` | Hash format 2. Generated by Rust (`cargo run --bin emit_golden_format2` in nauticalab/starfix) and copied here byte for byte. Every vector and relation is asserted by `tests/test_golden_parity_format2.py`. Never edit. | | `format1_to_format2.json` | Every format-1 golden or pinned value of the Rust repository with its format-2 value (Rust-generated, copied byte for byte). Used to move this repository's hand-coded test literals to format 2. | | `python_literals_format1_inputs.json` | Inputs of this repository's hand-coded format-1 test literals that `format1_to_format2.json` did not cover, recovered from the calls that produced them, so that Rust could supply their format-2 values. | -| `include_metadata_v0.3.json` | Historical format-1 record (starfix ≤ 0.4). Kept unchanged; no longer asserted. | +| `include_metadata_v0.3.json` | Format-1 golden file (starfix ≤ 0.4), kept unchanged. Asserted against the legacy 0.4 mode (`tests/test_legacy_v0_4_golden_parity_metadata.py`). | diff --git a/tests/test_legacy_v0_4_arrow_digester.py b/tests/test_legacy_v0_4_arrow_digester.py new file mode 100644 index 0000000..d53ff88 --- /dev/null +++ b/tests/test_legacy_v0_4_arrow_digester.py @@ -0,0 +1,556 @@ +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import +(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. + +Tests for the pure-Python Arrow digester. + +Golden hash values are taken from the Rust test suite to ensure +byte-for-byte compatibility. +""" + +import pyarrow as pa +import pytest +from starfix.legacy.v0_4 import ArrowDigester, _serialized_schema + + +# ── Schema serialization ────────────────────────────────────────────── + + +class TestSchemaSerialization: + def test_simple_schema(self): + schema = pa.schema([ + pa.field("age", pa.int32(), nullable=False), + pa.field("name", pa.utf8(), nullable=True), + ]) + s = _serialized_schema(schema) + # Keys must be sorted: age before name + assert s.index('"age"') < s.index('"name"') + assert '"data_type":"Int32"' in s + assert '"data_type":"LargeUtf8"' in s + assert '"nullable":false' in s + + def test_time_types_in_schema(self): + schema = pa.schema([ + pa.field("t32s", pa.time32("s"), nullable=False), + pa.field("t32ms", pa.time32("ms"), nullable=False), + pa.field("t64us", pa.time64("us"), nullable=False), + pa.field("t64ns", pa.time64("ns"), nullable=False), + ]) + s = _serialized_schema(schema) + assert '"Time32":"Second"' in s + assert '"Time32":"Millisecond"' in s + assert '"Time64":"Microsecond"' in s + assert '"Time64":"Nanosecond"' in s + + def test_list_schema_uses_element_type_no_name(self): + """LargeList serialization should use element_type_to_value (no 'name' key).""" + schema = pa.schema([ + pa.field("items", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True), + ]) + s = _serialized_schema(schema) + # Should NOT contain "name":"item" inside the LargeList value + # The LargeList value should only have data_type and nullable + assert '"LargeList"' in s + # Check that the inner field does NOT include "name" + import json + parsed = json.loads(s) + large_list_val = parsed["items"]["data_type"]["LargeList"] + assert "name" not in large_list_val + assert "data_type" in large_list_val + assert "nullable" in large_list_val + + def test_struct_fields_sorted_in_schema(self): + """Struct fields should be sorted alphabetically in serialization.""" + schema = pa.schema([ + pa.field("s", pa.struct([ + pa.field("z_field", pa.int32(), nullable=False), + pa.field("a_field", pa.bool_(), nullable=True), + ]), nullable=True), + ]) + s = _serialized_schema(schema) + # a_field should appear before z_field in the Struct array + assert s.index('"a_field"') < s.index('"z_field"') + + def test_timestamp_types_in_schema(self): + schema = pa.schema([ + pa.field("ts_utc_s", pa.timestamp("s", tz="UTC"), nullable=False), + pa.field("ts_utc_ms", pa.timestamp("ms", tz="UTC"), nullable=False), + pa.field("ts_utc_us", pa.timestamp("us", tz="UTC"), nullable=False), + pa.field("ts_utc_ns", pa.timestamp("ns", tz="UTC"), nullable=False), + pa.field("ts_naive_us", pa.timestamp("us"), nullable=False), + ]) + s = _serialized_schema(schema) + assert '{"Timestamp":["Second","UTC"]}' in s + assert '{"Timestamp":["Millisecond","UTC"]}' in s + assert '{"Timestamp":["Microsecond","UTC"]}' in s + assert '{"Timestamp":["Nanosecond","UTC"]}' in s + assert '{"Timestamp":["Microsecond",null]}' in s + + def test_duration_types_in_schema(self): + schema = pa.schema([ + pa.field("dur_s", pa.duration("s"), nullable=False), + pa.field("dur_ms", pa.duration("ms"), nullable=False), + pa.field("dur_us", pa.duration("us"), nullable=False), + pa.field("dur_ns", pa.duration("ns"), nullable=False), + ]) + s = _serialized_schema(schema) + assert '{"Duration":"Second"}' in s + assert '{"Duration":"Millisecond"}' in s + assert '{"Duration":"Microsecond"}' in s + assert '{"Duration":"Nanosecond"}' in s + + +# ── Schema hashing (golden values from Rust) ────────────────────────── + + +class TestSchemaHashing: + def test_simple_schema_empty_table(self): + """Empty table hash for a simple schema shared between Rust and Python.""" + schema = pa.schema([ + pa.field("flags", pa.bool_(), nullable=True), + pa.field("uids", pa.int32(), nullable=False), + ]) + d = ArrowDigester(schema) + h = d.finalize().hex() + assert h.startswith("000001") + # Self-consistency: finalize with no updates on fresh instances + d2 = ArrowDigester(schema) + assert d2.finalize() == d.finalize() + + +# ── Array hashing (golden values from Rust) ─────────────────────────── + + +class TestArrayHashing: + def test_boolean_array(self): + arr = pa.array([True, None, False, True], type=pa.bool_()) + h = ArrowDigester.hash_array(arr).hex() + assert h == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + + def test_int32_array(self): + arr = pa.array([42, None, -7, 0], type=pa.int32()) + h = ArrowDigester.hash_array(arr).hex() + assert h == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + + def test_time32_second_array(self): + arr = pa.array([1000, None, 5000, 0], type=pa.time32("s")) + h = ArrowDigester.hash_array(arr).hex() + assert h == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + + def test_time64_microsecond_array(self): + arr = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) + h = ArrowDigester.hash_array(arr).hex() + assert h == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + + def test_time_units_differ(self): + a = pa.array([1000, 2000], type=pa.time32("s")) + b = pa.array([1000, 2000], type=pa.time32("ms")) + assert ArrowDigester.hash_array(a) != ArrowDigester.hash_array(b) + + def test_binary_array(self): + arr = pa.array([b"hello", None, b"world", b""], type=pa.binary()) + h = ArrowDigester.hash_array(arr).hex() + assert h == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + + def test_string_array(self): + arr = pa.array(["hello", None, "world", ""], type=pa.utf8()) + h = ArrowDigester.hash_array(arr).hex() + assert h == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + + def test_list_array(self): + arr = pa.array( + [[1, 2, 3], None, [4, 5], [6]], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + h = ArrowDigester.hash_array(arr).hex() + assert h == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + + def test_decimal128_array(self): + from decimal import Decimal + arr = pa.array( + [ + Decimal("1234567890123456789012.34567"), + None, + Decimal("-9876543210987654321098.76543"), + Decimal("0.00000"), + ], + type=pa.decimal128(38, 5), + ) + h = ArrowDigester.hash_array(arr).hex() + assert h == "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e" + + +# ── Type normalization ──────────────────────────────────────────────── + + +class TestTypeNormalization: + def test_utf8_equals_large_utf8_array(self): + a = pa.array(["hello", None, "world"], type=pa.utf8()) + b = pa.array(["hello", None, "world"], type=pa.large_utf8()) + assert ArrowDigester.hash_array(a) == ArrowDigester.hash_array(b) + + def test_binary_equals_large_binary_array(self): + a = pa.array([b"hello", None, b"world"], type=pa.binary()) + b = pa.array([b"hello", None, b"world"], type=pa.large_binary()) + assert ArrowDigester.hash_array(a) == ArrowDigester.hash_array(b) + + def test_list_equals_large_list_array(self): + lt = pa.list_(pa.field("item", pa.int32(), nullable=True)) + llt = pa.large_list(pa.field("item", pa.int32(), nullable=True)) + a = pa.array([[1, 2], None, [3]], type=lt) + b = pa.array([[1, 2], None, [3]], type=llt) + assert ArrowDigester.hash_array(a) == ArrowDigester.hash_array(b) + + def test_schema_utf8_equals_large_utf8(self): + s1 = pa.schema([pa.field("name", pa.utf8(), nullable=True)]) + s2 = pa.schema([pa.field("name", pa.large_utf8(), nullable=True)]) + assert ArrowDigester.hash_schema(s1) == ArrowDigester.hash_schema(s2) + + def test_schema_binary_equals_large_binary(self): + s1 = pa.schema([pa.field("data", pa.binary(), nullable=True)]) + s2 = pa.schema([pa.field("data", pa.large_binary(), nullable=True)]) + assert ArrowDigester.hash_schema(s1) == ArrowDigester.hash_schema(s2) + + def test_schema_list_equals_large_list(self): + s1 = pa.schema([pa.field("items", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True)]) + s2 = pa.schema([pa.field("items", pa.large_list(pa.field("item", pa.int32(), nullable=True)), nullable=True)]) + assert ArrowDigester.hash_schema(s1) == ArrowDigester.hash_schema(s2) + + def test_record_batch_utf8_equals_large_utf8(self): + s1 = pa.schema([pa.field("name", pa.utf8(), nullable=True)]) + s2 = pa.schema([pa.field("name", pa.large_utf8(), nullable=True)]) + b1 = pa.RecordBatch.from_arrays([pa.array(["a", "b"], type=pa.utf8())], schema=s1) + b2 = pa.RecordBatch.from_arrays([pa.array(["a", "b"], type=pa.large_utf8())], schema=s2) + assert ArrowDigester.hash_record_batch(b1) == ArrowDigester.hash_record_batch(b2) + + def test_list_of_utf8_vs_large_list_of_large_utf8_array(self): + """List(Utf8) vs LargeList(LargeUtf8) — normalization must be recursive.""" + list_arr = pa.array( + [["hello", "world"], ["foo"]], + type=pa.list_(pa.field("item", pa.utf8(), nullable=True)), + ) + large_list_arr = pa.array( + [["hello", "world"], ["foo"]], + type=pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), + ) + assert ArrowDigester.hash_array(list_arr) == ArrowDigester.hash_array(large_list_arr) + + def test_list_of_utf8_vs_large_list_of_large_utf8_schema(self): + s1 = pa.schema([pa.field("col", pa.list_(pa.field("item", pa.utf8(), nullable=True)), nullable=True)]) + s2 = pa.schema([pa.field("col", pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), nullable=True)]) + assert ArrowDigester.hash_schema(s1) == ArrowDigester.hash_schema(s2) + + def test_streaming_with_type_equivalent_schemas(self): + """Digester with Utf8 schema should accept LargeUtf8 batches.""" + schema_utf8 = pa.schema([pa.field("col", pa.utf8(), nullable=True)]) + d = ArrowDigester(schema_utf8) + batch = pa.RecordBatch.from_arrays( + [pa.array(["hello", None], type=pa.large_utf8())], + schema=pa.schema([pa.field("col", pa.large_utf8(), nullable=True)]), + ) + d.update(batch) + _hash = d.finalize() # Should not raise + + +# ── Collision resistance ────────────────────────────────────────────── + + +class TestCollisionResistance: + def test_binary_partition(self): + a1 = pa.array([b"\x01\x02", b"\x03"], type=pa.binary()) + a2 = pa.array([b"\x01", b"\x02\x03"], type=pa.binary()) + assert ArrowDigester.hash_array(a1) != ArrowDigester.hash_array(a2) + + def test_string_partition(self): + a1 = pa.array(["ab", "c"], type=pa.utf8()) + a2 = pa.array(["a", "bc"], type=pa.utf8()) + assert ArrowDigester.hash_array(a1) != ArrowDigester.hash_array(a2) + + def test_list_partition(self): + a1 = pa.array([[1, 2], [3]], type=pa.list_(pa.field("item", pa.int32(), nullable=True))) + a2 = pa.array([[1], [2, 3]], type=pa.list_(pa.field("item", pa.int32(), nullable=True))) + assert ArrowDigester.hash_array(a1) != ArrowDigester.hash_array(a2) + + +# ── RecordBatch hashing ────────────────────────────────────────────── + + +class TestRecordBatchHashing: + def test_column_order_independence(self): + uids = pa.array([1, 2, 3, 4], type=pa.int32()) + flags = pa.array([True, False, None, True], type=pa.bool_()) + + batch1 = pa.RecordBatch.from_arrays( + [uids, flags], + schema=pa.schema([ + pa.field("uids", pa.int32(), nullable=False), + pa.field("flags", pa.bool_(), nullable=True), + ]), + ) + batch2 = pa.RecordBatch.from_arrays( + [flags, uids], + schema=pa.schema([ + pa.field("flags", pa.bool_(), nullable=True), + pa.field("uids", pa.int32(), nullable=False), + ]), + ) + assert ArrowDigester.hash_record_batch(batch1) == ArrowDigester.hash_record_batch(batch2) + + def test_batch_split_independence(self): + """Two batches vs one combined should produce same hash.""" + schema = pa.schema([ + pa.field("id", pa.int32(), nullable=False), + pa.field("value", pa.float64(), nullable=True), + ]) + batch1 = pa.RecordBatch.from_arrays( + [pa.array([1, 2, 3], type=pa.int32()), pa.array([1.1, 2.2, 3.3], type=pa.float64())], + schema=schema, + ) + batch2 = pa.RecordBatch.from_arrays( + [pa.array([4, 5, 6], type=pa.int32()), pa.array([4.4, 5.5, 6.6], type=pa.float64())], + schema=schema, + ) + combined = pa.RecordBatch.from_arrays( + [pa.array([1, 2, 3, 4, 5, 6], type=pa.int32()), + pa.array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6], type=pa.float64())], + schema=schema, + ) + + d_multi = ArrowDigester(schema) + d_multi.update(batch1) + d_multi.update(batch2) + + d_single = ArrowDigester(schema) + d_single.update(combined) + + assert d_multi.finalize() == d_single.finalize() + + def test_streaming_golden_value(self): + """Matches Rust test ``record_batch_hashing``.""" + schema = pa.schema([ + pa.field("uids", pa.int32(), nullable=False), + pa.field("flags", pa.bool_(), nullable=True), + ]) + batch1 = pa.RecordBatch.from_arrays( + [pa.array([1, 2, 3, 4], type=pa.int32()), + pa.array([True, False, None, True], type=pa.bool_())], + schema=schema, + ) + batch2 = pa.RecordBatch.from_arrays( + [pa.array([5, 6, 7, 8], type=pa.int32()), + pa.array([False, True, True, None], type=pa.bool_())], + schema=schema, + ) + d = ArrowDigester(schema) + d.update(batch1) + d.update(batch2) + assert d.finalize().hex() == "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0" + + def test_nullable_vs_non_nullable_same_data(self): + """Array with all valid values should hash same whether nullable or not.""" + a = pa.array([1, 2, 3], type=pa.int32()) + b = pa.array([1, 2, 3], type=pa.int32()) + assert ArrowDigester.hash_array(a) == ArrowDigester.hash_array(b) + + def test_batches_with_nulls_vs_single(self): + """Batches where first is all nulls should produce same result as combined batch.""" + schema = pa.schema([ + pa.field("id", pa.int32(), nullable=True), + pa.field("value", pa.float64(), nullable=True), + ]) + batch1 = pa.RecordBatch.from_arrays( + [pa.array([None, None, None], type=pa.int32()), + pa.array([None, None, None], type=pa.float64())], + schema=schema, + ) + batch2 = pa.RecordBatch.from_arrays( + [pa.array([1, 2, 3], type=pa.int32()), + pa.array([1.1, 2.2, 3.3], type=pa.float64())], + schema=schema, + ) + combined = pa.RecordBatch.from_arrays( + [pa.array([None, None, None, 1, 2, 3], type=pa.int32()), + pa.array([None, None, None, 1.1, 2.2, 3.3], type=pa.float64())], + schema=schema, + ) + + d_multi = ArrowDigester(schema) + d_multi.update(batch1) + d_multi.update(batch2) + + d_single = ArrowDigester(schema) + d_single.update(combined) + + assert d_multi.finalize() == d_single.finalize() + + +# ── Nullable vs non-nullable schema ────────────────────────────────── + + +class TestNullableSchemas: + def test_different_schema_hashes(self): + s1 = pa.schema([pa.field("col1", pa.int32(), nullable=True), + pa.field("col2", pa.bool_(), nullable=True)]) + s2 = pa.schema([pa.field("col1", pa.int32(), nullable=False), + pa.field("col2", pa.bool_(), nullable=False)]) + assert ArrowDigester.hash_schema(s1) != ArrowDigester.hash_schema(s2) + + +# ── Struct hashing ─────────────────────────────────────────────────── + + +class TestStructHashing: + def test_struct_field_order_in_schema_should_not_affect_hash(self): + schema1 = pa.schema([pa.field("my_struct", pa.struct([ + pa.field("x", pa.int32(), nullable=False), + pa.field("y", pa.utf8(), nullable=True), + ]), nullable=True)]) + + schema2 = pa.schema([pa.field("my_struct", pa.struct([ + pa.field("y", pa.utf8(), nullable=True), + pa.field("x", pa.int32(), nullable=False), + ]), nullable=True)]) + + assert ArrowDigester.hash_schema(schema1) == ArrowDigester.hash_schema(schema2) + + def test_struct_field_order_in_record_batch_should_not_affect_hash(self): + schema1 = pa.schema([pa.field("s", pa.struct([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]), nullable=False)]) + + schema2 = pa.schema([pa.field("s", pa.struct([ + pa.field("b", pa.bool_(), nullable=True), + pa.field("a", pa.int32(), nullable=False), + ]), nullable=False)]) + + ints = pa.array([1, 2, 3], type=pa.int32()) + bools = pa.array([True, False, None], type=pa.bool_()) + + struct1 = pa.StructArray.from_arrays( + [ints, bools], + fields=[pa.field("a", pa.int32(), nullable=False), pa.field("b", pa.bool_(), nullable=True)], + ) + struct2 = pa.StructArray.from_arrays( + [bools, ints], + fields=[pa.field("b", pa.bool_(), nullable=True), pa.field("a", pa.int32(), nullable=False)], + ) + + batch1 = pa.RecordBatch.from_arrays([struct1], schema=schema1) + batch2 = pa.RecordBatch.from_arrays([struct2], schema=schema2) + + assert ArrowDigester.hash_record_batch(batch1) == ArrowDigester.hash_record_batch(batch2) + + def test_struct_with_list_utf8_vs_large_variants(self): + """Struct with List(Utf8) should hash same as Struct with LargeList(LargeUtf8).""" + schema1 = pa.schema([pa.field("s", pa.struct([ + pa.field("items", pa.list_(pa.field("item", pa.utf8(), nullable=True)), nullable=True), + pa.field("name", pa.utf8(), nullable=True), + ]), nullable=False)]) + + schema2 = pa.schema([pa.field("s", pa.struct([ + pa.field("items", pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), + pa.field("name", pa.large_utf8(), nullable=True), + ]), nullable=False)]) + + list1 = pa.array([["a", "b"], ["c"]], type=pa.list_(pa.field("item", pa.utf8(), nullable=True))) + names1 = pa.array(["Alice", "Bob"], type=pa.utf8()) + struct1 = pa.StructArray.from_arrays( + [list1, names1], + fields=[ + pa.field("items", pa.list_(pa.field("item", pa.utf8(), nullable=True)), nullable=True), + pa.field("name", pa.utf8(), nullable=True), + ], + ) + + list2 = pa.array([["a", "b"], ["c"]], type=pa.large_list(pa.field("item", pa.large_utf8(), nullable=True))) + names2 = pa.array(["Alice", "Bob"], type=pa.large_utf8()) + struct2 = pa.StructArray.from_arrays( + [list2, names2], + fields=[ + pa.field("items", pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), + pa.field("name", pa.large_utf8(), nullable=True), + ], + ) + + batch1 = pa.RecordBatch.from_arrays([struct1], schema=schema1) + batch2 = pa.RecordBatch.from_arrays([struct2], schema=schema2) + + assert ArrowDigester.hash_record_batch(batch1) == ArrowDigester.hash_record_batch(batch2) + + +# ── Dictionary handling ────────────────────────────────────────────── + + +class TestDictionaryHandling: + def test_dictionary_utf8_should_hash_same_as_plain(self): + plain = pa.array(["apple", "banana", "apple"], type=pa.utf8()) + dict_arr = pa.DictionaryArray.from_arrays( + pa.array([0, 1, 0], type=pa.int32()), + pa.array(["apple", "banana"], type=pa.utf8()), + ) + assert ArrowDigester.hash_array(plain) == ArrowDigester.hash_array(dict_arr) + + def test_dictionary_with_nulls_should_hash_same_as_plain(self): + plain = pa.array(["a", None, "b", None], type=pa.utf8()) + dict_arr = pa.DictionaryArray.from_arrays( + pa.array([0, None, 1, None], type=pa.int32()), + pa.array(["a", "b"], type=pa.utf8()), + ) + assert ArrowDigester.hash_array(plain) == ArrowDigester.hash_array(dict_arr) + + +# ── Streaming column reorder ───────────────────────────────────────── + + +class TestStreamingReorder: + def test_streaming_update_with_reordered_columns(self): + schema = pa.schema([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]) + d = ArrowDigester(schema) + + reordered_schema = pa.schema([ + pa.field("b", pa.bool_(), nullable=True), + pa.field("a", pa.int32(), nullable=False), + ]) + batch = pa.RecordBatch.from_arrays( + [pa.array([True, False], type=pa.bool_()), pa.array([1, 2], type=pa.int32())], + schema=reordered_schema, + ) + d.update(batch) + _hash = d.finalize() # Should not raise + + def test_streaming_reordered_columns_produce_same_hash(self): + schema_ab = pa.schema([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]) + + ints = pa.array([1, 2], type=pa.int32()) + bools = pa.array([True, False], type=pa.bool_()) + + batch_ab = pa.RecordBatch.from_arrays( + [ints, bools], schema=schema_ab, + ) + batch_ba = pa.RecordBatch.from_arrays( + [bools, ints], + schema=pa.schema([ + pa.field("b", pa.bool_(), nullable=True), + pa.field("a", pa.int32(), nullable=False), + ]), + ) + + d1 = ArrowDigester(schema_ab) + d1.update(batch_ab) + h1 = d1.finalize() + + d2 = ArrowDigester(schema_ab) + d2.update(batch_ba) + h2 = d2.finalize() + + assert h1 == h2 + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/tests/test_legacy_v0_4_frozen.py b/tests/test_legacy_v0_4_frozen.py new file mode 100644 index 0000000..8aa3c9e --- /dev/null +++ b/tests/test_legacy_v0_4_frozen.py @@ -0,0 +1,41 @@ +"""[Legacy 0.4 mode] The legacy module is frozen and physically separate from format 2. + +If this test fails because src/starfix/legacy/v0_4.py changed: the legacy module must not be +edited. Its output must stay byte-identical to starfix-python 0.4.0 forever (data hashed by +0.4.x stays findable). Revert the change. +""" + +from __future__ import annotations + +import ast +import hashlib +from pathlib import Path + +_SRC = Path(__file__).parent.parent / "src" / "starfix" +_LEGACY = _SRC / "legacy" / "v0_4.py" +_LEGACY_SHA256 = "652b0620bc484ab0ccf89a5423945244e6195d99484e1afcae48de5f4704ada3" + + +def test_legacy_module_is_unchanged() -> None: + assert hashlib.sha256(_LEGACY.read_bytes()).hexdigest() == _LEGACY_SHA256, ( + "src/starfix/legacy/v0_4.py changed: the legacy 0.4 module is frozen; revert the edit" + ) + + +def _imported_modules(path: Path) -> set[str]: + names: set[str] = set() + for node in ast.walk(ast.parse(path.read_text(encoding="utf-8"))): + if isinstance(node, ast.Import): + names.update(alias.name for alias in node.names) + elif isinstance(node, ast.ImportFrom) and node.module: + names.add(node.module) + return names + + +def test_legacy_imports_only_stdlib_and_pyarrow() -> None: + assert not {m for m in _imported_modules(_LEGACY) if m.startswith("starfix")} + + +def test_format2_does_not_import_legacy() -> None: + for path in (_SRC / "_format2.py", _SRC / "arrow_digester.py", _SRC / "__init__.py"): + assert not {m for m in _imported_modules(path) if m.startswith("starfix.legacy")}, path diff --git a/tests/test_legacy_v0_4_golden_parity.py b/tests/test_legacy_v0_4_golden_parity.py new file mode 100644 index 0000000..7a9b7fb --- /dev/null +++ b/tests/test_legacy_v0_4_golden_parity.py @@ -0,0 +1,710 @@ +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import +(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. + +Golden-hash parity tests: Python must produce byte-for-byte identical hashes to Rust. + +Every expected value below was generated by `cargo run --bin emit_golden` against +the Rust starfix crate *after* PR #11 was merged (commit on 2026-03-20). The Rust +values are treated as the authoritative source of truth; these tests are regression +guards that will fail immediately if the Python implementation diverges. + +Covers 36 distinct Arrow tables / arrays: + - spec examples A, B, C, D, E, F, G, H, I, J, K, N, O + - all primitive scalar types (bool, int8..uint64, float32, float64) + - temporal types (date32, date64, time32(s/ms), time64(us/ns)) + - variable-length (binary, string/utf8) + - decimal128 (precision ranges 1-9, 10-18, 19-38) + - list-of-int32 + - struct column, nested struct (two levels), struct with nullable children + - multi-type record batch, schema-only (empty) hash + - streaming two-batch incremental update +""" + +from __future__ import annotations + +from decimal import Decimal + +import pyarrow as pa +import pytest +from starfix.legacy.v0_4 import ArrowDigester + + +# --------------------------------------------------------------------------- +# Spec examples (byte-exact conformance, letter-for-letter from spec) +# --------------------------------------------------------------------------- + + +class TestSpecExamples: + def test_example_a_two_column_table(self): + """Example A: {age: Int32 non-null, name: LargeUtf8 nullable} — two rows.""" + schema = pa.schema([ + pa.field("age", pa.int32(), nullable=False), + pa.field("name", pa.large_utf8(), nullable=True), + ]) + batch = pa.record_batch( + { + "age": pa.array([25, 30], type=pa.int32()), + "name": pa.array(["Alice", None], type=pa.large_utf8()), + }, + schema=schema, + ) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + + def test_example_b_bool_array_with_nulls(self): + """Example B: BooleanArray [true, NULL, false, true].""" + array = pa.array([True, None, False, True], type=pa.bool_()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + + def test_example_c_non_nullable_int32(self): + """Example C: Int32Array [1, 2, 3] — non-nullable.""" + array = pa.array([1, 2, 3], type=pa.int32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c" + + def test_example_d_non_nullable_binary(self): + """Example D: BinaryArray [b'hi', b''] — non-nullable; tests Binary→LargeBinary canonicalization.""" + array = pa.array([b"hi", b""], type=pa.binary()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d" + + def test_example_e_column_order_independence(self): + """Example E: columns [x: Int32, y: Boolean nullable] — order must not matter.""" + schema_xy = pa.schema([ + pa.field("x", pa.int32(), nullable=False), + pa.field("y", pa.bool_(), nullable=True), + ]) + schema_yx = pa.schema([ + pa.field("y", pa.bool_(), nullable=True), + pa.field("x", pa.int32(), nullable=False), + ]) + batch_xy = pa.record_batch( + {"x": pa.array([10], type=pa.int32()), "y": pa.array([True], type=pa.bool_())}, + schema=schema_xy, + ) + batch_yx = pa.record_batch( + {"y": pa.array([True], type=pa.bool_()), "x": pa.array([10], type=pa.int32())}, + schema=schema_yx, + ) + expected = "000001f68bf6319f8ec4aa938e52dd911974348289fbdfb9b5ebed5e14e239a6d8a3a9" + assert ArrowDigester.hash_record_batch(batch_xy).hex() == expected + assert ArrowDigester.hash_record_batch(batch_yx).hex() == expected + + def test_example_f_utf8_equivalence(self): + """Example F: Utf8 and LargeUtf8 arrays with the same data must hash identically.""" + small = pa.array(["ab"], type=pa.utf8()) + large = pa.array(["ab"], type=pa.large_utf8()) + expected = "000001f14d076ffc02533c6560f867b86cde7e15b1a0ac5a892b53697a609191cf307f" + assert ArrowDigester.hash_array(small).hex() == expected + assert ArrowDigester.hash_array(large).hex() == expected + + def test_example_g_nullable_int32(self): + """Example G: Int32Array [Some(42), None, Some(-7), Some(0)].""" + array = pa.array([42, None, -7, 0], type=pa.int32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + + def test_example_h_nullable_string(self): + """Example H: StringArray [Some('hello'), None, Some('world'), Some('')].""" + array = pa.array(["hello", None, "world", ""], type=pa.utf8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + + def test_example_i_empty_table(self): + """Example I: schema {a: Int32 non-null, b: Boolean nullable} with zero rows.""" + schema = pa.schema([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]) + digester = ArrowDigester(schema) + result = digester.finalize().hex() + assert result == "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922" + + def test_example_j_multi_batch_streaming(self): + """Example J: batch-split independence — two batches == one combined batch.""" + schema = pa.schema([pa.field("v", pa.int32(), nullable=False)]) + batch1 = pa.record_batch({"v": pa.array([1, 2], type=pa.int32())}, schema=schema) + batch2 = pa.record_batch({"v": pa.array([3], type=pa.int32())}, schema=schema) + digester = ArrowDigester(schema) + digester.update(batch1) + digester.update(batch2) + result = digester.finalize().hex() + assert result == "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857" + + def test_example_k_struct_column(self): + """Example K: {person: Struct}.""" + person_type = pa.struct([ + pa.field("age", pa.int32(), nullable=False), + pa.field("name", pa.large_utf8(), nullable=False), + ]) + schema = pa.schema([pa.field("person", person_type, nullable=False)]) + person_col = pa.array( + [{"age": 25, "name": "Alice"}, {"age": 30, "name": "Bob"}], + type=person_type, + ) + batch = pa.record_batch({"person": person_col}, schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001e3516302d68fd1fc4860fa4b7e0d4a6d60d500a9d7ccae79e445c5980021e4ec" + + def test_example_n_list_of_struct(self): + """Example N: {items: LargeList> nullable}. + + Row 0: [{id:1, label:'a'}, {id:2, label:'b'}] + Row 1: [{id:3, label:'c'}] + """ + item_type = pa.struct([ + pa.field("id", pa.int32(), nullable=False), + pa.field("label", pa.large_utf8(), nullable=False), + ]) + schema = pa.schema([ + pa.field("items", pa.large_list(pa.field("item", item_type, nullable=False)), nullable=True) + ]) + items_col = pa.array( + [ + [{"id": 1, "label": "a"}, {"id": 2, "label": "b"}], + [{"id": 3, "label": "c"}], + ], + type=pa.large_list(pa.field("item", item_type, nullable=False)), + ) + batch = pa.record_batch({"items": items_col}, schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000019c9cc6230a42e646a475ec1c8125fe396dcace351d64ff6e63e8f53d329c4895" + + def test_example_o_nested_struct(self): + """Example O: {s: Struct>} — two levels.""" + nested_type = pa.struct([ + pa.field("p", pa.int32(), nullable=False), + pa.field("q", pa.int32(), nullable=False), + ]) + outer_type = pa.struct([ + pa.field("a", pa.int32(), nullable=False), + pa.field("nested", nested_type, nullable=False), + ]) + schema = pa.schema([pa.field("s", outer_type, nullable=False)]) + s_col = pa.array( + [{"a": 10, "nested": {"p": 20, "q": 30}}], + type=outer_type, + ) + batch = pa.record_batch({"s": s_col}, schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001e732b8458782d9a331722698883617eec7cd1492028947b4ce3e97c7d6201550" + + +# --------------------------------------------------------------------------- +# Primitive scalar types (all 11 numeric/bool types) +# --------------------------------------------------------------------------- + + +class TestPrimitiveTypes: + def test_bool(self): + array = pa.array([True, False, None, True], type=pa.bool_()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1" + + def test_int8(self): + array = pa.array([1, None, -1, 127], type=pa.int8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc" + + def test_int16(self): + array = pa.array([1000, None, -1000, 32767], type=pa.int16()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4" + + def test_int32(self): + array = pa.array([42, None, -7, 0], type=pa.int32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + + def test_int64(self): + array = pa.array([1_000_000, None, -1_000_000, 0], type=pa.int64()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf" + + def test_uint8(self): + array = pa.array([0, 1, None, 255], type=pa.uint8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd" + + def test_uint16(self): + array = pa.array([0, 1000, None, 65535], type=pa.uint16()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357" + + def test_uint32(self): + array = pa.array([0, 1_000_000, None, 4_294_967_295], type=pa.uint32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e" + + def test_uint64(self): + array = pa.array([0, 1_000_000_000, None, 18_446_744_073_709_551_615], type=pa.uint64()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b" + + def test_float32(self): + array = pa.array([1.5, None, -3.14, 0.0], type=pa.float32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa" + + def test_float64(self): + array = pa.array([1.5, None, -3.14, 0.0], type=pa.float64()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b" + + +# --------------------------------------------------------------------------- +# Temporal types +# --------------------------------------------------------------------------- + + +class TestTemporalTypes: + def test_date32(self): + """Date32: days since Unix epoch.""" + array = pa.array([0, 18993, None, -1], type=pa.date32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6" + + def test_date64(self): + """Date64: ms since Unix epoch.""" + array = pa.array([0, 1_640_995_200_000, None, -86_400_000], type=pa.date64()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb" + + def test_time32_seconds(self): + """Time32(s): seconds since midnight.""" + array = pa.array([1000, None, 5000, 0], type=pa.time32("s")) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + + def test_time32_milliseconds(self): + """Time32(ms): milliseconds since midnight.""" + array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time32("ms")) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564" + + def test_time64_microseconds(self): + """Time64(us): microseconds since midnight.""" + array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + + def test_time64_nanoseconds(self): + """Time64(ns): nanoseconds since midnight.""" + array = pa.array([1_000_000_000, None, 5_000_000_000, 0], type=pa.time64("ns")) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f" + + +# --------------------------------------------------------------------------- +# Variable-length types +# --------------------------------------------------------------------------- + + +class TestVariableLengthTypes: + def test_binary(self): + """Binary array — tests LargeBinary canonicalization.""" + array = pa.array([b"hello", None, b"world", b""], type=pa.binary()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + + def test_large_binary_equals_binary(self): + """LargeBinary and Binary arrays with same data must produce the same hash.""" + small = pa.array([b"hello", None, b"world", b""], type=pa.binary()) + large = pa.array([b"hello", None, b"world", b""], type=pa.large_binary()) + expected = "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + assert ArrowDigester.hash_array(small).hex() == expected + assert ArrowDigester.hash_array(large).hex() == expected + + def test_string(self): + """String (Utf8) array — tests LargeUtf8 canonicalization.""" + array = pa.array(["hello", None, "world", ""], type=pa.utf8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + + def test_large_string_equals_string(self): + """LargeUtf8 and Utf8 arrays with same data must produce the same hash.""" + small = pa.array(["hello", None, "world", ""], type=pa.utf8()) + large = pa.array(["hello", None, "world", ""], type=pa.large_utf8()) + expected = "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert ArrowDigester.hash_array(small).hex() == expected + assert ArrowDigester.hash_array(large).hex() == expected + + +# --------------------------------------------------------------------------- +# Decimal types (precision routing: 1-9, 10-18, 19-38) +# --------------------------------------------------------------------------- + + +class TestDecimalTypes: + def test_decimal_precision_9_scale_2(self): + """Decimal128 precision=9 (maps to decimal32 storage range) scale=2. + + Rust stores raw i128 values [123, -456, 0]. In PyArrow, pa.decimal128(9, 2) + interprets values as scaled decimals, so we use Decimal strings to get + the same raw integer storage: 1.23 * 10^2 = 123, etc. + """ + array = pa.array( + [Decimal("1.23"), None, Decimal("-4.56"), Decimal("0.00")], + type=pa.decimal128(9, 2), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000014f015bd5c4b6ce6e939a8c890333f3e110c2c28ef8014aafd352f8373791e547" + + def test_decimal_precision_15_scale_3(self): + """Decimal128 precision=15 (maps to decimal64 range) scale=3.""" + array = pa.array( + [Decimal("1234567890.123"), None, Decimal("-9876543.210"), Decimal("0.000")], + type=pa.decimal128(15, 3), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001dc08c7b9c583edecec36bc5dee21cd2edec9f402a651014fea5f8834d16ad737" + + def test_decimal_precision_38_scale_5(self): + """Decimal128 precision=38 scale=5 — full 16-byte integer path.""" + array = pa.array( + [ + Decimal("1234567890123456789012.34567"), + None, + Decimal("-9876543210987654321098.76543"), + Decimal("0.00000"), + ], + type=pa.decimal128(38, 5), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e" + + +# --------------------------------------------------------------------------- +# List types +# --------------------------------------------------------------------------- + + +class TestListTypes: + def test_list_of_int32(self): + """List — tests LargeList canonicalization and per-element length prefix.""" + array = pa.array( + [ + [1, 2, 3], + None, + [4, 5], + [6], + ], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + + def test_large_list_equals_list(self): + """LargeList with the same data must produce the same hash as List.""" + small = pa.array( + [[1, 2, 3], None, [4, 5], [6]], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + large = pa.array( + [[1, 2, 3], None, [4, 5], [6]], + type=pa.large_list(pa.field("item", pa.int32(), nullable=True)), + ) + expected = "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + assert ArrowDigester.hash_array(small).hex() == expected + assert ArrowDigester.hash_array(large).hex() == expected + + +# --------------------------------------------------------------------------- +# Struct types +# --------------------------------------------------------------------------- + + +class TestStructTypes: + def test_struct_with_nullable_children(self): + """Non-nullable struct column {a: Int32 non-null, b: Boolean nullable}.""" + struct_type = pa.struct([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]) + schema = pa.schema([pa.field("s", struct_type, nullable=False)]) + s_col = pa.array( + [{"a": 1, "b": True}, {"a": 2, "b": False}, {"a": 3, "b": None}], + type=struct_type, + ) + batch = pa.record_batch({"s": s_col}, schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000015f1992c5f9130aaa64aa1360e53ddd00b427855ae02e380f534a629353135680" + + def test_struct_field_order_independence(self): + """Struct fields in different order must hash identically (order-independence).""" + type_ab = pa.struct([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=True), + ]) + type_ba = pa.struct([ + pa.field("b", pa.bool_(), nullable=True), + pa.field("a", pa.int32(), nullable=False), + ]) + schema_ab = pa.schema([pa.field("s", type_ab, nullable=False)]) + schema_ba = pa.schema([pa.field("s", type_ba, nullable=False)]) + + data_ab = pa.array( + [{"a": 1, "b": True}, {"a": 2, "b": False}, {"a": 3, "b": None}], + type=type_ab, + ) + data_ba = pa.array( + [{"b": True, "a": 1}, {"b": False, "a": 2}, {"b": None, "a": 3}], + type=type_ba, + ) + batch_ab = pa.record_batch({"s": data_ab}, schema=schema_ab) + batch_ba = pa.record_batch({"s": data_ba}, schema=schema_ba) + assert ( + ArrowDigester.hash_record_batch(batch_ab) + == ArrowDigester.hash_record_batch(batch_ba) + ) + + +# --------------------------------------------------------------------------- +# Multi-type record batch +# --------------------------------------------------------------------------- + + +class TestMultiTypeBatch: + def test_multi_type_record_batch(self): + """One-row record batch covering all scalar and collection types.""" + schema = pa.schema([ + pa.field("bool", pa.bool_(), nullable=True), + pa.field("int8", pa.int8(), nullable=False), + pa.field("uint8", pa.uint8(), nullable=False), + pa.field("int16", pa.int16(), nullable=False), + pa.field("uint16", pa.uint16(), nullable=False), + pa.field("int32", pa.int32(), nullable=False), + pa.field("uint32", pa.uint32(), nullable=False), + pa.field("int64", pa.int64(), nullable=False), + pa.field("uint64", pa.uint64(), nullable=False), + pa.field("float32", pa.float32(), nullable=False), + pa.field("float64", pa.float64(), nullable=False), + pa.field("date32", pa.date32(), nullable=False), + pa.field("date64", pa.date64(), nullable=False), + pa.field("time32_second", pa.time32("s"), nullable=False), + pa.field("time32_millis", pa.time32("ms"), nullable=False), + pa.field("time64_micro", pa.time64("us"), nullable=False), + pa.field("time64_nano", pa.time64("ns"), nullable=False), + pa.field("binary", pa.binary(), nullable=True), + pa.field("large_binary", pa.large_binary(), nullable=True), + pa.field("utf8", pa.utf8(), nullable=True), + pa.field("large_utf8", pa.large_utf8(), nullable=True), + pa.field("list", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True), + pa.field("large_list", pa.large_list(pa.field("item", pa.int32(), nullable=True)), nullable=True), + pa.field("decimal128", pa.decimal128(38, 5), nullable=True), + ]) + batch = pa.record_batch( + { + "bool": pa.array([True], type=pa.bool_()), + "int8": pa.array([1], type=pa.int8()), + "uint8": pa.array([1], type=pa.uint8()), + "int16": pa.array([100], type=pa.int16()), + "uint16": pa.array([100], type=pa.uint16()), + "int32": pa.array([1000], type=pa.int32()), + "uint32": pa.array([1000], type=pa.uint32()), + "int64": pa.array([100_000], type=pa.int64()), + "uint64": pa.array([100_000], type=pa.uint64()), + "float32": pa.array([1.5], type=pa.float32()), + "float64": pa.array([1.5], type=pa.float64()), + "date32": pa.array([18993], type=pa.date32()), + "date64": pa.array([1_640_995_200_000], type=pa.date64()), + "time32_second": pa.array([3600], type=pa.time32("s")), + "time32_millis": pa.array([3_600_000], type=pa.time32("ms")), + "time64_micro": pa.array([3_600_000_000], type=pa.time64("us")), + "time64_nano": pa.array([3_600_000_000_000], type=pa.time64("ns")), + "binary": pa.array([b"data1"], type=pa.binary()), + "large_binary": pa.array([b"large1"], type=pa.large_binary()), + "utf8": pa.array(["text1"], type=pa.utf8()), + "large_utf8": pa.array(["large_text1"], type=pa.large_utf8()), + "list": pa.array([[1, 2]], type=pa.list_(pa.field("item", pa.int32(), nullable=True))), + "large_list": pa.array([[5, 6]], type=pa.large_list(pa.field("item", pa.int32(), nullable=True))), + "decimal128": pa.array( + [Decimal("1234567890123456789012345.67890")], + type=pa.decimal128(38, 5), + ), + }, + schema=schema, + ) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000010f8bb471cb34975f20c4b221abff1a90b2d98f24217a2257e3298ee3d4e9f9c4" + + def test_multi_type_schema_only(self): + """Empty (no-rows) digester over the large multi-type schema.""" + schema = pa.schema([ + pa.field("bool", pa.bool_(), nullable=True), + pa.field("int8", pa.int8(), nullable=False), + pa.field("uint8", pa.uint8(), nullable=False), + pa.field("int16", pa.int16(), nullable=False), + pa.field("uint16", pa.uint16(), nullable=False), + pa.field("int32", pa.int32(), nullable=False), + pa.field("uint32", pa.uint32(), nullable=False), + pa.field("int64", pa.int64(), nullable=False), + pa.field("uint64", pa.uint64(), nullable=False), + pa.field("float32", pa.float32(), nullable=False), + pa.field("float64", pa.float64(), nullable=False), + pa.field("date32", pa.date32(), nullable=False), + pa.field("date64", pa.date64(), nullable=False), + pa.field("time32_second", pa.time32("s"), nullable=False), + pa.field("time32_millis", pa.time32("ms"), nullable=False), + pa.field("time64_micro", pa.time64("us"), nullable=False), + pa.field("time64_nano", pa.time64("ns"), nullable=False), + pa.field("binary", pa.binary(), nullable=True), + pa.field("large_binary", pa.large_binary(), nullable=True), + pa.field("utf8", pa.utf8(), nullable=True), + pa.field("large_utf8", pa.large_utf8(), nullable=True), + pa.field("list", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True), + pa.field("large_list", pa.large_list(pa.field("item", pa.int32(), nullable=True)), nullable=True), + pa.field("decimal128", pa.decimal128(38, 5), nullable=True), + ]) + result = ArrowDigester(schema).finalize().hex() + assert result == "0000010e62b3f3317d25413b7a4dc6e7a8a6e7c73a73c513cdbe9f9b1f5e5ec56f0e94" + + +# --------------------------------------------------------------------------- +# Streaming / incremental hashing +# --------------------------------------------------------------------------- + + +class TestStreamingHashing: + def test_streaming_two_batches(self): + """Two-batch incremental update must match the known Rust hash.""" + schema = pa.schema([ + pa.field("uids", pa.int32(), nullable=False), + pa.field("flags", pa.bool_(), nullable=True), + ]) + batch1 = pa.record_batch( + { + "uids": pa.array([1, 2, 3, 4], type=pa.int32()), + "flags": pa.array([True, False, None, True], type=pa.bool_()), + }, + schema=schema, + ) + batch2 = pa.record_batch( + { + "uids": pa.array([5, 6, 7, 8], type=pa.int32()), + "flags": pa.array([False, True, True, None], type=pa.bool_()), + }, + schema=schema, + ) + digester = ArrowDigester(schema) + digester.update(batch1) + digester.update(batch2) + result = digester.finalize().hex() + assert result == "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0" + + def test_batch_split_independence(self): + """Splitting a batch into two must not change the hash.""" + schema = pa.schema([ + pa.field("v", pa.int32(), nullable=False), + ]) + combined = pa.record_batch({"v": pa.array([1, 2, 3], type=pa.int32())}, schema=schema) + batch1 = pa.record_batch({"v": pa.array([1, 2], type=pa.int32())}, schema=schema) + batch2 = pa.record_batch({"v": pa.array([3], type=pa.int32())}, schema=schema) + + hash_combined = ArrowDigester.hash_record_batch(combined) + + digester = ArrowDigester(schema) + digester.update(batch1) + digester.update(batch2) + hash_split = digester.finalize() + + assert hash_combined == hash_split + + +# --------------------------------------------------------------------------- +# Timestamp and Duration hashing — golden values match Rust (ITL-438) +# --------------------------------------------------------------------------- + + +class TestTimestampDurationHashing: + """Golden-hash parity for timestamp and duration types. + + All expected values were generated by the Rust starfix test suite + (timestamp_array_hashing / duration_array_hashing in tests/arrow_digester.rs). + Array contents: [0, None, 1_000] as raw i64 values. + """ + + # -- Timestamp (tz-aware UTC) ------------------------------------------ + + def test_timestamp_second_utc(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("s", tz="UTC")) + assert ArrowDigester.hash_array(arr).hex() == "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b" + + def test_timestamp_millisecond_utc(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("ms", tz="UTC")) + assert ArrowDigester.hash_array(arr).hex() == "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5" + + def test_timestamp_microsecond_utc(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("us", tz="UTC")) + assert ArrowDigester.hash_array(arr).hex() == "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e" + + def test_timestamp_nanosecond_utc(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("ns", tz="UTC")) + assert ArrowDigester.hash_array(arr).hex() == "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0" + + # -- Timestamp (tz-naive) ---------------------------------------------- + + def test_timestamp_second_naive(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("s")) + assert ArrowDigester.hash_array(arr).hex() == "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30" + + def test_timestamp_millisecond_naive(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("ms")) + assert ArrowDigester.hash_array(arr).hex() == "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842" + + def test_timestamp_microsecond_naive(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("us")) + assert ArrowDigester.hash_array(arr).hex() == "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3" + + def test_timestamp_nanosecond_naive(self): + arr = pa.array([0, None, 1_000], type=pa.timestamp("ns")) + assert ArrowDigester.hash_array(arr).hex() == "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796" + + # -- Timestamp: unit and tz produce different hashes ------------------- + + def test_timestamp_units_differ(self): + values = [1_000, 2_000] + hashes = [ + ArrowDigester.hash_array(pa.array(values, type=pa.timestamp("s"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.timestamp("ms"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.timestamp("us"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.timestamp("ns"))).hex(), + ] + assert len(set(hashes)) == 4, "all 4 timestamp units must produce distinct hashes" + + def test_timestamp_tz_differs(self): + values = [1_000, 2_000] + naive = ArrowDigester.hash_array(pa.array(values, type=pa.timestamp("us"))).hex() + utc = ArrowDigester.hash_array( + pa.array(values, type=pa.timestamp("us", tz="UTC")) + ).hex() + assert naive != utc, "tz-naive and tz=UTC must produce different hashes" + + # -- Duration ---------------------------------------------------------- + + def test_duration_second(self): + arr = pa.array([0, None, 1_000], type=pa.duration("s")) + assert ArrowDigester.hash_array(arr).hex() == "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa" + + def test_duration_millisecond(self): + arr = pa.array([0, None, 1_000], type=pa.duration("ms")) + assert ArrowDigester.hash_array(arr).hex() == "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c" + + def test_duration_microsecond(self): + arr = pa.array([0, None, 1_000], type=pa.duration("us")) + assert ArrowDigester.hash_array(arr).hex() == "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a" + + def test_duration_nanosecond(self): + arr = pa.array([0, None, 1_000], type=pa.duration("ns")) + assert ArrowDigester.hash_array(arr).hex() == "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b" + + def test_duration_units_differ(self): + values = [1_000, 2_000] + hashes = [ + ArrowDigester.hash_array(pa.array(values, type=pa.duration("s"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.duration("ms"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.duration("us"))).hex(), + ArrowDigester.hash_array(pa.array(values, type=pa.duration("ns"))).hex(), + ] + assert len(set(hashes)) == 4, "all 4 duration units must produce distinct hashes" diff --git a/tests/test_legacy_v0_4_golden_parity_metadata.py b/tests/test_legacy_v0_4_golden_parity_metadata.py new file mode 100644 index 0000000..4c34d55 --- /dev/null +++ b/tests/test_legacy_v0_4_golden_parity_metadata.py @@ -0,0 +1,130 @@ +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import +(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. + +Cross-language golden-hash parity tests for include_metadata vectors (PLT-1735). + +Every expected hash in `tests/golden/include_metadata_v0.3.json` was generated by +`cargo run --bin emit_golden_metadata` in the Rust starfix crate and is treated as +the authoritative source of truth. These tests will fail immediately if the Python +implementation diverges from Rust. + +Covers 9 vectors: + - no_metadata_include_false (regression: same as v0.1.0 schema hash) + - schema_level_metadata (schema-level metadata, include_metadata=True) + - field_metadata_single_field (single field with metadata, include_metadata=True) + - field_metadata_multiple_fields (two fields with metadata, include_metadata=True) + - schema_and_field_metadata (both schema- and field-level, include_metadata=True) + - unicode_metadata (emoji + CJK keys/values, include_metadata=True) + - key_reorder_canonical (metadata keys in alphabetical order) + - key_reorder_shuffled (same keys, different insertion order — same hash) + - empty_metadata_invariant (no metadata — hash must be same for both flag values) +""" +from __future__ import annotations + +import base64 +import io +import json +from pathlib import Path +from typing import Any + +import pyarrow as pa +import pytest + +from starfix.legacy.v0_4 import ArrowDigester + +_FIXTURE_PATH = Path(__file__).parent / "golden" / "include_metadata_v0.3.json" + + +def _load_vectors() -> list[dict[str, Any]]: + with _FIXTURE_PATH.open(encoding="utf-8") as f: + return json.load(f)["vectors"] + + +def _get_vector(vector_id: str) -> dict[str, Any]: + for v in _load_vectors(): + if v["id"] == vector_id: + return v + raise KeyError(f"Vector '{vector_id}' not found in fixture") + + +def _deserialize_ipc(ipc_b64: str) -> tuple[pa.Schema, pa.RecordBatch | None]: + raw = base64.b64decode(ipc_b64) + reader = pa.ipc.open_stream(io.BytesIO(raw)) + schema = reader.schema + batches = list(reader) + batch = batches[0] if batches else None + return schema, batch + + +@pytest.mark.parametrize("vector", _load_vectors(), ids=lambda v: v["id"]) +def test_golden_vector(vector: dict[str, Any]) -> None: + """Each vector must produce the Rust-authoritative expected_hash.""" + schema, batch = _deserialize_ipc(vector["ipc_b64"]) + include_metadata: bool = vector["include_metadata"] + + if vector["method"] == "hash_schema": + result = ArrowDigester.hash_schema(schema, include_metadata=include_metadata) + elif vector["method"] == "hash_record_batch": + assert batch is not None, ( + f"Vector '{vector['id']}': method is hash_record_batch but IPC has no batch" + ) + result = ArrowDigester.hash_record_batch(batch, include_metadata=include_metadata) + else: + pytest.fail(f"Vector '{vector['id']}': unknown method '{vector['method']}'") + + assert result.hex() == vector["expected_hash"], ( + f"Vector '{vector['id']}' mismatch: {vector['description']}\n" + f" got: {result.hex()}\n" + f" expected: {vector['expected_hash']}" + ) + + +def test_empty_metadata_invariant_both_flags() -> None: + """Empty-metadata invariant: include_metadata=True must produce the same hash as False.""" + vector = _get_vector("empty_metadata_invariant") + schema, _ = _deserialize_ipc(vector["ipc_b64"]) + + hash_false = ArrowDigester.hash_schema(schema, include_metadata=False).hex() + hash_true = ArrowDigester.hash_schema(schema, include_metadata=True).hex() + + assert hash_false == vector["expected_hash"], ( + f"empty_metadata_invariant: include_metadata=False got {hash_false}, " + f"expected {vector['expected_hash']}" + ) + assert hash_true == vector["expected_hash"], ( + f"empty_metadata_invariant: include_metadata=True got {hash_true}, " + f"expected {vector['expected_hash']}" + ) + assert hash_false == hash_true, ( + "empty_metadata_invariant: both flag values must produce the same hash" + ) + + +def test_key_reorder_hashes_are_identical() -> None: + """key_reorder_canonical and key_reorder_shuffled encode to identical IPC bytes. + + arrow-ipc normalises metadata key order (alphabetical sort) before FlatBuffers + encoding, so both vectors produce byte-identical blobs regardless of insertion + order. This test asserts those fixture invariants explicitly, then hashes once + as a live sanity check — re-hashing both would just hash the same bytes twice. + """ + canonical = _get_vector("key_reorder_canonical") + shuffled = _get_vector("key_reorder_shuffled") + + # Fixture invariants: arrow-ipc sorts keys before encoding, so both entries + # must carry the same IPC blob and the same expected hash. + assert canonical["ipc_b64"] == shuffled["ipc_b64"], ( + "key_reorder_canonical and key_reorder_shuffled must have identical ipc_b64 " + "(arrow-ipc normalises metadata key order before FlatBuffers encoding)" + ) + assert canonical["expected_hash"] == shuffled["expected_hash"], ( + "key_reorder_canonical and key_reorder_shuffled must have identical expected_hash" + ) + + # Sanity check: live hash must match the (single) fixture value. + schema, _ = _deserialize_ipc(canonical["ipc_b64"]) + live_hash = ArrowDigester.hash_schema(schema, include_metadata=True).hex() + assert live_hash == canonical["expected_hash"], ( + f"key_reorder live hash drifted from fixture: " + f"got {live_hash}, expected {canonical['expected_hash']}" + ) diff --git a/tests/test_legacy_v0_4_golden_parity_r2.py b/tests/test_legacy_v0_4_golden_parity_r2.py new file mode 100644 index 0000000..ebddd57 --- /dev/null +++ b/tests/test_legacy_v0_4_golden_parity_r2.py @@ -0,0 +1,1063 @@ +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import +(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. + +Golden-hash parity tests — Round 2. + +Every expected value below was generated by `cargo run --bin emit_golden` against +the Rust starfix crate. The Rust values are treated as the authoritative source +of truth; these tests are regression guards that will fail immediately if the +Python implementation diverges. + +Covers 40+ distinct Arrow tables / arrays across categories: + - Empty arrays (0 elements) + - All-null arrays + - Large boolean arrays (multi-byte bitvec) + - Single-element arrays + - Nullable structs (struct itself nullable, hash_array & record batch) + - Three-level nested structs + - Struct with list child + - List, nullable List + - List with nullable vs non-nullable item field (PLT-1048 edge case) + - Non-nullable lists + - Mixed-type structs + - Mixed struct+list record batches + - Empty record batches (schema only) + - All-null columns in batches + - Unicode strings + - Binary with varied sizes + - Struct field order independence + - Nested struct with nullable inner struct + - List-of-list (nested lists) + - Large schema hashes + - Multi-batch streaming with structs and lists + - Float special values (NaN, Inf) + - Realistic batch (struct + list + scalar) +""" + +from __future__ import annotations + +import pyarrow as pa +import pytest +from starfix.legacy.v0_4 import ArrowDigester + + +def _with_type(arr: pa.Array, t: pa.DataType) -> pa.Array: + """`arr` rebuilt with the field nullability of struct type `t` (same data). + + pyarrow 19 cannot cast a struct whose children are nullable to one whose children + are not, which pa.record_batch(..., schema=...) would otherwise do. Test inputs only. + """ + if not pa.types.is_struct(t) or not pa.types.is_struct(arr.type): + return arr + children = [_with_type(arr.field(i), t.field(i).type) for i in range(t.num_fields)] + mask = arr.is_null() if arr.null_count else None + return pa.StructArray.from_arrays(children, fields=list(t), mask=mask) + + +def _record_batch(columns, schema: pa.Schema) -> pa.RecordBatch: + if isinstance(columns, dict): + columns = [columns[f.name] for f in schema] + return pa.record_batch( + [_with_type(c, f.type) if isinstance(c, pa.Array) else c for c, f in zip(columns, schema)], + schema=schema, + ) + + +# --------------------------------------------------------------------------- +# Empty arrays +# --------------------------------------------------------------------------- + + +class TestEmptyArrays: + def test_empty_int32_array(self): + """Empty Int32 array (0 elements).""" + array = pa.array([], type=pa.int32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a" + + def test_empty_bool_array(self): + """Empty Boolean array (0 elements).""" + array = pa.array([], type=pa.bool_()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea" + + +# --------------------------------------------------------------------------- +# All-null arrays +# --------------------------------------------------------------------------- + + +class TestAllNullArrays: + def test_all_null_int32(self): + """Int32 array where every element is null.""" + array = pa.array([None, None, None, None], type=pa.int32()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65" + + def test_all_null_string(self): + """LargeString array where every element is null.""" + array = pa.array([None, None, None], type=pa.large_utf8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070" + + +# --------------------------------------------------------------------------- +# Boolean arrays +# --------------------------------------------------------------------------- + + +class TestBooleanArrays: + def test_bool_17_elements(self): + """17-element boolean array (multi-byte bitvec).""" + array = pa.array( + [ + True, False, True, True, + None, False, True, False, + True, None, True, False, + True, True, False, None, + True, + ], + type=pa.bool_(), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a" + + +# --------------------------------------------------------------------------- +# Single-element arrays +# --------------------------------------------------------------------------- + + +class TestSingleElementArrays: + def test_single_int64(self): + """Single Int64 value: 9_999_999_999.""" + array = pa.array([9_999_999_999], type=pa.int64()) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f" + + def test_single_string(self): + """Single LargeString value: 'hello world'.""" + array = pa.array(["hello world"], type=pa.large_utf8()) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb" + + def test_single_bool_false(self): + """Single Boolean value: false.""" + array = pa.array([False], type=pa.bool_()) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df" + + +# --------------------------------------------------------------------------- +# Nullable struct via hash_array +# --------------------------------------------------------------------------- + + +class TestNullableStructHashArray: + def test_nullable_struct_hash_array(self): + """Struct with null buffer via hash_array — row 1 is null struct. + + Fields: a: Int32 non-null, b: LargeUtf8 non-null + Data: [{a:10, b:'x'}, NULL, {a:30, b:'z'}] + """ + a_arr = pa.array([10, 20, 30], type=pa.int32()) + b_arr = pa.array(["x", "y", "z"], type=pa.large_utf8()) + mask = pa.array([False, True, False], type=pa.bool_()) + fields = [ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.large_utf8(), nullable=False), + ] + struct_array = pa.StructArray.from_arrays( + [a_arr, b_arr], + fields=fields, + mask=mask, + ) + result = ArrowDigester.hash_array(struct_array).hex() + assert result == "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5" + + +# --------------------------------------------------------------------------- +# Three-level nested struct +# --------------------------------------------------------------------------- + + +class TestThreeLevelStruct: + def test_three_level_struct_batch(self): + """Three-level nested struct as record batch. + + top: Struct> + Data: [{x:100, mid:{y:200, z:300}}] + """ + inner_type = pa.struct([ + pa.field("y", pa.int32(), nullable=False), + pa.field("z", pa.int32(), nullable=False), + ]) + outer_type = pa.struct([ + pa.field("x", pa.int32(), nullable=False), + pa.field("mid", inner_type, nullable=False), + ]) + schema = pa.schema([pa.field("top", outer_type, nullable=False)]) + col = pa.array( + [{"x": 100, "mid": {"y": 200, "z": 300}}], + type=outer_type, + ) + batch = _record_batch({"top": col}, schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a" + + def test_three_level_struct_schema(self): + """Schema hash for three-level nested struct.""" + inner_type = pa.struct([ + pa.field("y", pa.int32(), nullable=False), + pa.field("z", pa.int32(), nullable=False), + ]) + outer_type = pa.struct([ + pa.field("x", pa.int32(), nullable=False), + pa.field("mid", inner_type, nullable=False), + ]) + schema = pa.schema([pa.field("top", outer_type, nullable=False)]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7" + + def test_three_level_struct_hash_array(self): + """Three-level struct via hash_array. + + Struct, x: Int32> + Data: [{inner:{y:7,z:'a'}, x:5}, {inner:{y:8,z:'b'}, x:6}] + """ + y_arr = pa.array([7, 8], type=pa.int32()) + z_arr = pa.array(["a", "b"], type=pa.large_utf8()) + inner_fields = [ + pa.field("y", pa.int32(), nullable=False), + pa.field("z", pa.large_utf8(), nullable=False), + ] + inner = pa.StructArray.from_arrays( + [y_arr, z_arr], + fields=inner_fields, + ) + x_arr = pa.array([5, 6], type=pa.int32()) + inner_type = pa.struct(inner_fields) + outer_fields = [ + pa.field("inner", inner_type, nullable=False), + pa.field("x", pa.int32(), nullable=False), + ] + outer = pa.StructArray.from_arrays( + [inner, x_arr], + fields=outer_fields, + ) + result = ArrowDigester.hash_array(outer).hex() + assert result == "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0" + + +# --------------------------------------------------------------------------- +# Struct with list child +# --------------------------------------------------------------------------- + + +class TestStructWithListChild: + def test_struct_with_list_child_batch(self): + """Record batch: struct with list child. + + record: Struct> + Data: [{id:1, tags:[10,20]}, {id:2, tags:[30]}, {id:3, tags:null}] + """ + ids = pa.array([1, 2, 3], type=pa.int32()) + tags = pa.array( + [[10, 20], [30], None], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + struct_type = pa.struct([ + pa.field("id", pa.int32(), nullable=False), + pa.field("tags", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True), + ]) + struct_arr = pa.StructArray.from_arrays( + [ids, tags], + names=["id", "tags"], + ) + schema = pa.schema([pa.field("record", struct_type, nullable=False)]) + batch = _record_batch([struct_arr], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d" + + def test_struct_with_list_child_schema(self): + """Schema hash for struct with list child.""" + struct_type = pa.struct([ + pa.field("id", pa.int32(), nullable=False), + pa.field("tags", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=True), + ]) + schema = pa.schema([pa.field("record", struct_type, nullable=False)]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed" + + +# --------------------------------------------------------------------------- +# Nullable struct in record batch +# --------------------------------------------------------------------------- + + +class TestNullableStructBatch: + def test_nullable_struct_batch(self): + """Nullable struct in record batch — row 1 is null. + + s: Struct nullable + Data: [{a:1,b:true}, NULL, {a:3,b:true}] + """ + a_arr = pa.array([1, 2, 3], type=pa.int32()) + b_arr = pa.array([True, False, True], type=pa.bool_()) + mask = pa.array([False, True, False], type=pa.bool_()) + struct_array = pa.StructArray.from_arrays( + [a_arr, b_arr], + names=["a", "b"], + mask=mask, + ) + struct_type = pa.struct([ + pa.field("a", pa.int32(), nullable=False), + pa.field("b", pa.bool_(), nullable=False), + ]) + schema = pa.schema([pa.field("s", struct_type, nullable=True)]) + batch = _record_batch([struct_array], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048" + + +# --------------------------------------------------------------------------- +# List via hash_array +# --------------------------------------------------------------------------- + + +class TestListOfStruct: + def test_list_of_struct_hash_array(self): + """LargeList> via hash_array. + + Row 0: [{id:1, name:'a'}, {id:2, name:'b'}] + Row 1: [{id:3, name:'c'}, {id:4, name:'d'}] + """ + ids = pa.array([1, 2, 3, 4], type=pa.int32()) + names = pa.array(["a", "b", "c", "d"], type=pa.large_utf8()) + struct_fields = [ + pa.field("id", pa.int32(), nullable=False), + pa.field("name", pa.large_utf8(), nullable=False), + ] + struct_arr = pa.StructArray.from_arrays( + [ids, names], + fields=struct_fields, + ) + inner_type = pa.struct([ + pa.field("id", pa.int32(), nullable=False), + pa.field("name", pa.large_utf8(), nullable=False), + ]) + inner_field = pa.field("item", inner_type, nullable=False) + offsets = pa.array([0, 2, 4], type=pa.int64()) + list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field)) + result = ArrowDigester.hash_array(list_array).hex() + assert result == "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626" + + def test_nullable_list_of_struct_hash_array(self): + """Nullable LargeList via hash_array — row 1 is null. + + Row 0: [{id:10, val:'p'}] + Row 1: NULL + Row 2: [{id:20, val:'q'}, {id:30, val:'r'}] + """ + ids = pa.array([10, 20, 30], type=pa.int32()) + vals = pa.array(["p", "q", "r"], type=pa.large_utf8()) + struct_fields = [ + pa.field("id", pa.int32(), nullable=False), + pa.field("val", pa.large_utf8(), nullable=False), + ] + struct_arr = pa.StructArray.from_arrays( + [ids, vals], + fields=struct_fields, + ) + inner_type = pa.struct(struct_fields) + inner_field = pa.field("item", inner_type, nullable=False) + offsets = pa.array([0, 1, 1, 3], type=pa.int64()) + mask = pa.array([False, True, False], type=pa.bool_()) + list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field), mask=mask) + result = ArrowDigester.hash_array(list_array).hex() + assert result == "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8" + + +# --------------------------------------------------------------------------- +# Non-nullable list +# --------------------------------------------------------------------------- + + +class TestNonNullableList: + def test_list_non_nullable(self): + """List where all elements are present (no nulls at list or item level). + + Row 0: [1] + Row 1: [2, 3] + Row 2: [4, 5, 6] + """ + array = pa.array( + [[1], [2, 3], [4, 5, 6]], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b" + + +# --------------------------------------------------------------------------- +# Struct with mixed types +# --------------------------------------------------------------------------- + + +class TestStructMixedTypes: + def test_struct_mixed_types_hash_array(self): + """Struct with int, string, bool, and list children via hash_array. + + Data: [{id:1, name:'Alice', active:true, scores:[90,85]}, + {id:2, name:'Bob', active:false, scores:[70]}] + """ + id_arr = pa.array([1, 2], type=pa.int32()) + name_arr = pa.array(["Alice", "Bob"], type=pa.large_utf8()) + active_arr = pa.array([True, False], type=pa.bool_()) + scores_arr = pa.array( + [[90, 85], [70]], + type=pa.list_(pa.field("item", pa.int32(), nullable=True)), + ) + struct_fields = [ + pa.field("id", pa.int32(), nullable=False), + pa.field("name", pa.large_utf8(), nullable=False), + pa.field("active", pa.bool_(), nullable=False), + pa.field("scores", pa.list_(pa.field("item", pa.int32(), nullable=True)), nullable=False), + ] + struct_arr = pa.StructArray.from_arrays( + [id_arr, name_arr, active_arr, scores_arr], + fields=struct_fields, + ) + result = ArrowDigester.hash_array(struct_arr).hex() + assert result == "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3" + + +# --------------------------------------------------------------------------- +# Mixed struct + list record batch +# --------------------------------------------------------------------------- + + +class TestMixedStructListBatch: + def test_mixed_struct_list_batch(self): + """Record batch with id: Int64, meta: Struct, tags: LargeList. + + Row 0: {id:100, meta:{key:'k1', value:10}, tags:['t1','t2']} + Row 1: {id:200, meta:{key:'k2', value:null}, tags:['t3']} + """ + schema = pa.schema([ + pa.field("id", pa.int64(), nullable=False), + pa.field("meta", pa.struct([ + pa.field("key", pa.large_utf8(), nullable=False), + pa.field("value", pa.int32(), nullable=True), + ]), nullable=False), + pa.field("tags", pa.large_list( + pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), + ]) + + id_arr = pa.array([100, 200], type=pa.int64()) + key_arr = pa.array(["k1", "k2"], type=pa.large_utf8()) + val_arr = pa.array([10, None], type=pa.int32()) + meta_arr = pa.StructArray.from_arrays( + [key_arr, val_arr], + names=["key", "value"], + ) + + tag_strings = pa.array(["t1", "t2", "t3"], type=pa.large_utf8()) + offsets = pa.array([0, 2, 3], type=pa.int64()) + tags_arr = pa.LargeListArray.from_arrays( + offsets, tag_strings, + type=pa.large_list(pa.field("item", pa.large_utf8(), nullable=True)), + ) + + batch = _record_batch([id_arr, meta_arr, tags_arr], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a" + + def test_mixed_struct_list_schema(self): + """Schema hash for mixed struct + list batch.""" + schema = pa.schema([ + pa.field("id", pa.int64(), nullable=False), + pa.field("meta", pa.struct([ + pa.field("key", pa.large_utf8(), nullable=False), + pa.field("value", pa.int32(), nullable=True), + ]), nullable=False), + pa.field("tags", pa.large_list( + pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45" + + +# --------------------------------------------------------------------------- +# Empty record batch (schema with 0 rows) +# --------------------------------------------------------------------------- + + +class TestEmptyBatchComplexSchema: + def test_empty_batch_complex_schema(self): + """Empty table hash (ArrowDigester(schema).finalize()) with complex schema.""" + schema = pa.schema([ + pa.field("x", pa.int32(), nullable=False), + pa.field("y", pa.large_utf8(), nullable=True), + pa.field("z", pa.struct([ + pa.field("a", pa.bool_(), nullable=False), + pa.field("b", pa.float64(), nullable=True), + ]), nullable=False), + ]) + digester = ArrowDigester(schema) + result = digester.finalize().hex() + assert result == "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83" + + def test_empty_batch_complex_schema_hash(self): + """Schema hash (hash_schema) for same complex schema.""" + schema = pa.schema([ + pa.field("x", pa.int32(), nullable=False), + pa.field("y", pa.large_utf8(), nullable=True), + pa.field("z", pa.struct([ + pa.field("a", pa.bool_(), nullable=False), + pa.field("b", pa.float64(), nullable=True), + ]), nullable=False), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654" + + +# --------------------------------------------------------------------------- +# Batch with all-null column +# --------------------------------------------------------------------------- + + +class TestBatchAllNullColumn: + def test_batch_all_null_column(self): + """Record batch where one column is entirely null. + + id: [1, 2, 3], value: [null, null, null] + """ + schema = pa.schema([ + pa.field("id", pa.int32(), nullable=False), + pa.field("value", pa.large_utf8(), nullable=True), + ]) + batch = _record_batch( + { + "id": pa.array([1, 2, 3], type=pa.int32()), + "value": pa.array([None, None, None], type=pa.large_utf8()), + }, + schema=schema, + ) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494" + + +# --------------------------------------------------------------------------- +# Unicode strings +# --------------------------------------------------------------------------- + + +class TestUnicodeStrings: + def test_unicode_string_array(self): + """LargeString array with unicode characters.""" + array = pa.array( + ["hello", "\u4e16\u754c", "\U0001f30d\U0001f30e\U0001f30f", None, "caf\u00e9"], + type=pa.large_utf8(), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40" + + +# --------------------------------------------------------------------------- +# Binary with varied sizes +# --------------------------------------------------------------------------- + + +class TestBinaryVariedSizes: + def test_binary_varied_sizes(self): + """Binary array with varied sizes including empty, null, and special bytes.""" + array = pa.array( + [ + b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", + b"", + None, + b"\xff", + b"\x00", + ], + type=pa.binary(), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05" + + +# --------------------------------------------------------------------------- +# Struct field order independence +# --------------------------------------------------------------------------- + + +class TestStructFieldOrderIndependence: + def test_struct_3field_order_independence(self): + """Three-field struct: field order should not affect hash. + + Fields: a: Int32, b: LargeUtf8, c: Boolean + Data: [{a:1,b:'x',c:true}, {a:2,b:'y',c:false}] + """ + a = pa.array([1, 2], type=pa.int32()) + b = pa.array(["x", "y"], type=pa.large_utf8()) + c = pa.array([True, False], type=pa.bool_()) + + fa = pa.field("a", pa.int32(), nullable=False) + fb = pa.field("b", pa.large_utf8(), nullable=False) + fc = pa.field("c", pa.bool_(), nullable=False) + + # Order: a, b, c + s1 = pa.StructArray.from_arrays([a, b, c], fields=[fa, fb, fc]) + # Order: c, a, b + s2 = pa.StructArray.from_arrays([c, a, b], fields=[fc, fa, fb]) + + h1 = ArrowDigester.hash_array(s1).hex() + h2 = ArrowDigester.hash_array(s2).hex() + assert h1 == h2, "struct field order should not affect hash_array" + assert h1 == "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25" + + +# --------------------------------------------------------------------------- +# Nested struct with nullable inner struct +# --------------------------------------------------------------------------- + + +class TestNestedNullableInnerStruct: + def test_nested_nullable_inner_struct(self): + """Outer struct with nullable inner struct — inner row 1 is null. + + Outer: Struct nullable> + Data: [{a:10, inner:{p:1,q:4}}, {a:20, inner:NULL}, {a:30, inner:{p:3,q:6}}] + """ + p = pa.array([1, 2, 3], type=pa.int32()) + q = pa.array([4, 5, 6], type=pa.int32()) + inner_mask = pa.array([False, True, False], type=pa.bool_()) + inner_fields = [ + pa.field("p", pa.int32(), nullable=False), + pa.field("q", pa.int32(), nullable=False), + ] + inner = pa.StructArray.from_arrays( + [p, q], + fields=inner_fields, + mask=inner_mask, + ) + + a = pa.array([10, 20, 30], type=pa.int32()) + inner_type = pa.struct(inner_fields) + outer_fields = [ + pa.field("a", pa.int32(), nullable=False), + pa.field("inner", inner_type, nullable=True), + ] + outer = pa.StructArray.from_arrays( + [a, inner], + fields=outer_fields, + ) + result = ArrowDigester.hash_array(outer).hex() + assert result == "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c" + + +# --------------------------------------------------------------------------- +# List of list (nested lists) +# --------------------------------------------------------------------------- + + +class TestListOfList: + def test_list_of_list_hash_array(self): + """LargeList> via hash_array. + + Row 0: [[1,2], [3]] + Row 1: [[4,5], [6]] + """ + inner_values = pa.array([1, 2, 3, 4, 5, 6], type=pa.int32()) + inner_offsets = pa.array([0, 2, 3, 5, 6], type=pa.int64()) + inner_field = pa.field("item", pa.int32(), nullable=False) + inner_list = pa.LargeListArray.from_arrays( + inner_offsets, inner_values, + type=pa.large_list(inner_field), + ) + outer_offsets = pa.array([0, 2, 4], type=pa.int64()) + outer_field = pa.field("item", pa.large_list(inner_field), nullable=False) + outer_list = pa.LargeListArray.from_arrays( + outer_offsets, inner_list, + type=pa.large_list(outer_field), + ) + result = ArrowDigester.hash_array(outer_list).hex() + assert result == "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc" + + def test_list_of_list_batch(self): + """Record batch with LargeList> column.""" + inner_values = pa.array([1, 2, 3, 4, 5, 6], type=pa.int32()) + inner_offsets = pa.array([0, 2, 3, 5, 6], type=pa.int64()) + inner_field = pa.field("item", pa.int32(), nullable=False) + inner_list = pa.LargeListArray.from_arrays( + inner_offsets, inner_values, + type=pa.large_list(inner_field), + ) + outer_offsets = pa.array([0, 2, 4], type=pa.int64()) + outer_field = pa.field("item", pa.large_list(inner_field), nullable=False) + outer_list = pa.LargeListArray.from_arrays( + outer_offsets, inner_list, + type=pa.large_list(outer_field), + ) + schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) + batch = _record_batch([outer_list], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10" + + def test_list_of_list_schema(self): + """Schema hash for list-of-list column.""" + inner_field = pa.field("item", pa.int32(), nullable=False) + outer_field = pa.field("item", pa.large_list(inner_field), nullable=False) + schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330" + + +# --------------------------------------------------------------------------- +# Large schema (12 fields) +# --------------------------------------------------------------------------- + + +class TestLargeSchema: + def test_large_schema_12_fields(self): + """Schema hash for 12-field schema with mixed types.""" + schema = pa.schema([ + pa.field("f01", pa.int8(), nullable=False), + pa.field("f02", pa.int16(), nullable=True), + pa.field("f03", pa.int32(), nullable=False), + pa.field("f04", pa.int64(), nullable=True), + pa.field("f05", pa.float32(), nullable=False), + pa.field("f06", pa.float64(), nullable=True), + pa.field("f07", pa.bool_(), nullable=False), + pa.field("f08", pa.large_utf8(), nullable=True), + pa.field("f09", pa.large_binary(), nullable=False), + pa.field("f10", pa.date32(), nullable=True), + pa.field("f11", pa.struct([ + pa.field("nested_a", pa.int32(), nullable=False), + pa.field("nested_b", pa.large_utf8(), nullable=True), + ]), nullable=False), + pa.field("f12", pa.large_list( + pa.field("item", pa.int32(), nullable=True)), nullable=True), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd" + + +# --------------------------------------------------------------------------- +# Schema with nested list-of-struct +# --------------------------------------------------------------------------- + + +class TestSchemaListOfStructWithList: + def test_schema_list_of_struct_with_list(self): + """Schema hash for LargeList>>.""" + schema = pa.schema([ + pa.field("events", pa.large_list( + pa.field("item", pa.struct([ + pa.field("ts", pa.int64(), nullable=False), + pa.field("msg", pa.large_utf8(), nullable=True), + pa.field("tags", pa.large_list( + pa.field("item", pa.large_utf8(), nullable=False)), + nullable=True), + ]), nullable=False)), nullable=True), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "0000017f5258ff48e85b2a63cd1a29590ff3bfca39bf718365200ad74a8232bb654ec6" + + +# --------------------------------------------------------------------------- +# Deeply nested schema (4 levels) +# --------------------------------------------------------------------------- + + +class TestSchema4LevelNestedStruct: + def test_schema_4_level_nested_struct(self): + """Schema hash for 4-level nested struct: root.l1.l2.l3.leaf.""" + schema = pa.schema([ + pa.field("root", pa.struct([ + pa.field("l1", pa.struct([ + pa.field("l2", pa.struct([ + pa.field("l3", pa.struct([ + pa.field("leaf", pa.int32(), nullable=False), + ]), nullable=False), + ]), nullable=False), + ]), nullable=False), + ]), nullable=False), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e" + + +# --------------------------------------------------------------------------- +# Nullable list-of-struct with nullable children +# --------------------------------------------------------------------------- + + +class TestNullableListStructNullableChildren: + def test_nullable_list_struct_nullable_children_batch(self): + """Record batch: nullable LargeList with nullable children. + + items: LargeList> nullable + Row 0: [{id:1, label:'a'}, {id:2, label:null}] + Row 1: NULL + """ + ids = pa.array([1, 2, 3], type=pa.int32()) + labels = pa.array(["a", None, "c"], type=pa.large_utf8()) + struct_fields = [ + pa.field("id", pa.int32(), nullable=False), + pa.field("label", pa.large_utf8(), nullable=True), + ] + struct_arr = pa.StructArray.from_arrays( + [ids, labels], + fields=struct_fields, + ) + inner_type = pa.struct(struct_fields) + inner_field = pa.field("item", inner_type, nullable=False) + offsets = pa.array([0, 2, 3], type=pa.int64()) + mask = pa.array([False, True], type=pa.bool_()) + list_array = pa.LargeListArray.from_arrays( + offsets, struct_arr, + type=pa.large_list(inner_field), + mask=mask, + ) + schema = pa.schema([ + pa.field("items", pa.large_list(inner_field), nullable=True), + ]) + batch = _record_batch([list_array], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96" + + +# --------------------------------------------------------------------------- +# Struct empty batch (schema only, struct fields) +# --------------------------------------------------------------------------- + + +class TestStructEmptyBatch: + def test_struct_empty_batch(self): + """Empty table hash with struct schema (0 rows).""" + schema = pa.schema([ + pa.field("person", pa.struct([ + pa.field("name", pa.large_utf8(), nullable=False), + pa.field("age", pa.int32(), nullable=False), + pa.field("score", pa.float64(), nullable=False), + ]), nullable=False), + ]) + d = ArrowDigester(schema) + result = d.finalize().hex() + assert result == "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773" + + +# --------------------------------------------------------------------------- +# Multi-batch with struct column +# --------------------------------------------------------------------------- + + +class TestMultiBatchStruct: + def test_multi_batch_struct(self): + """Multi-batch streaming with struct column. + + Schema: s: Struct + Batch 1: [{x:1,y:10}, {x:2,y:null}] + Batch 2: [{x:3,y:30}] + """ + struct_type = pa.struct([ + pa.field("x", pa.int32(), nullable=False), + pa.field("y", pa.int32(), nullable=True), + ]) + schema = pa.schema([pa.field("s", struct_type, nullable=False)]) + + s1 = pa.StructArray.from_arrays( + [pa.array([1, 2], type=pa.int32()), pa.array([10, None], type=pa.int32())], + names=["x", "y"], + ) + batch1 = _record_batch([s1], schema=schema) + + s2 = pa.StructArray.from_arrays( + [pa.array([3], type=pa.int32()), pa.array([30], type=pa.int32())], + names=["x", "y"], + ) + batch2 = _record_batch([s2], schema=schema) + + d = ArrowDigester(schema) + d.update(batch1) + d.update(batch2) + result = d.finalize().hex() + assert result == "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c" + + +# --------------------------------------------------------------------------- +# Multi-batch with list column +# --------------------------------------------------------------------------- + + +class TestMultiBatchList: + def test_multi_batch_list(self): + """Multi-batch streaming with LargeList column. + + Batch 1: [[1,2], null] + Batch 2: [[3,4,5]] + """ + list_type = pa.large_list(pa.field("item", pa.int32(), nullable=True)) + schema = pa.schema([pa.field("items", list_type, nullable=True)]) + + arr1 = pa.array( + [[1, 2], None], + type=list_type, + ) + batch1 = _record_batch([arr1], schema=schema) + + arr2 = pa.array( + [[3, 4, 5]], + type=list_type, + ) + batch2 = _record_batch([arr2], schema=schema) + + d = ArrowDigester(schema) + d.update(batch1) + d.update(batch2) + result = d.finalize().hex() + assert result == "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3" + + +# --------------------------------------------------------------------------- +# LargeList with nullable vs non-nullable inner (item) field +# +# This exercises the structural-only BTreeMap entry created for List. +# When inner_field.nullable=True the entry's BitVec is allocated but never +# populated (bit_count=0), so 8 zero bytes are prepended to the structural +# digest at finalisation. Both Rust and Python handle this identically. +# Golden values verified via `cargo test list_struct_nullable_inner_field_parity` +# against the Rust starfix crate (PLT-1048). +# --------------------------------------------------------------------------- + + +class TestListStructNullableInnerField: + """LargeList — nullable vs non-nullable item field parity.""" + + _ids = [1, 2, 3, 4] + _labels = ["a", "b", "c", "d"] + + def _make_list_array(self, inner_nullable: bool) -> "pa.LargeListArray": + ids = pa.array(self._ids, type=pa.int32()) + labels = pa.array(self._labels, type=pa.large_utf8()) + struct_fields = [ + pa.field("id", pa.int32(), nullable=False), + pa.field("label", pa.large_utf8(), nullable=False), + ] + struct_arr = pa.StructArray.from_arrays( + [ids, labels], + fields=struct_fields, + ) + inner_field = pa.field("item", pa.struct(struct_fields), nullable=inner_nullable) + offsets = pa.array([0, 2, 4], type=pa.int64()) + return pa.LargeListArray.from_arrays( + offsets, + struct_arr, + type=pa.large_list(inner_field), + ) + + def test_nullable_inner_field(self): + """LargeList with nullable=True item field. + + ids=[1,2,3,4], labels=['a','b','c','d'], offsets=[0,2,4] + inner_field.nullable=True → structural-only entry has empty BitVec. + Golden value confirmed against Rust (PLT-1048). + """ + result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=True)).hex() + assert result == "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c" + + def test_non_nullable_inner_field(self): + """LargeList with nullable=False item field. + + ids=[1,2,3,4], labels=['a','b','c','d'], offsets=[0,2,4] + inner_field.nullable=False → no BitVec in structural-only entry. + Golden value confirmed against Rust (PLT-1048). + """ + result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=False)).hex() + assert result == "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c" + + def test_nullable_differs_from_non_nullable(self): + """Nullable vs non-nullable inner field must produce different hashes.""" + hash_nullable = ArrowDigester.hash_array(self._make_list_array(inner_nullable=True)).hex() + hash_not_nullable = ArrowDigester.hash_array( + self._make_list_array(inner_nullable=False) + ).hex() + assert hash_nullable != hash_not_nullable, ( + "nullable and non-nullable item fields must produce distinct hashes" + ) + + +# --------------------------------------------------------------------------- +# Float special values +# --------------------------------------------------------------------------- + + +class TestFloatSpecialValues: + def test_float64_special_values(self): + """Float64 array with NaN, Inf, -Inf, 0.0, -0.0.""" + array = pa.array( + [float("nan"), float("inf"), float("-inf"), 0.0, -0.0], + type=pa.float64(), + ) + result = ArrowDigester.hash_array(array).hex() + assert result == "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a" + + +# --------------------------------------------------------------------------- +# Realistic batch (struct + list + scalar) +# --------------------------------------------------------------------------- + + +class TestRealisticBatch: + def test_realistic_batch(self): + """Realistic record batch: name, coords struct, readings list. + + name: ['A', null, 'C'] + coords: [{lat:40.7,lon:-74.0}, {lat:34.0,lon:-118.2}, {lat:51.5,lon:-0.1}] + readings: [[1.0,2.0], null, [3.0,4.0,5.0]] + """ + schema = pa.schema([ + pa.field("name", pa.large_utf8(), nullable=True), + pa.field("coords", pa.struct([ + pa.field("lat", pa.float64(), nullable=False), + pa.field("lon", pa.float64(), nullable=False), + ]), nullable=False), + pa.field("readings", pa.large_list( + pa.field("item", pa.float32(), nullable=False)), nullable=True), + ]) + + name_arr = pa.array(["A", None, "C"], type=pa.large_utf8()) + lat_arr = pa.array([40.7, 34.0, 51.5], type=pa.float64()) + lon_arr = pa.array([-74.0, -118.2, -0.1], type=pa.float64()) + coords_arr = pa.StructArray.from_arrays( + [lat_arr, lon_arr], + names=["lat", "lon"], + ) + + reading_vals = pa.array([1.0, 2.0, 3.0, 4.0, 5.0], type=pa.float32()) + offsets = pa.array([0, 2, 2, 5], type=pa.int64()) + reading_mask = pa.array([False, True, False], type=pa.bool_()) + readings_arr = pa.LargeListArray.from_arrays( + offsets, reading_vals, + type=pa.large_list(pa.field("item", pa.float32(), nullable=False)), + mask=reading_mask, + ) + + batch = _record_batch([name_arr, coords_arr, readings_arr], schema=schema) + result = ArrowDigester.hash_record_batch(batch).hex() + assert result == "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac" + + def test_realistic_schema(self): + """Schema hash for realistic batch.""" + schema = pa.schema([ + pa.field("name", pa.large_utf8(), nullable=True), + pa.field("coords", pa.struct([ + pa.field("lat", pa.float64(), nullable=False), + pa.field("lon", pa.float64(), nullable=False), + ]), nullable=False), + pa.field("readings", pa.large_list( + pa.field("item", pa.float32(), nullable=False)), nullable=True), + ]) + result = ArrowDigester.hash_schema(schema).hex() + assert result == "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356" diff --git a/tests/test_legacy_v0_4_metadata_hashing.py b/tests/test_legacy_v0_4_metadata_hashing.py new file mode 100644 index 0000000..e76f961 --- /dev/null +++ b/tests/test_legacy_v0_4_metadata_hashing.py @@ -0,0 +1,382 @@ +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import +(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. + +Tests for include_metadata hashing option (PLT-1734). + +Verifies that: +- include_metadata=False (default) ignores all Arrow metadata (hash format 0.0.1 stability) +- include_metadata=True detects changes to schema-level and field-level metadata +- Hashes are deterministic regardless of metadata key insertion order +- Empty-metadata invariant: no metadata → same hash regardless of include_metadata +""" +from __future__ import annotations + +import pyarrow as pa +import pytest +from starfix.legacy.v0_4 import ( + ArrowDigester, + _collect_nested_field_metadata, + _sort_metadata, +) + + +class TestSortMetadata: + def test_sorts_by_key(self): + meta = {b"z": b"1", b"a": b"2", b"m": b"3"} + result = _sort_metadata(meta) + assert list(result.keys()) == ["a", "m", "z"] + + def test_decodes_bytes_to_utf8(self): + meta = {b"key": b"value"} + result = _sort_metadata(meta) + assert result == {"key": "value"} + assert isinstance(list(result.keys())[0], str) + + def test_none_returns_empty_dict(self): + assert _sort_metadata(None) == {} + + def test_empty_dict_returns_empty_dict(self): + assert _sort_metadata({}) == {} + + +class TestCollectNestedFieldMetadata: + def test_top_level_field_with_metadata(self): + field = pa.field("x", pa.int32(), metadata={b"unit": b"kg"}) + result = _collect_nested_field_metadata(field, "x") + assert result == {"x": {"unit": "kg"}} + + def test_field_without_metadata_not_included(self): + field = pa.field("x", pa.int32()) + result = _collect_nested_field_metadata(field, "x") + assert result == {} + + def test_struct_child_metadata_uses_slash_separator(self): + child = pa.field("age", pa.int32(), metadata={b"unit": b"years"}) + parent = pa.field("person", pa.struct([child])) + result = _collect_nested_field_metadata(parent, "person") + assert result == {"person/age": {"unit": "years"}} + + def test_list_element_field_uses_trailing_slash(self): + element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) + list_field = pa.field("items", pa.large_list(element)) + result = _collect_nested_field_metadata(list_field, "items") + assert result == {"items/": {"unit": "count"}} + + def test_regular_list_element_field_also_uses_trailing_slash(self): + element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) + list_field = pa.field("items", pa.list_(element)) + result = _collect_nested_field_metadata(list_field, "items") + assert result == {"items/": {"unit": "count"}} + + def test_parent_field_and_child_both_with_metadata(self): + child = pa.field("age", pa.int32(), metadata={b"unit": b"years"}) + parent = pa.field("person", pa.struct([child]), metadata={b"source": b"census"}) + result = _collect_nested_field_metadata(parent, "person") + assert result == { + "person": {"source": "census"}, + "person/age": {"unit": "years"}, + } + + def test_result_is_sorted_by_path(self): + child_z = pa.field("z", pa.int32(), metadata={b"k": b"v"}) + child_a = pa.field("a", pa.int32(), metadata={b"k": b"v"}) + parent = pa.field("s", pa.struct([child_z, child_a])) + result = _collect_nested_field_metadata(parent, "s") + assert list(result.keys()) == ["s/a", "s/z"] + + def test_map_item_field_metadata_uses_trailing_slash(self): + item = pa.field("value", pa.int32(), metadata={b"unit": b"cents"}) + map_field = pa.field("m", pa.map_(pa.utf8(), item)) + result = _collect_nested_field_metadata(map_field, "m") + assert result == {"m/": {"unit": "cents"}} + + def test_fixed_size_list_element_uses_trailing_slash(self): + element = pa.field("item", pa.int32(), metadata={b"unit": b"count"}) + list_field = pa.field("items", pa.list_(element, 3)) + result = _collect_nested_field_metadata(list_field, "items") + assert result == {"items/": {"unit": "count"}} + + +class TestEmptyMetadataInvariant: + def test_no_metadata_include_true_equals_false(self): + """Schema with no metadata: include_metadata=True == include_metadata=False.""" + schema = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + assert ( + ArrowDigester.hash_schema(schema, include_metadata=True) + == ArrowDigester.hash_schema(schema, include_metadata=False) + ) + + +class TestFieldMetadataChangesHash: + def test_hash_schema_detects_field_metadata(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"unit": b"kg"}), + ]) + assert ( + ArrowDigester.hash_schema(schema_plain, include_metadata=True) + != ArrowDigester.hash_schema(schema_meta, include_metadata=True) + ) + + def test_hash_record_batch_detects_field_metadata(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"unit": b"kg"}), + ]) + batch_plain = pa.record_batch({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_plain) + batch_meta = pa.record_batch({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_meta) + assert ( + ArrowDigester.hash_record_batch(batch_plain, include_metadata=True) + != ArrowDigester.hash_record_batch(batch_meta, include_metadata=True) + ) + + def test_hash_table_detects_field_metadata(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"unit": b"kg"}), + ]) + table_plain = pa.table({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_plain) + table_meta = pa.table({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_meta) + assert ( + ArrowDigester.hash_table(table_plain, include_metadata=True) + != ArrowDigester.hash_table(table_meta, include_metadata=True) + ) + + def test_streaming_digester_detects_field_metadata(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"unit": b"kg"}), + ]) + batch_plain = pa.record_batch({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_plain) + batch_meta = pa.record_batch({"x": pa.array([1, 2], type=pa.int32())}, schema=schema_meta) + + d_plain = ArrowDigester(schema_plain, include_metadata=True) + d_plain.update(batch_plain) + + d_meta = ArrowDigester(schema_meta, include_metadata=True) + d_meta.update(batch_meta) + + assert d_plain.finalize() != d_meta.finalize() + + def test_struct_child_metadata_changes_hash(self): + child_plain = pa.field("age", pa.int32(), nullable=False) + child_meta = pa.field("age", pa.int32(), nullable=False, metadata={b"unit": b"years"}) + schema_plain = pa.schema([pa.field("person", pa.struct([child_plain]), nullable=False)]) + schema_meta = pa.schema([pa.field("person", pa.struct([child_meta]), nullable=False)]) + assert ( + ArrowDigester.hash_schema(schema_plain, include_metadata=True) + != ArrowDigester.hash_schema(schema_meta, include_metadata=True) + ) + + def test_list_element_field_metadata_changes_hash(self): + element_plain = pa.field("item", pa.int32(), nullable=False) + element_meta = pa.field("item", pa.int32(), nullable=False, metadata={b"unit": b"count"}) + schema_plain = pa.schema([pa.field("items", pa.large_list(element_plain), nullable=True)]) + schema_meta = pa.schema([pa.field("items", pa.large_list(element_meta), nullable=True)]) + assert ( + ArrowDigester.hash_schema(schema_plain, include_metadata=True) + != ArrowDigester.hash_schema(schema_meta, include_metadata=True) + ) + + +class TestMetadataExcludedByDefault: + def test_field_metadata_ignored_by_default(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, + metadata={b"ARROW:extension:name": b"my_ext"}), + ]) + assert ArrowDigester.hash_schema(schema_plain) == ArrowDigester.hash_schema(schema_meta) + + def test_schema_metadata_ignored_by_default(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema( + [pa.field("x", pa.int32(), nullable=False)], + metadata={b"version": b"2"}, + ) + assert ArrowDigester.hash_schema(schema_plain) == ArrowDigester.hash_schema(schema_meta) + + def test_default_matches_hash_format_001_golden_value(self): + """Batch with metadata + include_metadata=False must match the hash format 0.0.1 + golden value from test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table.""" + schema = pa.schema([ + pa.field("age", pa.int32(), nullable=False, metadata={b"unit": b"years"}), + pa.field("name", pa.large_utf8(), nullable=True), + ], metadata={b"source": b"survey"}) + batch = pa.record_batch( + { + "age": pa.array([25, 30], type=pa.int32()), + "name": pa.array(["Alice", None], type=pa.large_utf8()), + }, + schema=schema, + ) + result = ArrowDigester.hash_record_batch(batch, include_metadata=False).hex() + assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + + +class TestSchemaMetadataChangesHash: + def test_schema_level_metadata_changes_hash(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema( + [pa.field("x", pa.int32(), nullable=False)], + metadata={b"version": b"2"}, + ) + assert ( + ArrowDigester.hash_schema(schema_plain, include_metadata=True) + != ArrowDigester.hash_schema(schema_meta, include_metadata=True) + ) + + def test_field_and_schema_metadata_independently_encoded(self): + """Same key/value placed on a field vs on the schema must produce different hashes.""" + schema_on_field = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"version": b"2"}), + ]) + schema_on_schema = pa.schema( + [pa.field("x", pa.int32(), nullable=False)], + metadata={b"version": b"2"}, + ) + assert ( + ArrowDigester.hash_schema(schema_on_field, include_metadata=True) + != ArrowDigester.hash_schema(schema_on_schema, include_metadata=True) + ) + + +class TestMetadataDeterminism: + def test_field_metadata_key_order_does_not_affect_hash(self): + meta_abc = {b"alpha": b"1", b"beta": b"2", b"gamma": b"3"} + meta_cba = {b"gamma": b"3", b"alpha": b"1", b"beta": b"2"} + schema_a = pa.schema([pa.field("x", pa.int32(), nullable=False, metadata=meta_abc)]) + schema_b = pa.schema([pa.field("x", pa.int32(), nullable=False, metadata=meta_cba)]) + assert ( + ArrowDigester.hash_schema(schema_a, include_metadata=True) + == ArrowDigester.hash_schema(schema_b, include_metadata=True) + ) + + def test_schema_metadata_key_order_does_not_affect_hash(self): + schema_a = pa.schema([pa.field("x", pa.int32())], metadata={b"p": b"1", b"q": b"2"}) + schema_b = pa.schema([pa.field("x", pa.int32())], metadata={b"q": b"2", b"p": b"1"}) + assert ( + ArrowDigester.hash_schema(schema_a, include_metadata=True) + == ArrowDigester.hash_schema(schema_b, include_metadata=True) + ) + + def test_multiple_fields_with_shuffled_metadata_keys(self): + schema_a = pa.schema([ + pa.field("x", pa.int32(), metadata={b"p": b"1", b"q": b"2", b"r": b"3"}), + pa.field("y", pa.float64(), metadata={b"s": b"4", b"t": b"5", b"u": b"6"}), + ]) + schema_b = pa.schema([ + pa.field("x", pa.int32(), metadata={b"r": b"3", b"p": b"1", b"q": b"2"}), + pa.field("y", pa.float64(), metadata={b"u": b"6", b"s": b"4", b"t": b"5"}), + ]) + assert ( + ArrowDigester.hash_schema(schema_a, include_metadata=True) + == ArrowDigester.hash_schema(schema_b, include_metadata=True) + ) + + +class TestEmptyMetadataInvariantFull: + def test_explicit_empty_schema_metadata_treated_as_no_metadata(self): + schema_none = pa.schema([pa.field("x", pa.int32())]) + schema_empty = pa.schema([pa.field("x", pa.int32())], metadata={}) + assert ( + ArrowDigester.hash_schema(schema_none, include_metadata=True) + == ArrowDigester.hash_schema(schema_empty, include_metadata=True) + ) + + def test_explicit_empty_field_metadata_treated_as_no_metadata(self): + schema_none = pa.schema([pa.field("x", pa.int32())]) + schema_empty = pa.schema([pa.field("x", pa.int32(), metadata={})]) + assert ( + ArrowDigester.hash_schema(schema_none, include_metadata=True) + == ArrowDigester.hash_schema(schema_empty, include_metadata=True) + ) + + +class TestRoundTrip: + def test_add_then_change_metadata_both_differ(self): + """Adding and then changing metadata each produce distinct hashes.""" + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_v1 = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"version": b"1"}), + ]) + schema_v2 = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"version": b"2"}), + ]) + h_plain = ArrowDigester.hash_schema(schema_plain, include_metadata=True) + h_v1 = ArrowDigester.hash_schema(schema_v1, include_metadata=True) + h_v2 = ArrowDigester.hash_schema(schema_v2, include_metadata=True) + assert h_plain != h_v1 + assert h_v1 != h_v2 + assert h_plain != h_v2 + + def test_removing_metadata_restores_hash(self): + schema_plain = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + schema_meta = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"unit": b"kg"}), + ]) + h_plain = ArrowDigester.hash_schema(schema_plain, include_metadata=True) + h_meta = ArrowDigester.hash_schema(schema_meta, include_metadata=True) + assert h_plain != h_meta + # Removing metadata restores the original hash + schema_restored = pa.schema([pa.field("x", pa.int32(), nullable=False)]) + assert ArrowDigester.hash_schema(schema_restored, include_metadata=True) == h_plain + + def test_changing_metadata_value_changes_hash(self): + schema_v1 = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"version": b"1"}), + ]) + schema_v2 = pa.schema([ + pa.field("x", pa.int32(), nullable=False, metadata={b"version": b"2"}), + ]) + assert ( + ArrowDigester.hash_schema(schema_v1, include_metadata=True) + != ArrowDigester.hash_schema(schema_v2, include_metadata=True) + ) + + def test_nested_struct_child_metadata_round_trip(self): + """Round-trip: add/remove metadata on a nested struct child field.""" + child_plain = pa.field("age", pa.int32(), nullable=False) + child_meta = pa.field("age", pa.int32(), nullable=False, metadata={b"unit": b"years"}) + schema_plain = pa.schema([pa.field("person", pa.struct([child_plain]))]) + schema_meta = pa.schema([pa.field("person", pa.struct([child_meta]))]) + + h_plain = ArrowDigester.hash_schema(schema_plain, include_metadata=True) + h_meta = ArrowDigester.hash_schema(schema_meta, include_metadata=True) + assert h_plain != h_meta + + # Removing the child metadata restores the original hash + schema_restored = pa.schema([pa.field("person", pa.struct([child_plain]))]) + assert ArrowDigester.hash_schema(schema_restored, include_metadata=True) == h_plain + + def test_list_element_field_metadata_round_trip(self): + """Round-trip: add/remove metadata on a list element field (trailing-slash path).""" + element_plain = pa.field("item", pa.int32(), nullable=False) + element_meta = pa.field("item", pa.int32(), nullable=False, metadata={b"unit": b"count"}) + schema_plain = pa.schema([pa.field("items", pa.large_list(element_plain))]) + schema_meta = pa.schema([pa.field("items", pa.large_list(element_meta))]) + + h_plain = ArrowDigester.hash_schema(schema_plain, include_metadata=True) + h_meta = ArrowDigester.hash_schema(schema_meta, include_metadata=True) + assert h_plain != h_meta + + # Removing the element field metadata restores the original hash + schema_restored = pa.schema([pa.field("items", pa.large_list(element_plain))]) + assert ArrowDigester.hash_schema(schema_restored, include_metadata=True) == h_plain + + +class TestFieldPathSorting: + def test_fields_are_globally_sorted_by_path(self): + """Field paths are sorted alphabetically regardless of schema field definition order.""" + schema_za = pa.schema([ + pa.field("z_col", pa.int32(), metadata={b"k": b"1"}), + pa.field("a_col", pa.int32(), metadata={b"k": b"2"}), + ]) + schema_az = pa.schema([ + pa.field("a_col", pa.int32(), metadata={b"k": b"2"}), + pa.field("z_col", pa.int32(), metadata={b"k": b"1"}), + ]) + assert ( + ArrowDigester.hash_schema(schema_za, include_metadata=True) + == ArrowDigester.hash_schema(schema_az, include_metadata=True) + ) From f65253f72c656019785a38fe05a13be9eda577ff Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:38:09 -0800 Subject: [PATCH 31/49] perf: legacy 0.4 mode hashes list slices without copying the shared buffer (ITL-908) One performance-only line in src/starfix/legacy/v0_4.py, marked LEGACY PATCH: raw = memoryview(data_buf) instead of data_buf.to_pybytes() in _hash_fixed_size_data (the ITL-908 P1 fix). List columns now hash in linear time when migration reads large stores. No hash changes: the restored 0.4.0 tests pass and the differential test against the released starfix==0.4.0 still compares 2794 results with 0 differences. The header says the file differs from 0.4.0 by exactly this line; the freeze guard's sha256 is updated in this commit. Co-Authored-By: Claude Opus 5.5 --- README.md | 3 ++- src/starfix/legacy/v0_4.py | 8 ++++++-- tests/test_legacy_v0_4_frozen.py | 2 +- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 449690e..bc7072d 100644 --- a/README.md +++ b/README.md @@ -125,7 +125,8 @@ to read or match data hashed by starfix-python 0.4.x** (for example to find stor its old key). **Never hash new data with it**: use `starfix.ArrowDigester`. It is frozen: never fixed and never extended (no order options). Its code is the 0.4.0 module -verbatim, kept apart from the format-2 code. Its output is pinned by the restored 0.4.0 tests and golden file, and by a differential +verbatim except one performance-only line (list columns hash in linear time; no hash changes), +kept apart from the format-2 code. Its output is pinned by the restored 0.4.0 tests and golden file, and by a differential test against the released `starfix==0.4.0` package. Known defects, kept on purpose (all fixed in format 2): diff --git a/src/starfix/legacy/v0_4.py b/src/starfix/legacy/v0_4.py index 0fe954d..b673b3e 100644 --- a/src/starfix/legacy/v0_4.py +++ b/src/starfix/legacy/v0_4.py @@ -2,7 +2,11 @@ # FROZEN LEGACY MODULE: starfix-python 0.4 hash format (format 1, prefix 00 00 01). # # This file is starfix-python v0.4.0's src/starfix/arrow_digester.py (tag v0.4.0, commit -# d2ed97e), VERBATIM below this header. It exists ONLY to read or match data hashed by +# d2ed97e), verbatim below this header EXCEPT ONE performance-only line, marked +# "LEGACY PATCH": in _hash_fixed_size_data, `raw = data_buf.to_pybytes()` became +# `raw = memoryview(data_buf)`, which removes the quadratic cost of list columns (ITL-908) +# and changes no hash (proven by the restored 0.4.0 tests and by the differential test +# against the released starfix==0.4.0). It exists ONLY to read or match data hashed by # starfix-python 0.4.x; never hash new data with it (use starfix.ArrowDigester, format 2). # Its known defects (collisions, batch-split dependence, differences from Rust 0.4) are # kept on purpose and listed in the README section "Legacy 0.4 mode". @@ -671,7 +675,7 @@ def _hash_fixed_size_data(arr, data_digest, element_size: int, effective_nulls) data_buf = bufs[1] offset = arr.offset - raw = data_buf.to_pybytes() + raw = memoryview(data_buf) # LEGACY PATCH (performance only, see header) start = offset * element_size if effective_nulls is None: diff --git a/tests/test_legacy_v0_4_frozen.py b/tests/test_legacy_v0_4_frozen.py index 8aa3c9e..73bab19 100644 --- a/tests/test_legacy_v0_4_frozen.py +++ b/tests/test_legacy_v0_4_frozen.py @@ -13,7 +13,7 @@ _SRC = Path(__file__).parent.parent / "src" / "starfix" _LEGACY = _SRC / "legacy" / "v0_4.py" -_LEGACY_SHA256 = "652b0620bc484ab0ccf89a5423945244e6195d99484e1afcae48de5f4704ada3" +_LEGACY_SHA256 = "7b4c76508f1f96b96c18e0d2bac87b9f2e8ae8b343254b9be5060e87e0fe6704" def test_legacy_module_is_unchanged() -> None: From 277d691801b4d06f06d77d0554010f1187c44f0a Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:38:34 -0800 Subject: [PATCH 32/49] fix(format2): zero-width FixedSizeBinary contributes no value bytes (ITL-898) Copilot review: a nullable FixedSizeBinary(0) leaf divided by zero when sizing its chunks. Zero-width values have no payload; their validity is recorded as usual. Regression test at the root and under a nullable struct. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 2 ++ tests/test_format2.py | 10 ++++++++++ 2 files changed, 12 insertions(+) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index fba1b91..b83b989 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -437,6 +437,8 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: digest.update(memoryview(chunk.buffers()[1])[chunk.offset:chunk.offset + len(chunk)]) return width = _value_width(t) + if width == 0: + return # FixedSizeBinary(0): no value bytes (validity is recorded by _visit) if width is not None: if bits is None: if n: diff --git a/tests/test_format2.py b/tests/test_format2.py index 09d05ac..14ccb41 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -713,3 +713,13 @@ def test_nullable_leaves_hashed_in_bounded_chunks(budget, monkeypatch) -> None: validity = u64(len(arr)) + bits.to_bytes((len(arr) + 7) // 8, "little") expected = V + sha(header(0), f2.type_json(arr.type, 0).encode(), u64(len(arr)), validity, sha(value_bytes)) assert f2.hash_array(arr) == expected, (arr.type, budget) + + +def test_zero_width_fixed_size_binary() -> None: + """FixedSizeBinary(0) values contribute no bytes; nulls are still recorded.""" + arr = pa.array([b"", None, b""], type=pa.binary(0)) + expected = V + sha(header(0), b'{"FixedSizeBinary":0}', u64(3), u64(3) + b"\x05", sha(b"")) + assert f2.hash_array(arr) == expected + st = pa.StructArray.from_arrays([pa.array([b"", b""], pa.binary(0))], fields=[pa.field("z", pa.binary(0), nullable=False)], + mask=pa.array([False, True])) + f2.hash_record_batch(pa.record_batch([st], names=["s"])) # masked by a nullable struct From 1d9ae9bbe96ac7cca1ae0b13b7ee1f129e51b060 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:43:20 -0800 Subject: [PATCH 33/49] test(format2): dictionary of List and hidden child nulls under non-nullable list items (ITL-898) Inputs from the independent Rust review: a dictionary whose values are a List hashes as the plain list (column, struct child, hash_array); child nulls under a null list slot or outside the offsets are not elements and are accepted; a visible null under a valid slot is rejected. Co-Authored-By: Claude Opus 5.5 --- tests/test_format2.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/tests/test_format2.py b/tests/test_format2.py index 14ccb41..b88a97d 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -723,3 +723,45 @@ def test_zero_width_fixed_size_binary() -> None: st = pa.StructArray.from_arrays([pa.array([b"", b""], pa.binary(0))], fields=[pa.field("z", pa.binary(0), nullable=False)], mask=pa.array([False, True])) f2.hash_record_batch(pa.record_batch([st], names=["s"])) # masked by a nullable struct + + +# ── Inputs from the Rust review (ITL-898) ─────────────────────────────── + + +def test_dictionary_of_list_equals_plain_list() -> None: + """A dictionary whose values are a List (32-bit offsets) hashes as the plain list.""" + lt = pa.list_(pa.int32()) + dict_arr = pa.DictionaryArray.from_arrays(pa.array([0, 1, 0, 2, None], pa.int8()), pa.array([[1, 2], [3], None], lt)) + plain = pa.array([[1, 2], [3], [1, 2], None, None], lt) + assert f2.hash_array(dict_arr) == f2.hash_array(plain) + assert f2.hash_record_batch(pa.record_batch([dict_arr], names=["c"])) == f2.hash_record_batch( + pa.record_batch([plain], names=["c"]) + ) + s_dict = pa.StructArray.from_arrays([dict_arr], names=["l"]) + s_plain = pa.StructArray.from_arrays([plain], names=["l"]) + assert f2.hash_record_batch(pa.record_batch([s_dict], names=["s"])) == f2.hash_record_batch( + pa.record_batch([s_plain], names=["s"]) + ) + + +def test_list_non_nullable_items_with_hidden_child_nulls() -> None: + """Child nulls under a null list slot or outside the offsets are not elements (accepted).""" + t = pa.list_(pa.field("item", pa.int32(), nullable=False)) + schema = pa.schema([pa.field("l", t)]) + child = pa.array([1, None, 2, None], pa.int32()) + under_null_slot = pa.ListArray.from_arrays( + pa.array([0, 1, 2, 3], pa.int32()), child.slice(0, 3), mask=pa.array([False, True, False]) + ).cast(t) + clean = pa.ListArray.from_arrays( + pa.array([0, 1, 1, 2], pa.int32()), pa.array([1, 2], pa.int32()), mask=pa.array([False, True, False]) + ).cast(t) + assert f2.hash_record_batch(pa.record_batch([under_null_slot], schema=schema)) == f2.hash_record_batch( + pa.record_batch([clean], schema=schema) + ) + outside_offsets = pa.ListArray.from_arrays(pa.array([0, 1, 1], pa.int32()), child).cast(t) + assert f2.hash_record_batch(pa.record_batch([outside_offsets], schema=schema)) == f2.hash_record_batch( + pa.record_batch([pa.array([[1], []], t)], schema=schema) + ) + visible = pa.ListArray.from_arrays(pa.array([0, 2], pa.int32()), pa.array([1, None], pa.int32())).cast(t) + with pytest.raises(ValueError, match="Non-nullable"): + f2.hash_array(visible) From 8f145d5ddb75e64403a395657b5a3c454274fbde Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:48:12 -0800 Subject: [PATCH 34/49] test: legacy separation guard resolves relative and package-level imports (ITL-898) Copilot review: the guard missed from .legacy.v0_4 import X, from . import legacy and from starfix import legacy. Relative imports are now resolved against the file's package and imported names are included; a self-test covers each form. Co-Authored-By: Claude Opus 5.5 --- tests/test_legacy_v0_4_frozen.py | 41 ++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/tests/test_legacy_v0_4_frozen.py b/tests/test_legacy_v0_4_frozen.py index 73bab19..9933ce6 100644 --- a/tests/test_legacy_v0_4_frozen.py +++ b/tests/test_legacy_v0_4_frozen.py @@ -22,13 +22,32 @@ def test_legacy_module_is_unchanged() -> None: ) -def _imported_modules(path: Path) -> set[str]: +def _package_of(path: Path) -> str: + """Dotted package of a source file below src/ (e.g. src/starfix/legacy/v0_4.py -> starfix.legacy).""" + parts = path.relative_to(_SRC.parent).with_suffix("").parts + return ".".join(parts[:-1] if parts[-1] != "__init__" else parts[:-1]) + + +def _imported_modules(path: Path, source: str | None = None) -> set[str]: + """Absolute dotted names a module imports: modules and module.name for each imported name. + + Relative imports are resolved against the file's package, so `from . import legacy` and + `from .legacy.v0_4 import X` are seen as starfix.legacy / starfix.legacy.v0_4.X. + """ + package = _package_of(path) names: set[str] = set() - for node in ast.walk(ast.parse(path.read_text(encoding="utf-8"))): + for node in ast.walk(ast.parse(source if source is not None else path.read_text(encoding="utf-8"))): if isinstance(node, ast.Import): names.update(alias.name for alias in node.names) - elif isinstance(node, ast.ImportFrom) and node.module: - names.add(node.module) + elif isinstance(node, ast.ImportFrom): + if node.level: + base = package.split(".") + base = base[: len(base) - (node.level - 1)] if node.level > 1 else base + module = ".".join(base + ([node.module] if node.module else [])) + else: + module = node.module or "" + names.add(module) + names.update(f"{module}.{alias.name}" for alias in node.names) return names @@ -39,3 +58,17 @@ def test_legacy_imports_only_stdlib_and_pyarrow() -> None: def test_format2_does_not_import_legacy() -> None: for path in (_SRC / "_format2.py", _SRC / "arrow_digester.py", _SRC / "__init__.py"): assert not {m for m in _imported_modules(path) if m.startswith("starfix.legacy")}, path + + +def test_separation_guard_sees_relative_and_package_imports() -> None: + """The guard itself: every ordinary way of importing the legacy module is detected.""" + fake = _SRC / "_format2.py" + for source in ( + "from .legacy.v0_4 import ArrowDigester", + "from . import legacy", + "from starfix import legacy", + "import starfix.legacy.v0_4", + "from starfix.legacy import v0_4", + ): + found = {m for m in _imported_modules(fake, source) if m.startswith("starfix.legacy")} + assert found, source From da8e945db22bfdb77ff1633cec48ba055d665377 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:50:32 -0800 Subject: [PATCH 35/49] fix(format2): list children are zero-copy slices with a selection mask (ITL-898) Copilot review: a list with a null row (or under a null struct value) was filtered as a whole, which copies the child buffers (a second copy of a list payload). Now a list node writes the lengths of its present rows (value_lengths filtered as integers) and visits its child as a zero-copy slice of the original values with a selection mask take(present_rows, list_parent_indices): elements outside the selection are not elements (no validity, lengths or values), as the spec requires. Same bytes (goldens, spec examples, offset and hidden-null tests). Regression test on a fresh proxy of the Arrow memory pool (tracemalloc cannot see Arrow allocations): hashing a nullable list with a 4 MB payload peaks far below the payload (the old code peaked at 4.03 MB). Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 64 ++++++++++++++++++++++++----------- tests/test_format2_scaling.py | 23 +++++++++++++ 2 files changed, 67 insertions(+), 20 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index b83b989..e6c5e2b 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -468,10 +468,10 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: for chunk_start in range(0, n, _CHUNK): chunk_end = min(chunk_start + _CHUNK, n) offs = offsets[chunk_start:chunk_end + 1].tolist() - pairs = zip(offs, offs[1:]) + pairs = zip(offs, offs[1:], strict=False) # consecutive offsets if bits is not None: flags = bits.slice(chunk_start, chunk_end - chunk_start).to_pylist() - pairs = (pair for pair, ok in zip(pairs, flags) if ok) + pairs = (pair for pair, ok in zip(pairs, flags, strict=True) if ok) for a, b in pairs: size_i = b - a if size_i >= _BYTE_BUDGET: @@ -492,45 +492,69 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: raise ValueError(f"Hashing data of type {t} is not supported") # checked earlier (Section 7) -def _visit(field: pa.Field, arr: pa.Array, path: str, enclosing: pa.Array | None, entries: dict) -> None: - """Feed the elements `arr` of the node `field` at `path` into its entry (Section 3.2). - - `enclosing` is the AND of the enclosing struct validities at this list level (None: - all valid). +def _visit( + field: pa.Field, + arr: pa.Array, + path: str, + enclosing: pa.Array | None, + entries: dict, + select: pa.Array | None = None, +) -> None: + """Feed the elements of the node `field` at `path` into its entry (Section 3.2). + + `arr` holds the node's candidate elements; `select` (None: all) marks which of them are + elements at all: below a list, the items of valid list values (items of null or masked + list values are not visited). `enclosing` is the AND of the enclosing struct validities + at this list level (None: all valid). Nothing proportional to the payload is copied: + list children are zero-copy slices of the original values with a selection mask. """ arr = _resolve(arr) entry = entries[path] own = arr.is_valid() if arr.null_count else None if own is not None and not field.nullable: - # Section 7 item 4: a null in a non-nullable node not masked by an enclosing struct null. - bad = own if enclosing is None else pc.or_(own, pc.invert(enclosing)) - if not pc.all(bad).as_py(): + # Section 7 item 4: a null in a non-nullable node not masked by an enclosing struct + # null (elements outside `select` are not elements and are ignored). + ok = own if enclosing is None else pc.or_(own, pc.invert(enclosing)) + if select is not None: + ok = pc.or_(ok, pc.invert(select)) + if not pc.all(ok).as_py(): raise ValueError(f"Non-nullable field {path!r} contains nulls") bits = _and(own, enclosing) if entry.validity is not None: if bits is None: - entry.validity.append_true(len(arr)) + entry.validity.append_true(len(arr) if select is None else (pc.sum(select).as_py() or 0)) else: - entry.validity.append_bitmap(bits.buffers()[1], bits.offset, len(bits)) + written = bits if select is None else bits.filter(select) + entry.validity.append_bitmap(written.buffers()[1], written.offset, len(written)) if entry.kind == "struct": t = arr.type for i in range(t.num_fields): child = t.field(i) - _visit(child, arr.field(i), f"{path}/{child.name}", bits, entries) + _visit(child, arr.field(i), f"{path}/{child.name}", bits, entries, select) return + present = _and(bits, select) # elements that are visited and valid (None: all) if entry.kind == "list": - valid = arr if bits is None else arr.filter(bits) - if len(valid): - lengths = pc.cast(valid.value_lengths(), pa.uint64()) - entry.lengths.update(memoryview(lengths.buffers()[1])[lengths.offset * 8:(lengths.offset + len(lengths)) * 8]) - # Items of valid list values only; list boundaries reset struct validity. - _visit(arr.type.value_field, valid.flatten(), path + "/", None, entries) + lengths = arr.value_lengths() + if present is not None: + lengths = lengths.filter(present) + if len(lengths): + lengths = pc.cast(lengths, pa.uint64()) + entry.lengths.update( + memoryview(lengths.buffers()[1])[lengths.offset * 8:(lengths.offset + len(lengths)) * 8] + ) + # The items of all list values, as a zero-copy slice of the child, with the items of + # null (or not visited) list values deselected. List boundaries reset `enclosing`. + offsets = arr.offsets + first, last = offsets[0].as_py(), offsets[len(arr)].as_py() + items = arr.values.slice(first, last - first) + item_select = None if present is None else pc.take(present, pc.list_parent_indices(arr)) + _visit(arr.type.value_field, items, path + "/", None, entries, item_select) return - _hash_values(arr, bits, entry.values) + _hash_values(arr, present, entry.values) def _is_unsupported_data(t: pa.DataType) -> bool: diff --git a/tests/test_format2_scaling.py b/tests/test_format2_scaling.py index 16ff5ca..6724776 100644 --- a/tests/test_format2_scaling.py +++ b/tests/test_format2_scaling.py @@ -65,3 +65,26 @@ def counting(*args, **kwargs): f2.hash_table(_nested_table(rows)) counts.append(calls) assert counts[0] == counts[1], f"{counts[0]} visits for 10 rows, {counts[1]} for 10,000 rows" + + +def test_nullable_list_of_binary_does_not_copy_the_payload() -> None: + """A list column with a null row is not filtered as a whole (no second payload copy). + + Arrow allocations are invisible to tracemalloc, so they are measured on a fresh proxy of + the Arrow memory pool, made the default for the duration of the hash. + """ + values = pa.array([b"x" * 1000] * 4000, pa.binary()) # 4 MB payload + offsets = pa.array(range(0, 4001, 4), pa.int32()) + mask = pa.array([i == 0 for i in range(1000)]) + table = pa.table({"c": pa.ListArray.from_arrays(offsets, values, mask=mask)}) + payload = values.buffers()[2].size + f2.hash_table(table.slice(0, 2)) # warm up + + default = pa.default_memory_pool() + pool = pa.proxy_memory_pool(default) + pa.set_memory_pool(pool) + try: + f2.hash_table(table) + finally: + pa.set_memory_pool(default) + assert pool.max_memory() < payload // 4, f"Arrow peak {pool.max_memory()} bytes for a {payload}-byte payload" From 64179f9fa3acbffccafe6ae2f053446255f6591e Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 04:56:45 -0800 Subject: [PATCH 36/49] feat(format2): entry-point kind in the header; hash_array root always nullable (ITL-898) Developer decision 2026-11-11 (provisional until the Rust spec and golden): - header = 0x00 || "starfix" || 00 00 02 || kind || flags (13 bytes), kind 'S' schema digest, 'R' record batch / stream / table, 'A' hash_array - the record-batch / stream final digest starts with its own 'R' header - the hash_array root is always nullable: its validity is always written Spec-level tests migrated to the new layout; the old printed hashes are replaced by byte-structure assertions until the new spec prints its values. Pins: nested dictionaries resolve recursively; FixedSizeBinary(0) 1 row != 5. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 26 +++++---- tests/test_format2.py | 121 +++++++++++++++++++++++++++------------- 2 files changed, 97 insertions(+), 50 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index e6c5e2b..685a21f 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -24,6 +24,11 @@ ORDERED_COLUMNS = 0x01 ORDERED_STRUCT_FIELDS = 0x02 +# Section 1: entry-point kind, one ASCII byte of the header. +KIND_SCHEMA = b"S" # schema digest (hash_schema, and the schema digest inside record hashes) +KIND_RECORDS = b"R" # record batch / stream / table final digest +KIND_ARRAY = b"A" # hash_array + _SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" _U64 = struct.Struct(" int: return (ORDERED_COLUMNS if ordered_columns else 0) | (ORDERED_STRUCT_FIELDS if ordered_struct_fields else 0) -def header(flags: int) -> bytes: - """Section 1: 0x00 || "starfix" || version || flags (12 bytes).""" - return _HEADER_PREFIX + bytes([flags]) +def header(kind: bytes, flags: int) -> bytes: + """Section 1: 0x00 || "starfix" || version || kind || flags (13 bytes).""" + return _HEADER_PREFIX + kind + bytes([flags]) def _json(value: Any) -> str: @@ -305,7 +310,7 @@ def schema_digest(schema: pa.Schema, include_metadata: bool, flags: int) -> byte """Section 2.5.""" schema_nodes(schema) # Section 7 rejections phase1, phase2 = schema_key(schema, include_metadata, flags) - h = hashlib.sha256(header(flags)) + h = hashlib.sha256(header(KIND_SCHEMA, flags)) h.update(phase1.encode()) if phase2 is not None: h.update(phase2.encode()) @@ -626,7 +631,8 @@ def update(self, batch: pa.RecordBatch) -> None: self._rows += batch.num_rows def finalize(self) -> bytes: - final = hashlib.sha256(self._schema_digest) + final = hashlib.sha256(header(KIND_RECORDS, self._flags)) + final.update(self._schema_digest) final.update(_U64.pack(self._rows)) _feed_entries(self._entries, final) return VERSION_BYTES + final.digest() @@ -651,18 +657,18 @@ def hash_table(table: pa.Table, **options: bool) -> bytes: def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct_fields: bool = False) -> bytes: - """Section 4: the array is the node at path "" (nullable iff it has a null). + """Section 4: the array is the node at path "", always nullable. - Nulls are counted on the resolved values: a valid dictionary key that points at a - null dictionary value is a null (pyarrow's DictionaryArray.null_count counts keys). + Its validity is always written: the logical validity after decoding dictionaries (a + valid dictionary key that points at a null dictionary value is a null). """ flags = flags_of(ordered_columns, ordered_struct_fields) - root = pa.field("", array.type, nullable=_resolve(array).null_count > 0) + root = pa.field("", array.type, nullable=True) nodes = _walk([("", root)]) _check_data_supported(nodes) entries = _new_entries(nodes) _visit(root, array, "", None, entries) - final = hashlib.sha256(header(flags)) + final = hashlib.sha256(header(KIND_ARRAY, flags)) final.update(type_json(array.type, flags).encode()) final.update(_U64.pack(len(array))) _feed_entries(entries, final) diff --git a/tests/test_format2.py b/tests/test_format2.py index b88a97d..e703eb2 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -19,8 +19,26 @@ V = b"\x00\x00\x02" -def header(flags: int) -> bytes: - return bytes.fromhex("00 73 74 61 72 66 69 78 00 00 02".replace(" ", "")) + bytes([flags]) +def header(flags: int, kind: bytes) -> bytes: + """Section 1: 0x00 || "starfix" || 00 00 02 || kind || flags (13 bytes).""" + return bytes.fromhex("00 73 74 61 72 66 69 78 00 00 02".replace(" ", "")) + kind + bytes([flags]) + + +def hs(flags: int = 0) -> bytes: # schema digest header + return header(flags, b"S") + + +def hr(flags: int = 0) -> bytes: # record batch / stream final digest header + return header(flags, b"R") + + +def ha(flags: int = 0) -> bytes: # hash_array header + return header(flags, b"A") + + +def all_valid(n: int) -> bytes: + """Validity entry of n valid elements (the hash_array root is always nullable).""" + return u64(n) + ((1 << n) - 1).to_bytes((n + 7) // 8, "little") def sha(*parts: bytes) -> bytes: @@ -42,8 +60,9 @@ def i32(*vals: int) -> bytes: def test_header_bytes() -> None: - assert f2.header(0x03) == header(0x03) - assert len(f2.header(0)) == 12 + for kind in (b"S", b"R", b"A"): + assert f2.header(kind, 0x03) == header(0x03, kind) + assert len(f2.header(kind, 0)) == 13 assert f2.VERSION_BYTES == V @@ -58,30 +77,27 @@ def test_map_example() -> None: b'"value":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":false},' b'{"data_type":"Int32","name":"z","nullable":false}]},"nullable":true}}},"nullable":true}}' ) - expected = "0000021c34e18fc2130624f527774ee7992b42234963037109d81715bbacd180adcf1f" - assert (V + sha(header(0), json_)).hex() == expected - assert f2.hash_schema(schema).hex() == expected + assert f2.hash_schema(schema) == V + sha(hs(), json_) def test_fixed_size_list_example() -> None: schema = pa.schema([pa.field("f", pa.list_(pa.field("item", pa.int32(), nullable=True), 2), nullable=False)]) - expected = "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc" + json_ = b'{"f":{"data_type":{"FixedSizeList":[{"data_type":"Int32","nullable":true},2]},"nullable":false}}' - assert (V + sha(header(0), json_)).hex() == expected - assert f2.hash_schema(schema).hex() == expected + assert f2.hash_schema(schema) == V + sha(hs(), json_) def test_hash_array_non_ascii_example() -> None: arr = pa.StructArray.from_arrays([pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32(), nullable=False)]) - expected = "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728" - assert f2.hash_array(arr).hex() == expected + type_json = '{"Struct":[{"data_type":"Int32","name":"é","nullable":false}]}'.encode() + assert f2.hash_array(arr) == V + sha(ha(), type_json, u64(1), all_valid(1), sha(i32(1))) def test_json_text_rules() -> None: schema = pa.schema([pa.field("a\nb\x1b/\x7f\"\\é", pa.int8(), nullable=False)]) name = '"a\\nb\\u001b/\x7f\\"\\\\é"'.encode() json_ = b"{" + name + b':{"data_type":"Int8","nullable":false}}' - assert f2.hash_schema(schema) == V + sha(header(0), json_) + assert f2.hash_schema(schema) == V + sha(hs(), json_) @pytest.mark.parametrize( @@ -113,7 +129,7 @@ def test_json_text_rules() -> None: def test_primitive_and_canonical_forms(factory, form) -> None: schema = pa.schema([pa.field("c", factory(), nullable=True)]) json_ = ('{"c":{"data_type":' + form + ',"nullable":true}}').encode() - assert f2.hash_schema(schema) == V + sha(header(0), json_) + assert f2.hash_schema(schema) == V + sha(hs(), json_) # ── Section 9: worked examples ───────────────────────────────────────── @@ -123,16 +139,16 @@ def test_example_1_record_batch() -> None: schema = pa.schema([pa.field("a", pa.int32(), nullable=False), pa.field("b", pa.large_utf8(), nullable=True)]) batch = pa.record_batch([pa.array([1, 2], pa.int32()), pa.array(["x", None], pa.large_utf8())], schema=schema) schema_digest = sha( - header(0), b'{"a":{"data_type":"Int32","nullable":false},"b":{"data_type":"LargeUtf8","nullable":true}}' + hs(), b'{"a":{"data_type":"Int32","nullable":false},"b":{"data_type":"LargeUtf8","nullable":true}}' ) final = sha( + hr(), schema_digest, u64(2), sha(i32(1, 2)), u64(2) + b"\x01", sha(u64(1) + b"x"), ) - assert (V + final).hex() == "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" assert f2.hash_record_batch(batch) == V + final @@ -141,6 +157,7 @@ def test_example_2_list() -> None: schema = pa.schema([pa.field("c", t, nullable=True)]) batch = pa.record_batch([pa.array([[1, None], None, []], t)], schema=schema) final = sha( + hr(), f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x05", @@ -160,6 +177,7 @@ def test_example_3_nullable_struct() -> None: schema = pa.schema([pa.field("s", s.type, nullable=True)]) batch = pa.record_batch([s], schema=schema) final = sha( + hr(), f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x06", @@ -175,6 +193,7 @@ def test_example_4_list_of_nullable_struct() -> None: schema = pa.schema([pa.field("l", t, nullable=False)]) batch = pa.record_batch([pa.array([[None, {"a": 4}]], t)], schema=schema) final = sha( + hr(), f2.hash_schema(schema)[3:], u64(1), sha(u64(2)), # "l": lengths @@ -196,15 +215,14 @@ def test_example_4_as_printed_with_non_nullable_child() -> None: pa.StructArray.from_arrays([pa.array([0, 4], pa.int32())], fields=list(st), mask=pa.array([True, False])), ).cast(t) batch = pa.record_batch([arr], schema=schema) - final = sha(f2.hash_schema(schema)[3:], u64(1), sha(u64(2)), u64(2) + b"\x02", sha(i32(4))) + final = sha(hr(), f2.hash_schema(schema)[3:], u64(1), sha(u64(2)), u64(2) + b"\x02", sha(i32(4))) assert f2.hash_record_batch(batch) == V + final def test_example_5_hash_array() -> None: - expected = V + sha(header(0), b'"Int32"', u64(3), sha(i32(1, 2, 3))) - assert expected.hex() == "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" + expected = V + sha(ha(), b'"Int32"', u64(3), all_valid(3), sha(i32(1, 2, 3))) assert f2.hash_array(pa.array([1, 2, 3], pa.int32())) == expected - boolean = V + sha(header(0), b'"Boolean"', u64(3), u64(3) + b"\x05", sha(b"\x01\x00")) + boolean = V + sha(ha(), b'"Boolean"', u64(3), u64(3) + b"\x05", sha(b"\x01\x00")) assert f2.hash_array(pa.array([True, None, False])) == boolean @@ -214,13 +232,13 @@ def test_example_6_options() -> None: b'[{"data_type":"Int32","name":"b","nullable":false},' b'{"data_type":"LargeUtf8","name":"a","nullable":true}]' ) - assert f2.hash_schema(schema, ordered_columns=True) == V + sha(header(0x01), json_) + assert f2.hash_schema(schema, ordered_columns=True) == V + sha(hs(0x01), json_) def test_example_7_zero_columns() -> None: batch = pa.RecordBatch.from_struct_array(pa.array([{}, {}, {}], pa.struct([]))) assert batch.num_columns == 0 and batch.num_rows == 3 - assert f2.hash_record_batch(batch) == V + sha(sha(header(0), b"{}"), u64(3)) + assert f2.hash_record_batch(batch) == V + sha(hr(), sha(hs(), b"{}"), u64(3)) # ── Sections 2.3, 2.4: metadata and names not hashed ─────────────────── @@ -234,7 +252,7 @@ def test_phase2_map_value_metadata_path() -> None: b'"value":{"data_type":"Int32","nullable":true}}},"nullable":true}}' ) assert f2.hash_schema(schema, include_metadata=True) == V + sha( - header(0), phase1, b'{"fields":{"m//value":{"unit":"kg"}}}' + hs(), phase1, b'{"fields":{"m//value":{"unit":"kg"}}}' ) @@ -249,7 +267,7 @@ def test_phase2_paths_and_schema_metadata() -> None: b'{"fields":{"d/x":{"k":"1"},"l/":{"e":"2"},"s":{"c":"3"},"s/x":{"k":"1"}},"schema":{"a":"0","z":"9"}}' ) phase1 = f2.phase1_json(schema, 0).encode() - assert f2.hash_schema(schema, include_metadata=True) == V + sha(header(0), phase1, expected_phase2) + assert f2.hash_schema(schema, include_metadata=True) == V + sha(hs(), phase1, expected_phase2) def test_include_metadata_without_metadata_is_invariant() -> None: @@ -283,7 +301,7 @@ def test_non_nullable_child_of_null_struct_contributes_nothing() -> None: ) schema = pa.schema([pa.field("s", s.type, nullable=True)]) batch = pa.record_batch([s], schema=schema) - final = sha(f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x05", sha(i32(1, 3))) + final = sha(hr(), f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x05", sha(i32(1, 3))) assert f2.hash_record_batch(batch) == V + final @@ -297,7 +315,7 @@ def batch(n): def test_entry_order_is_bytewise_node_path_order() -> None: schema = pa.schema([pa.field("b", pa.int8(), nullable=False), pa.field("a", pa.int8(), nullable=False)]) batch = pa.record_batch([pa.array([1], pa.int8()), pa.array([2], pa.int8())], schema=schema) - final = sha(f2.hash_schema(schema)[3:], u64(1), sha(b"\x02"), sha(b"\x01")) + final = sha(hr(), f2.hash_schema(schema)[3:], u64(1), sha(b"\x02"), sha(b"\x01")) assert f2.hash_record_batch(batch) == V + final @@ -315,7 +333,7 @@ def test_leaf_value_bytes() -> None: for arr, value_bytes in cases: t = arr.type.value_type if pa.types.is_dictionary(arr.type) else arr.type type_json = f2.type_json(t, 0).encode() - expected = V + sha(header(0), type_json, u64(len(arr)), sha(value_bytes)) + expected = V + sha(ha(), type_json, u64(len(arr)), all_valid(len(arr)), sha(value_bytes)) assert f2.hash_array(arr) == expected, arr.type @@ -323,15 +341,17 @@ def test_hash_array_root_struct_nullable_and_list() -> None: s = pa.StructArray.from_arrays([pa.array([1, 2], pa.int8())], fields=[pa.field("x", pa.int8(), nullable=False)], mask=pa.array([False, True])) type_json = b'{"Struct":[{"data_type":"Int8","name":"x","nullable":false}]}' - assert f2.hash_array(s) == V + sha(header(0), type_json, u64(2), u64(2) + b"\x01", sha(b"\x01")) + assert f2.hash_array(s) == V + sha(ha(), type_json, u64(2), u64(2) + b"\x01", sha(b"\x01")) lst = pa.array([[1, 2], [3]], pa.list_(pa.field("item", pa.int8(), nullable=False))) type_json = b'{"LargeList":{"data_type":"Int8","nullable":false}}' - assert f2.hash_array(lst) == V + sha(header(0), type_json, u64(2), sha(u64(2) + u64(1)), sha(b"\x01\x02\x03")) + assert f2.hash_array(lst) == V + sha( + ha(), type_json, u64(2), all_valid(2), sha(u64(2) + u64(1)), sha(b"\x01\x02\x03") + ) def test_hash_array_ordered_columns_changes_only_the_header() -> None: arr = pa.array([1], pa.int8()) - assert f2.hash_array(arr, ordered_columns=True) == V + sha(header(0x01), b'"Int8"', u64(1), sha(b"\x01")) + assert f2.hash_array(arr, ordered_columns=True) == V + sha(ha(0x01), b'"Int8"', u64(1), all_valid(1), sha(b"\x01")) # ── Invariants (Section 11) ───────────────────────────────────────────── @@ -424,7 +444,7 @@ def test_struct_child_paths_always_use_a_slash() -> None: # hash_array root struct child "" is the node "/" (distinct from the root ""). arr = pa.StructArray.from_arrays([pa.array([1], pa.int64())], fields=[pa.field("", pa.int64(), nullable=False)]) type_json = b'{"Struct":[{"data_type":"Int64","name":"","nullable":false}]}' - assert f2.hash_array(arr) == V + sha(header(0), type_json, u64(1), sha(struct.pack(" N s = pa.StructArray.from_arrays([pa.array([1, 2], pa.int8())], fields=[pa.field("x", pa.int8(), nullable=True)], mask=pa.array([False, True])) type_json = b'{"Struct":[{"data_type":"Int8","name":"x","nullable":true}]}' - expected = V + sha(header(0), type_json, u64(2), u64(2) + b"\x01", u64(2) + b"\x01", sha(b"\x01")) + expected = V + sha(ha(), type_json, u64(2), u64(2) + b"\x01", u64(2) + b"\x01", sha(b"\x01")) assert f2.hash_array(s) == expected @@ -525,7 +545,7 @@ def test_registered_python_extension_type(point_type) -> None: schema = pa.schema([pa.field("p", point_type("km"), metadata={"other": "x"})]) phase1 = b'{"p":{"data_type":{"Struct":[{"data_type":"Float64","name":"x","nullable":true}]},"nullable":true}}' phase2 = b'{"fields":{"p":{"ARROW:extension:metadata":"{\\"unit\\":\\"km\\"}","ARROW:extension:name":"starfix.test.point","other":"x"}}}' - assert f2.hash_schema(schema, include_metadata=True) == V + sha(header(0), phase1, phase2) + assert f2.hash_schema(schema, include_metadata=True) == V + sha(hs(), phase1, phase2) # Without include_metadata an extension type hashes exactly like its storage type. assert f2.hash_schema(schema) == f2.hash_schema(pa.schema([pa.field("p", storage)])) # Data: the storage array is hashed. @@ -551,7 +571,7 @@ def test_unregistered_extension_keys_hashed_verbatim() -> None: "ARROW:extension:name": "other.thing", "ARROW:extension:metadata": "v1"})]) seen, _ = _ipc_roundtrip(schema) phase2 = b'{"fields":{"q":{"ARROW:extension:metadata":"v1","ARROW:extension:name":"other.thing"}}}' - assert f2.hash_schema(seen, include_metadata=True) == V + sha(header(0), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) + assert f2.hash_schema(seen, include_metadata=True) == V + sha(hs(), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) def test_extension_name_without_metadata_key_is_hashed_as_empty_metadata() -> None: @@ -560,7 +580,7 @@ def test_extension_name_without_metadata_key_is_hashed_as_empty_metadata() -> No empty = pa.schema([pa.field("q", pa.int32(), metadata={ "ARROW:extension:name": "other.thing", "ARROW:extension:metadata": ""})]) phase2 = b'{"fields":{"q":{"ARROW:extension:metadata":"","ARROW:extension:name":"other.thing"}}}' - expected = V + sha(header(0), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) + expected = V + sha(hs(), b'{"q":{"data_type":"Int32","nullable":true}}', phase2) assert f2.hash_schema(name_only, include_metadata=True) == expected assert f2.hash_schema(empty, include_metadata=True) == expected seen, _ = _ipc_roundtrip(name_only) @@ -584,7 +604,7 @@ def test_hash_array_dictionary_nullability_counts_resolved_nulls() -> None: """A valid key pointing at a null dictionary value is a null element.""" arr = pa.DictionaryArray.from_arrays(pa.array([0, 1], pa.int8()), pa.array(["a", None])) assert arr.null_count == 0 # pyarrow counts index nulls only - expected = V + sha(header(0), b'"LargeUtf8"', u64(2), u64(2) + b"\x01", sha(u64(1) + b"a")) + expected = V + sha(ha(), b'"LargeUtf8"', u64(2), u64(2) + b"\x01", sha(u64(1) + b"a")) assert f2.hash_array(arr) == expected @@ -644,7 +664,7 @@ def test_child_null_masked_by_null_parent_is_accepted() -> None: st = pa.struct([pa.field("x", pa.int32(), nullable=False)]) s = pa.StructArray.from_arrays([pa.array([1, None], pa.int32())], fields=list(st), mask=pa.array([False, True])) schema = pa.schema([pa.field("s", st, nullable=True)]) - final = sha(f2.hash_schema(schema)[3:], u64(2), u64(2) + b"\x01", sha(i32(1))) + final = sha(hr(), f2.hash_schema(schema)[3:], u64(2), u64(2) + b"\x01", sha(i32(1))) assert f2.hash_record_batch(pa.record_batch([s], schema=schema)) == V + final @@ -676,7 +696,7 @@ def test_binary_values_hashed_with_a_byte_budget(monkeypatch) -> None: arr = pa.array(values, pa.binary()) expected = b"".join(u64(len(v)) + v for v in values if v is not None) valid = u64(6) + bytes([0b110111]) - assert f2.hash_array(arr) == V + sha(header(0), b'"LargeBinary"', u64(6), valid, sha(expected)) + assert f2.hash_array(arr) == V + sha(ha(), b'"LargeBinary"', u64(6), valid, sha(expected)) def test_rejected_batch_restores_partial_validity_bytes() -> None: @@ -711,14 +731,14 @@ def test_nullable_leaves_hashed_in_bounded_chunks(budget, monkeypatch) -> None: valid = [v is not None for v in arr.to_pylist()] bits = sum(1 << i for i, ok in enumerate(valid) if ok) validity = u64(len(arr)) + bits.to_bytes((len(arr) + 7) // 8, "little") - expected = V + sha(header(0), f2.type_json(arr.type, 0).encode(), u64(len(arr)), validity, sha(value_bytes)) + expected = V + sha(ha(), f2.type_json(arr.type, 0).encode(), u64(len(arr)), validity, sha(value_bytes)) assert f2.hash_array(arr) == expected, (arr.type, budget) def test_zero_width_fixed_size_binary() -> None: """FixedSizeBinary(0) values contribute no bytes; nulls are still recorded.""" arr = pa.array([b"", None, b""], type=pa.binary(0)) - expected = V + sha(header(0), b'{"FixedSizeBinary":0}', u64(3), u64(3) + b"\x05", sha(b"")) + expected = V + sha(ha(), b'{"FixedSizeBinary":0}', u64(3), u64(3) + b"\x05", sha(b"")) assert f2.hash_array(arr) == expected st = pa.StructArray.from_arrays([pa.array([b"", b""], pa.binary(0))], fields=[pa.field("z", pa.binary(0), nullable=False)], mask=pa.array([False, True])) @@ -765,3 +785,24 @@ def test_list_non_nullable_items_with_hidden_child_nulls() -> None: visible = pa.ListArray.from_arrays(pa.array([0, 2], pa.int32()), pa.array([1, None], pa.int32())).cast(t) with pytest.raises(ValueError, match="Non-nullable"): f2.hash_array(visible) + + +def test_nested_dictionaries_resolve_recursively() -> None: + """Dictionary> hashes as plain Utf8 (schema, batch, array).""" + inner = pa.array(["a", "b", "a"]).dictionary_encode() + nested = pa.DictionaryArray.from_arrays(pa.array([0, 1, 2, 0, None], pa.int8()), inner) + plain = pa.array(["a", "b", "a", "a", None]) + assert f2.hash_array(nested) == f2.hash_array(plain) + assert f2.hash_record_batch(pa.record_batch([nested], names=["c"])) == f2.hash_record_batch( + pa.record_batch([plain], names=["c"]) + ) + assert f2.hash_schema(pa.schema([pa.field("c", nested.type)])) == f2.hash_schema(pa.schema([pa.field("c", pa.utf8())])) + + +def test_zero_width_fixed_size_binary_row_count_matters() -> None: + one = pa.array([b""], pa.binary(0)) + five = pa.array([b""] * 5, pa.binary(0)) + assert f2.hash_array(one) != f2.hash_array(five) + assert f2.hash_record_batch(pa.record_batch([one], names=["z"])) != f2.hash_record_batch( + pa.record_batch([five], names=["z"]) + ) From 7745d2c0402faf2aac98969ef34df20dd0438ba8 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:00:01 -0800 Subject: [PATCH 37/49] fix(format2): hash leaf dictionaries through their indices (bounded memory) (ITL-898) Copilot review: dictionary_decode() materialized the whole logical payload (10,000 indices to one 1 MiB value = 10 GiB). Leaf dictionaries now stay encoded: validity is index validity AND the validity of the value it points to (take over booleans), strings/binary are fed from the dictionary buffers through the indices, fixed-width and Boolean values are gathered in byte-bounded chunks. Nested dictionaries resolve inside the dictionary only; dictionaries of struct/list values are decoded (their children are visited). Hash-neutral: 1602/1602 identical against the previous module (400 seeded random batches with string and numeric dictionaries, plus dictionaries in lists, nested, of structs, with null values, sliced). Regression test on a proxy of the Arrow pool: 80 references to a 1 MiB value peak far below the decoded size (the old code peaked at 140 MB). Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 141 ++++++++++++++++++++++++++-------- tests/test_format2_scaling.py | 19 +++++ 2 files changed, 128 insertions(+), 32 deletions(-) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 685a21f..48f010f 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -396,16 +396,38 @@ def feed(self, digest) -> None: def _resolve(arr: pa.Array) -> pa.Array: - """Extension arrays -> storage; dictionary arrays -> decoded values (repeatedly).""" + """Extension arrays -> storage, repeatedly. Dictionaries are hashed as their values: + + - a dictionary of leaf values stays encoded (its values are read through the indices + from the dictionary buffers, so the logical payload is never materialized); nested + dictionaries and extension values are resolved inside its dictionary only; + - a dictionary of struct or list values is decoded (its children are traversed). + """ while True: if isinstance(arr, pa.ExtensionArray): arr = arr.storage elif pa.types.is_dictionary(arr.type): - arr = arr.dictionary_decode() + values = _resolve(arr.dictionary) + if pa.types.is_dictionary(values.type): # resolved values are plain or decoded + values = values.dictionary_decode() + t = values.type + if pa.types.is_struct(t) or _is_list(t) or pa.types.is_fixed_size_list(t) or pa.types.is_map(t): + arr = values.take(arr.indices) + else: + return arr if values is arr.dictionary else pa.DictionaryArray.from_arrays(arr.indices, values) else: return arr +def _logical_validity(arr: pa.Array) -> pa.Array | None: + """Per-element validity (None: all valid). A dictionary element is valid iff its index + is valid and the dictionary value it points to is valid.""" + if pa.types.is_dictionary(arr.type): + valid = pc.fill_null(pc.take(arr.dictionary.is_valid(), arr.indices), False) + return None if pc.all(valid).as_py() is not False else valid + return arr.is_valid() if arr.null_count else None + + def _and(a: pa.Array | None, b: pa.Array | None) -> pa.Array | None: if a is None: return b @@ -426,11 +448,88 @@ def _value_width(t: pa.DataType) -> int | None: return None +def _is_var_length(t: pa.DataType) -> bool: + return pa.types.is_string(t) or pa.types.is_large_string(t) or pa.types.is_binary(t) or pa.types.is_large_binary(t) + + +def _var_length_buffers(arr: pa.Array) -> tuple[memoryview, memoryview]: + """The whole offsets buffer (as integers) and data buffer of a string/binary array.""" + large = pa.types.is_large_string(arr.type) or pa.types.is_large_binary(arr.type) + size = 8 if large else 4 + bufs = arr.buffers() + raw = memoryview(bufs[1]) + offsets = raw[: len(raw) // size * size].cast("q" if large else "i") + data = memoryview(bufs[2]) if bufs[2] is not None else memoryview(b"") + return offsets, data + + +class _VarLengthFeeder: + """Feeds `u64 length || bytes` values to a digest in updates of about _BYTE_BUDGET bytes; + a value of at least that size is fed straight from its buffer (no copy).""" + + __slots__ = ("digest", "parts", "pending") + + def __init__(self, digest) -> None: + self.digest, self.parts, self.pending = digest, [], 0 + + def flush(self) -> None: + if self.parts: + self.digest.update(b"".join(self.parts)) + self.parts, self.pending = [], 0 + + +def _feed_var_length(feeder: "_VarLengthFeeder", data: memoryview, pairs) -> None: + pack = _U64.pack + for a, b in pairs: + size = b - a + if size >= _BYTE_BUDGET: + feeder.parts.append(pack(size)) + feeder.flush() + feeder.digest.update(data[a:b]) + continue + feeder.parts.append(pack(size)) + feeder.parts.append(data[a:b]) + feeder.pending += 8 + size + if feeder.pending >= _BYTE_BUDGET: + feeder.flush() + + +def _hash_dictionary_values(arr: pa.DictionaryArray, bits: pa.Array | None, digest) -> None: + """Leaf values of a dictionary array, read through its indices (never decoded whole).""" + values, indices, n = arr.dictionary, arr.indices, len(arr) + t = values.type + if _is_var_length(t): + offsets, data = _var_length_buffers(values) + base = values.offset + feeder = _VarLengthFeeder(digest) + for start in range(0, n, _CHUNK): + chunk = indices.slice(start, _CHUNK) + if bits is not None: + chunk = chunk.filter(bits.slice(start, _CHUNK)) + ids = chunk.to_pylist() + _feed_var_length(feeder, data, ((offsets[base + j], offsets[base + j + 1]) for j in ids)) + feeder.flush() + return + width = _value_width(t) + if width == 0: + return + rows = _CHUNK if width is None else max(1, _BYTE_BUDGET // width) + for start in range(0, n, rows): + chunk = indices.slice(start, rows) + if bits is not None: + chunk = chunk.filter(bits.slice(start, rows)) + if len(chunk): + _hash_values(values.take(chunk), None, digest) + + def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: """Section 3.2 leaf value bytes of the elements of `arr` whose bit in `bits` is 1. Works in bounded chunks: the valid values are never materialized as a whole. """ + if pa.types.is_dictionary(arr.type): + _hash_dictionary_values(arr, bits, digest) + return t = arr.type n = len(arr) if pa.types.is_boolean(t): @@ -456,43 +555,21 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: raw = memoryview(chunk.buffers()[1]) digest.update(raw[chunk.offset * width:(chunk.offset + len(chunk)) * width]) return - if pa.types.is_string(t) or pa.types.is_large_string(t) or pa.types.is_binary(t) or pa.types.is_large_binary(t): + if _is_var_length(t): if n == 0: return - large = pa.types.is_large_string(t) or pa.types.is_large_binary(t) - size = 8 if large else 4 - bufs = arr.buffers() - offsets = memoryview(bufs[1])[arr.offset * size:(arr.offset + n + 1) * size].cast("q" if large else "i") - data = memoryview(bufs[2]) if bufs[2] is not None else memoryview(b"") - # Nulls are skipped while reading the original buffers. Small values are joined - # into updates of about _BYTE_BUDGET bytes; a value of at least that size is fed - # straight from the data buffer (no copy). - parts: list = [] - pending = 0 - pack = _U64.pack + offsets, data = _var_length_buffers(arr) + feeder = _VarLengthFeeder(digest) + # Nulls are skipped while reading the original buffers (no copy of the payload). for chunk_start in range(0, n, _CHUNK): chunk_end = min(chunk_start + _CHUNK, n) - offs = offsets[chunk_start:chunk_end + 1].tolist() + offs = offsets[arr.offset + chunk_start:arr.offset + chunk_end + 1].tolist() pairs = zip(offs, offs[1:], strict=False) # consecutive offsets if bits is not None: flags = bits.slice(chunk_start, chunk_end - chunk_start).to_pylist() pairs = (pair for pair, ok in zip(pairs, flags, strict=True) if ok) - for a, b in pairs: - size_i = b - a - if size_i >= _BYTE_BUDGET: - parts.append(pack(size_i)) - digest.update(b"".join(parts)) - digest.update(data[a:b]) - parts, pending = [], 0 - continue - parts.append(pack(size_i)) - parts.append(data[a:b]) - pending += 8 + size_i - if pending >= _BYTE_BUDGET: - digest.update(b"".join(parts)) - parts, pending = [], 0 - if parts: - digest.update(b"".join(parts)) + _feed_var_length(feeder, data, pairs) + feeder.flush() return raise ValueError(f"Hashing data of type {t} is not supported") # checked earlier (Section 7) @@ -515,7 +592,7 @@ def _visit( """ arr = _resolve(arr) entry = entries[path] - own = arr.is_valid() if arr.null_count else None + own = _logical_validity(arr) if own is not None and not field.nullable: # Section 7 item 4: a null in a non-nullable node not masked by an enclosing struct # null (elements outside `select` are not elements and are ignored). diff --git a/tests/test_format2_scaling.py b/tests/test_format2_scaling.py index 6724776..6c41068 100644 --- a/tests/test_format2_scaling.py +++ b/tests/test_format2_scaling.py @@ -88,3 +88,22 @@ def test_nullable_list_of_binary_does_not_copy_the_payload() -> None: finally: pa.set_memory_pool(default) assert pool.max_memory() < payload // 4, f"Arrow peak {pool.max_memory()} bytes for a {payload}-byte payload" + + +def test_dictionary_leaves_are_not_decoded_as_a_whole() -> None: + """Few large dictionary values referenced many times: hashed from the dictionary buffers.""" + big = pa.array([b"x" * (1 << 20), b"y" * 10, None], pa.large_binary()) # one 1 MiB value + indices = pa.array([0, 1, 0, None, 2] * 40, pa.int32()) # 80 references to the 1 MiB value + arr = pa.DictionaryArray.from_arrays(indices, big) + decoded_size = 80 * (1 << 20) + f2.hash_array(arr.slice(0, 2)) # warm up + + default = pa.default_memory_pool() + pool = pa.proxy_memory_pool(default) + pa.set_memory_pool(pool) + try: + f2.hash_array(arr) + f2.hash_record_batch(pa.record_batch([arr], names=["d"])) + finally: + pa.set_memory_pool(default) + assert pool.max_memory() < decoded_size // 20, f"Arrow peak {pool.max_memory()} bytes (decoded: {decoded_size})" From 8488daece68eb073188fd3ba203e1e0ed21103a1 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:06:26 -0800 Subject: [PATCH 38/49] fix: independent review of PR #9, behaviour items 2, 3, 9, 12, 14 (ITL-898) 2 an Arrow-valid empty list array without an offsets buffer segfaulted: empty lists no longer touch offsets or lengths (subprocess test, List and LargeList, top level and in a struct) 3 with include_metadata, duplicate metadata keys (field, struct child, schema) are rejected with ValueError naming the node and key; metadata is read through the Arrow C data interface, which keeps duplicates. Explicit ARROW:extension:* keys conflicting with a registered extension type are rejected; agreeing ones are accepted 9 wrong container types raise TypeError naming the expected type (hash_record_batch(Table), hash_table(RecordBatch), update(Table), hash_schema / ArrowDigester with a non-schema); hash_array accepts a ChunkedArray, hashed chunk by chunk, equal to the combined array 12 legacy: the performance-only line keeps 0.4.0's AttributeError for a missing values buffer (differential now 2795 results, 4 raising the same exception, 0 differ); r2 test docstring states the input helpers 14 _Bits appends replace the partial last byte in one slice assignment, and restore truncates and resets the byte at its saved index Co-Authored-By: Claude Opus 5.5 --- scripts/legacy_differential.py | 2 + src/starfix/_format2.py | 87 ++++++++++++++++----- src/starfix/legacy/v0_4.py | 10 ++- tests/test_format2.py | 89 ++++++++++++++++++++++ tests/test_legacy_v0_4_frozen.py | 2 +- tests/test_legacy_v0_4_golden_parity_r2.py | 6 +- 6 files changed, 170 insertions(+), 26 deletions(-) diff --git a/scripts/legacy_differential.py b/scripts/legacy_differential.py index dece655..971c3ac 100644 --- a/scripts/legacy_differential.py +++ b/scripts/legacy_differential.py @@ -144,6 +144,8 @@ def unchecked_stream(D): return d.finalize() yield "stream_without_batch_check", unchecked_stream + # A zero-length fixed-width array with no values buffer: 0.4.0 raises AttributeError. + yield "fixed_width_without_values_buffer", lambda D: D.hash_array(pa.Array.from_buffers(pa.int32(), 0, [None, None])) def _cases(seeds: int): diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 48f010f..0c6b7bb 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -223,12 +223,13 @@ def _extension_metadata(t: pa.DataType) -> dict[str, str]: return {"ARROW:extension:name": t.extension_name, "ARROW:extension:metadata": serialized.decode("utf-8")} -def _exported_extension_metadata(t: pa.DataType) -> bytes: - """The serialized metadata pyarrow writes for an extension type (C data interface). +def _exported_metadata_pairs(obj) -> list[tuple[bytes, bytes]]: + """Key/value pairs of a Field's, Schema's or DataType's metadata as Arrow exports them. - Exporting a field to the Arrow C data interface (a fixed, documented ABI) carries the - ARROW:extension:name / ARROW:extension:metadata keys in ArrowSchema.metadata, encoded - as int32 count, then per pair int32 length + key bytes, int32 length + value bytes. + Read through the Arrow C data interface (ArrowSchema.metadata, a fixed, documented ABI: + int32 count, then per pair int32 length + key bytes, int32 length + value bytes). Unlike + pyarrow's ``metadata`` dict this keeps duplicate keys, and for a registered extension + type it carries the ARROW:extension:* keys pyarrow writes for the type. """ import ctypes @@ -247,9 +248,9 @@ class _ArrowSchema(ctypes.Structure): ("private_data", ctypes.c_void_p), ] c_schema = _ArrowSchema() - pa.field("x", t)._export_to_c(ctypes.addressof(c_schema)) + obj._export_to_c(ctypes.addressof(c_schema)) try: - pairs: dict[bytes, bytes] = {} + pairs: list[tuple[bytes, bytes]] = [] if c_schema.metadata: pos = c_schema.metadata @@ -267,19 +268,45 @@ def read_bytes(n: int) -> bytes: for _ in range(read_int32()): key = read_bytes(read_int32()) - pairs[key] = read_bytes(read_int32()) - return pairs.get(b"ARROW:extension:metadata", b"") + pairs.append((key, read_bytes(read_int32()))) + return pairs finally: if c_schema.release: c_schema.release(ctypes.addressof(c_schema)) -def _field_metadata(field: pa.Field) -> dict[str, str]: - meta = _decode(field.metadata) +def _exported_extension_metadata(t: pa.DataType) -> bytes: + """The serialized metadata pyarrow writes for a (natively registered) extension type.""" + return dict(_exported_metadata_pairs(pa.field("x", t))).get(b"ARROW:extension:metadata", b"") + + +def _unique_metadata(pairs: list[tuple[bytes, bytes]], where: str) -> dict[str, str]: + """Decode metadata pairs; Section 7: a duplicate key is ambiguous and rejected.""" + out: dict[str, str] = {} + for key, value in pairs: + k = key.decode("utf-8") + if k in out: + raise ValueError(f"Duplicate metadata key {k!r} on {where}: ambiguous, rejected with include_metadata") + out[k] = value.decode("utf-8") + return out + + +def _field_metadata(field: pa.Field, path: str) -> dict[str, str]: + """The field's metadata as stored (Section 2.3), duplicates rejected (Section 7).""" + explicit = _decode(field.metadata) # pyarrow's dict view (duplicates collapsed) t = field.type while pa.types.is_dictionary(t): # a dictionary of an extension type keeps its keys t = t.value_type - meta.update(_extension_metadata(t)) + derived = _extension_metadata(t) + for key, value in derived.items(): + if key in explicit and explicit[key] != value: + raise ValueError( + f"Field {path!r} carries {key}={explicit[key]!r}, conflicting with its extension type " + f"({value!r}): ambiguous, rejected with include_metadata" + ) + meta = _unique_metadata(_exported_metadata_pairs(field), f"field {path!r}") + for key, value in derived.items(): + meta.setdefault(key, value) # Section 2.3: an absent ARROW:extension:metadata is hashed as "" (absent == empty). if "ARROW:extension:name" in meta: meta.setdefault("ARROW:extension:metadata", "") @@ -290,13 +317,13 @@ def phase2_json(schema: pa.Schema) -> str | None: """Section 2.3: metadata keyed by node path; None when there is none.""" fields = {} for path, field in schema_nodes(schema): - meta = _field_metadata(field) + meta = _field_metadata(field, path) if meta: fields[path] = meta doc: dict[str, Any] = {} if fields: doc["fields"] = fields - schema_meta = _decode(schema.metadata) + schema_meta = _unique_metadata(_exported_metadata_pairs(schema), "the schema") if schema_meta: doc["schema"] = schema_meta return _json(doc) if doc else None @@ -343,8 +370,12 @@ def _append_int(self, value: int, n: int) -> None: return shift = self._len & 7 if shift: - value = (value << shift) | self._bytes.pop() - self._bytes += value.to_bytes((n + shift + 7) >> 3, "little") + # Replace the partial last byte and append in one slice assignment, so the + # buffer is never shorter than before (snapshot/restore relies on it). + value = (value << shift) | self._bytes[-1] + self._bytes[-1:] = value.to_bytes((n + shift + 7) >> 3, "little") + else: + self._bytes += value.to_bytes((n + 7) >> 3, "little") self._len += n def feed(self, digest) -> None: @@ -357,9 +388,9 @@ def snapshot(self) -> tuple[int, int, int | None]: def restore(self, state: tuple[int, int, int | None]) -> None: bit_len, byte_len, last = state - del self._bytes[byte_len:] + del self._bytes[byte_len:] # appends only grow the buffer or rewrite its last byte if last is not None: - self._bytes[-1] = last + self._bytes[byte_len - 1] = last self._len = bit_len @@ -619,6 +650,11 @@ def _visit( present = _and(bits, select) # elements that are visited and valid (None: all) if entry.kind == "list": + if len(arr) == 0: + # An empty list array may legally have no offsets buffer: touch neither the + # offsets nor the lengths; the element node still gets visited (no elements). + _visit(arr.type.value_field, arr.values.slice(0, 0), path + "/", None, entries) + return lengths = arr.value_lengths() if present is not None: lengths = lengths.filter(present) @@ -680,6 +716,7 @@ def __init__( ordered_columns: bool = False, ordered_struct_fields: bool = False, ) -> None: + _require(schema, pa.Schema, "ArrowDigester", "a pyarrow.Schema") self._flags = flags_of(ordered_columns, ordered_struct_fields) self._include_metadata = include_metadata self._schema_digest = schema_digest(schema, include_metadata, self._flags) @@ -690,6 +727,7 @@ def __init__( self._rows = 0 def update(self, batch: pa.RecordBatch) -> None: + _require(batch, pa.RecordBatch, "update", "a pyarrow.RecordBatch (use hash_table for a Table)") schema = batch.schema schema_nodes(schema) # Section 7 if schema_key(schema, self._include_metadata, self._flags) != self._key: @@ -715,18 +753,26 @@ def finalize(self) -> bytes: return VERSION_BYTES + final.digest() +def _require(obj, cls, entry_point: str, expected: str) -> None: + if not isinstance(obj, cls): + raise TypeError(f"{entry_point} expects {expected}, got {type(obj).__name__}") + + def hash_schema(schema: pa.Schema, *, include_metadata: bool = False, ordered_columns: bool = False, ordered_struct_fields: bool = False) -> bytes: + _require(schema, pa.Schema, "hash_schema", "a pyarrow.Schema") return VERSION_BYTES + schema_digest(schema, include_metadata, flags_of(ordered_columns, ordered_struct_fields)) def hash_record_batch(batch: pa.RecordBatch, **options: bool) -> bytes: + _require(batch, pa.RecordBatch, "hash_record_batch", "a pyarrow.RecordBatch (use hash_table for a Table)") d = Digester(batch.schema, **options) d.update(batch) return d.finalize() def hash_table(table: pa.Table, **options: bool) -> bytes: + _require(table, pa.Table, "hash_table", "a pyarrow.Table (use hash_record_batch for a RecordBatch)") d = Digester(table.schema, **options) for batch in table.to_batches(): d.update(batch) @@ -739,12 +785,15 @@ def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct Its validity is always written: the logical validity after decoding dictionaries (a valid dictionary key that points at a null dictionary value is a null). """ + _require(array, (pa.Array, pa.ChunkedArray), "hash_array", "a pyarrow.Array or pyarrow.ChunkedArray") flags = flags_of(ordered_columns, ordered_struct_fields) root = pa.field("", array.type, nullable=True) nodes = _walk([("", root)]) _check_data_supported(nodes) entries = _new_entries(nodes) - _visit(root, array, "", None, entries) + # A ChunkedArray hashes like its chunks combined: entries are streams (Section 3.3). + for chunk in (array.chunks if isinstance(array, pa.ChunkedArray) else [array]): + _visit(root, chunk, "", None, entries) final = hashlib.sha256(header(KIND_ARRAY, flags)) final.update(type_json(array.type, flags).encode()) final.update(_U64.pack(len(array))) diff --git a/src/starfix/legacy/v0_4.py b/src/starfix/legacy/v0_4.py index b673b3e..e0df959 100644 --- a/src/starfix/legacy/v0_4.py +++ b/src/starfix/legacy/v0_4.py @@ -4,9 +4,11 @@ # This file is starfix-python v0.4.0's src/starfix/arrow_digester.py (tag v0.4.0, commit # d2ed97e), verbatim below this header EXCEPT ONE performance-only line, marked # "LEGACY PATCH": in _hash_fixed_size_data, `raw = data_buf.to_pybytes()` became -# `raw = memoryview(data_buf)`, which removes the quadratic cost of list columns (ITL-908) -# and changes no hash (proven by the restored 0.4.0 tests and by the differential test -# against the released starfix==0.4.0). It exists ONLY to read or match data hashed by +# `raw = memoryview(data_buf)` (still `data_buf.to_pybytes()` when there is no buffer, so a +# missing buffer raises the same AttributeError as 0.4.0). It removes the quadratic cost of +# list columns (ITL-908) and changes no hash or exception (proven by the restored 0.4.0 +# tests and by the differential test against the released starfix==0.4.0). It exists ONLY +# to read or match data hashed by # starfix-python 0.4.x; never hash new data with it (use starfix.ArrowDigester, format 2). # Its known defects (collisions, batch-split dependence, differences from Rust 0.4) are # kept on purpose and listed in the README section "Legacy 0.4 mode". @@ -675,7 +677,7 @@ def _hash_fixed_size_data(arr, data_digest, element_size: int, effective_nulls) data_buf = bufs[1] offset = arr.offset - raw = memoryview(data_buf) # LEGACY PATCH (performance only, see header) + raw = data_buf.to_pybytes() if data_buf is None else memoryview(data_buf) # LEGACY PATCH (see header) start = offset * element_size if effective_nulls is None: diff --git a/tests/test_format2.py b/tests/test_format2.py index e703eb2..77c5e97 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -806,3 +806,92 @@ def test_zero_width_fixed_size_binary_row_count_matters() -> None: assert f2.hash_record_batch(pa.record_batch([one], names=["z"])) != f2.hash_record_batch( pa.record_batch([five], names=["z"]) ) + + +# ── Independent review of PR #9 (items 2, 3, 9, 14) ───────────────────── + + +def test_empty_list_without_offsets_buffer_does_not_crash() -> None: + """Arrow allows an empty list array with no offsets buffer (it used to segfault).""" + import subprocess + import sys + + code = """ +import pyarrow as pa +from starfix import _format2 as f2 +for t in (pa.list_(pa.int32()), pa.large_list(pa.int32())): + arr = pa.Array.from_buffers(t, 0, [None, None], children=[pa.array([], pa.int32())]) + arr.validate(full=True) + assert f2.hash_array(arr) == f2.hash_array(pa.array([], t)) + s = pa.StructArray.from_arrays([arr], names=["l"]) + assert f2.hash_array(s) == f2.hash_array(pa.StructArray.from_arrays([pa.array([], t)], names=["l"])) +print("ok") +""" + result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True) + assert result.returncode == 0 and result.stdout.strip() == "ok", (result.returncode, result.stderr[-500:]) + + +@pytest.mark.parametrize("where", ["field", "schema", "struct_child"]) +def test_duplicate_metadata_keys_rejected_with_include_metadata(where) -> None: + dup = pa.KeyValueMetadata([(b"a", b"1"), (b"a", b"2")]) + if where == "field": + schema = pa.schema([pa.field("x", pa.int8(), metadata=dup)]) + elif where == "schema": + schema = pa.schema([pa.field("x", pa.int8())], metadata=dup) + else: + schema = pa.schema([pa.field("s", pa.struct([pa.field("c", pa.int8(), metadata=dup)]))]) + f2.hash_schema(schema) # metadata not hashed: accepted + with pytest.raises(ValueError, match="Duplicate metadata key 'a'"): + f2.hash_schema(schema, include_metadata=True) + with pytest.raises(ValueError, match="Duplicate metadata key"): + f2.Digester(schema, include_metadata=True) + + +def test_explicit_extension_keys_conflicting_with_the_type_rejected(point_type) -> None: + conflicting = pa.schema([pa.field("p", point_type("km"), metadata={"ARROW:extension:name": "other"})]) + with pytest.raises(ValueError, match="conflicting with its extension type"): + f2.hash_schema(conflicting, include_metadata=True) + agreeing = pa.schema([pa.field("p", point_type("km"), metadata={"ARROW:extension:name": "starfix.test.point"})]) + assert f2.hash_schema(agreeing, include_metadata=True) == f2.hash_schema( + pa.schema([pa.field("p", point_type("km"))]), include_metadata=True + ) + + +def test_wrong_container_types_raise_type_error() -> None: + batch = pa.record_batch([pa.array([1, 2])], names=["a"]) + table = pa.Table.from_batches([batch]) + with pytest.raises(TypeError, match="hash_record_batch expects a pyarrow.RecordBatch"): + f2.hash_record_batch(table) + with pytest.raises(TypeError, match="hash_table expects a pyarrow.Table"): + f2.hash_table(batch) + with pytest.raises(TypeError, match="update expects a pyarrow.RecordBatch"): + f2.Digester(batch.schema).update(table) + with pytest.raises(TypeError, match="hash_schema expects a pyarrow.Schema"): + f2.hash_schema(batch) + with pytest.raises(TypeError, match="ArrowDigester expects a pyarrow.Schema"): + f2.Digester(batch) + with pytest.raises(TypeError, match="hash_array expects"): + f2.hash_array([1, 2]) + + +def test_hash_array_of_chunked_array_equals_combined_array() -> None: + chunked = pa.chunked_array([pa.array([1, None], pa.int32()), pa.array([], pa.int32()), pa.array([3], pa.int32())]) + assert f2.hash_array(chunked) == f2.hash_array(chunked.combine_chunks()) + nested = pa.chunked_array([pa.array([[True], None]), pa.array([[False, None]])]) + assert f2.hash_array(nested) == f2.hash_array(nested.combine_chunks()) + + +def test_bits_restore_after_partial_appends() -> None: + """Snapshots restore exactly, whether the buffer ended mid-byte or on a byte boundary.""" + from starfix._format2 import _Bits + + for prefix in (0, 3, 8, 13): + bits = _Bits() + bits.append_true(prefix) + state = bits.snapshot() + bits.append_true(11) + bits.restore(state) + bits.append_true(2) + reference = _Bits() + reference.append_true(prefix + 2) + assert bits._len == reference._len and bytes(bits._bytes) == bytes(reference._bytes), prefix diff --git a/tests/test_legacy_v0_4_frozen.py b/tests/test_legacy_v0_4_frozen.py index 9933ce6..b1fc225 100644 --- a/tests/test_legacy_v0_4_frozen.py +++ b/tests/test_legacy_v0_4_frozen.py @@ -13,7 +13,7 @@ _SRC = Path(__file__).parent.parent / "src" / "starfix" _LEGACY = _SRC / "legacy" / "v0_4.py" -_LEGACY_SHA256 = "7b4c76508f1f96b96c18e0d2bac87b9f2e8ae8b343254b9be5060e87e0fe6704" +_LEGACY_SHA256 = "d7641a8e64b08d3f2698fbc0e461a0cf495cf1c6dc552a9798f9e1343160bb91" def test_legacy_module_is_unchanged() -> None: diff --git a/tests/test_legacy_v0_4_golden_parity_r2.py b/tests/test_legacy_v0_4_golden_parity_r2.py index ebddd57..5e0809b 100644 --- a/tests/test_legacy_v0_4_golden_parity_r2.py +++ b/tests/test_legacy_v0_4_golden_parity_r2.py @@ -1,5 +1,7 @@ -"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored unchanged except for the import -(starfix.legacy.v0_4). Its format-1 values pin the frozen legacy module byte for byte. +"""[Legacy 0.4 mode] starfix-python v0.4.0 test, restored with its original format-1 values. +Changes: the import (starfix.legacy.v0_4), and the _with_type / _record_batch helpers that build +struct inputs with the schema's field types (pyarrow 19 cannot cast nullable struct children to +non-nullable ones); same data. Its values pin the frozen legacy module byte for byte. Golden-hash parity tests — Round 2. From 8082bbe26d04277269270cb0c1a7458c381a41e7 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:08:40 -0800 Subject: [PATCH 39/49] docs/test: independent review of PR #9, items 4, 5, 7, 8, 10, 11, 13, 15 (ITL-898) 4 README/CHANGELOG: extension types are hashed as stored; exact only where pyarrow can observe the stored form (list of non-canonical cases; a Python-defined type's serializer must reproduce the stored bytes); the 'byte-identical to Rust' claim names this one exception 5 ArrowDigester docstring: ValueError (not NotImplementedError) for unsupported data, plus every rejection; TypeError for wrong containers; not thread-safe; hash_array deliberately without include_metadata 7/8/13 README Performance section (linear; strings ~3-5M rows/s; a few us per column per update); _visit docstring states what is still allocated 10 golden test asserts minimum vector/relation counts; pytest empty_parameter_set_mark = fail_at_collect 11 test_format2.py: expectations no longer taken from the implementation (hand-written Phase 1 / type JSON); docstring says what is independent; stale notes removed 15 CI: Python 3.13 in the test matrix; golden-sync also diffs python_literals_format1_inputs.json (identical to the Rust copy) CHANGELOG: the version comes from the git tag at release Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 6 +-- CHANGELOG.md | 8 ++- README.md | 46 ++++++++++++++-- pyproject.toml | 4 ++ src/starfix/_format2.py | 6 ++- src/starfix/arrow_digester.py | 21 +++++--- tests/test_format2.py | 83 ++++++++++++++++++----------- tests/test_golden_parity_format2.py | 7 +++ 8 files changed, 134 insertions(+), 47 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 11558bf..3fc6cff 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,7 +14,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12", "3.13"] steps: - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 @@ -151,7 +151,7 @@ jobs: # Raw media type: no 1 MB limit (format2_v0.5.json is append-only and grows). # Tolerate missing files here so the next step prints the explanation. # On failure gh prints the error body to stdout, so keep the file only on success. - for f in format2_v0.5.json format1_to_format2.json; do + for f in format2_v0.5.json format1_to_format2.json python_literals_format1_inputs.json; do if ! gh api -H "Accept: application/vnd.github.raw" \ "repos/nauticalab/starfix/contents/tests/golden/$f" > "/tmp/upstream_$f"; then rm -f "/tmp/upstream_$f" @@ -162,7 +162,7 @@ jobs: - name: Fail on format-2 fixture drift run: | - for f in format2_v0.5.json format1_to_format2.json; do + for f in format2_v0.5.json format1_to_format2.json python_literals_format1_inputs.json; do if [ ! -s "/tmp/upstream_$f" ]; then echo "ERROR: Could not fetch tests/golden/$f from nauticalab/starfix main." echo "(the starfix ITL-898 PR must be merged before this check can pass)" diff --git a/CHANGELOG.md b/CHANGELOG.md index 30aa897..c237135 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ ## Unreleased (proposed 0.5.0) +The package version comes from the git tag at release (hatch-vcs); nothing in the source +pins it to 0.5.0. + ### Changed — hash format 2 (every hash changes) starfix-python now computes hash format 2, byte-identical to the Rust starfix crate 0.5. The @@ -48,7 +51,10 @@ buffers: at 1M rows, `list` takes about 20 ms instead of an estimated 90 `hash_schema`, `hash_record_batch`, `hash_table` and `hash_array`: make column order and struct field order (at every depth) part of the hash. Default off. - Extension types are hashed as their storage type; with `include_metadata`, their - `ARROW:extension:*` keys are hashed, also for types registered with pyarrow. + `ARROW:extension:*` keys are hashed as stored. For extension types that pyarrow registers, + this is exact only when the stored metadata and storage are what pyarrow reconstructs + (canonical forms; a Python-defined type's serializer must reproduce the stored bytes); see + the README section "Extension types". - Golden vectors `tests/golden/format2_v0.5.json`, generated by Rust and asserted in full. ### Changed (breaking) diff --git a/README.md b/README.md index bc7072d..41e0f55 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,9 @@ Pure-Python implementation of the [starfix](https://github.com/nauticalab/starfi Produces stable SHA-256 hashes of Arrow schemas, tables, record batches and arrays that are: - **Byte-identical to the Rust implementation**: every vector of the shared golden file - (`tests/golden/format2_v0.5.json`, generated by Rust) is matched. + (`tests/golden/format2_v0.5.json`, generated by Rust) is matched. The one documented + exception concerns stored extension-type metadata that pyarrow cannot observe (see + [Extension types](#extension-types)). - **Column-order and struct-field-order independent** by default. Both orders can be made part of the hash (see [Options](#options)). Nothing else is reordered: row order and list element order are always hashed. @@ -77,8 +79,32 @@ digest = ArrowDigester.hash_table(table, ordered_columns=True, ordered_struct_fi - With `include_metadata`, metadata is keyed by each field's node path (column `c`, struct child `c/x`, list element `c/`, map key and value `m//key` and `m//value`). Extension types are hashed as their storage type; with `include_metadata` their `ARROW:extension:name` and - `ARROW:extension:metadata` are hashed too, including for extension types registered with - pyarrow. + `ARROW:extension:metadata` are hashed too (see [Extension types](#extension-types)). +- `hash_array` has no `include_metadata` on purpose: an array carries no schema or field + metadata. It accepts a `ChunkedArray` (hashed like the combined array). +- A digester is not thread-safe; a batch rejected by `update` leaves it unchanged. + +### Extension types + +With `include_metadata`, an extension type's field metadata is hashed **as stored**, including +`ARROW:extension:name` and `ARROW:extension:metadata` (an absent `ARROW:extension:metadata` +counts as `""`). pyarrow hides these two keys for extension types it has registered and +rebuilds the type from them, so starfix-python hashes what pyarrow can observe: + +- **Unregistered extension types:** the stored keys are hashed verbatim. Identical to Rust. +- **Python-defined `pa.ExtensionType` subclasses** (registered with + `pa.register_extension_type`): the keys are re-added from `extension_name` and + `__arrow_ext_serialize__()`. Identical to Rust **only if the serializer reproduces the + stored bytes exactly**. Otherwise the hash differs from Rust's, and it also depends on + whether the type is registered in the hashing process. +- **pyarrow's built-in canonical extension types** (`arrow.uuid`, `arrow.json`, `arrow.bool8`, + `arrow.opaque`, `arrow.fixed_shape_tensor`, `arrow.variable_shape_tensor`, depending on the + pyarrow version): pyarrow re-serializes their metadata and rebuilds their storage type, so + the hash is defined only for the canonical stored form, the one every Arrow implementation + writes. It differs from Rust when the stored data is not canonical, for example: + `arrow.json` stored with metadata `{}` instead of `""`; `arrow.opaque` or tensor metadata + JSON with another key order or whitespace; a fixed-shape tensor stored over a non-nullable + item field. ## Rejected inputs @@ -92,11 +118,25 @@ digest = ArrowDigester.hash_table(table, ordered_columns=True, ordered_struct_fi `Utf8View` or `BinaryView` (their schemas hash; their data does not), whatever the number of rows; - a non-nullable field holding a null that no enclosing struct null explains; +- with `include_metadata`: a duplicate metadata key on a field or the schema, or explicit + `ARROW:extension:*` keys that conflict with the field's registered extension type; - streaming: a batch whose schema differs from the digester's. Physically different but equivalent types (`Utf8`/`LargeUtf8`, `Binary`/`LargeBinary`, `List`/`LargeList`, dictionary and plain values) are accepted; reordered columns or struct fields are accepted unless the matching order option is on. +`TypeError` is raised for a wrong container type, for example a `Table` passed to +`hash_record_batch` or a `RecordBatch` passed to `hash_table`. + +## Performance + +Hashing takes time linear in the data size and works on Arrow buffers (bounded temporary +memory). Fixed-width, Boolean and list columns hash at tens of millions of rows per second. +String and binary columns hash at about 3 to 5 million rows per second, because each value is +visited in Python. Each `update` call also costs a few microseconds per column, to check the +batch's schema. starfix-python is a pure-Python implementation; the Rust crate is faster on +string-heavy data. + ## Hash format The byte layout is specified in starfix's `docs/byte-layout-spec.md`. The first three bytes of diff --git a/pyproject.toml b/pyproject.toml index 91af9e5..fdb0323 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,3 +27,7 @@ version-file = "src/starfix/_version.py" [tool.hatch.build.targets.wheel] packages = ["src/starfix"] + +[tool.pytest.ini_options] +# An empty parametrization (e.g. a golden file without relations) must fail, not skip. +empty_parameter_set_mark = "fail_at_collect" diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 0c6b7bb..5930643 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -618,8 +618,10 @@ def _visit( `arr` holds the node's candidate elements; `select` (None: all) marks which of them are elements at all: below a list, the items of valid list values (items of null or masked list values are not visited). `enclosing` is the AND of the enclosing struct validities - at this list level (None: all valid). Nothing proportional to the payload is copied: - list children are zero-copy slices of the original values with a selection mask. + at this list level (None: all valid). Value payloads (string/binary bytes, list + children) are not copied: list children are zero-copy slices of the original values with + a selection mask. Per-element metadata is still allocated: validity bitmaps, list lengths + cast to u64, and list_parent_indices (8 bytes per list item). """ arr = _resolve(arr) entry = entries[path] diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index a33bada..415ab49 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -26,11 +26,17 @@ class ArrowDigester: reordered. Arrow schema- and field-level metadata are hashed only with ``include_metadata=True``; a schema without metadata hashes the same either way. - Raises ``ValueError`` for schemas in which two nodes share a path (duplicate names, - or a name containing ``/`` that aliases another node), for ListView, Union and - RunEndEncoded types, and for a streamed batch whose schema differs from the - digester's. Raises ``NotImplementedError`` for data of types whose schema can be - hashed but whose data cannot (Null, FixedSizeList, Map, Interval, view types). + Raises ``ValueError`` (in every mode) for: schemas in which two nodes share a path + (duplicate names, or a name containing ``/`` that aliases another node); ListView, + LargeListView, Union and RunEndEncoded types; hashing data of a schema containing + Null, FixedSizeList, Map, Interval or view types (their schemas hash), whatever the + number of rows; a non-nullable field holding a null that no enclosing struct null + explains; duplicate metadata keys when ``include_metadata`` is on; and a streamed + batch whose schema differs from the digester's. Raises ``TypeError`` for a wrong + container type (for example a Table passed to ``hash_record_batch``). + + A digester is not thread-safe: feed one digester from one thread at a time. A batch + rejected by ``update`` leaves the digester unchanged. """ def __init__( @@ -122,9 +128,10 @@ def hash_array( ordered_columns: bool = False, ordered_struct_fields: bool = False, ) -> bytes: - """Hash a single array (no schema; ``include_metadata`` does not apply). + """Hash a single array or ChunkedArray (equal to its chunks combined). - ``ordered_columns`` changes only the header of an array's hash. + There is deliberately no ``include_metadata``: an array has no schema or field + metadata. ``ordered_columns`` changes only the header of an array's hash. """ return _format2.hash_array( array, ordered_columns=ordered_columns, ordered_struct_fields=ordered_struct_fields diff --git a/tests/test_format2.py b/tests/test_format2.py index 77c5e97..210630c 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -1,9 +1,11 @@ """Hash format 2 (ITL-898), checked byte for byte against the specification. -Spec: ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2, commit 041b8f1). Every -expected value is built here from the literal SHA-256 inputs in the spec, or is a final -hash the spec prints; never from the implementation under test. Cross-language values are -pinned separately by the Rust golden file once it lands. +Spec: ``nauticalab/starfix docs/byte-layout-spec.md`` (format 2). Expected values are +independent of the implementation under test: SHA-256 inputs written out from the spec's +rules and worked examples (headers, hand-written canonical JSON, entry bytes), or hashes the +spec prints. The exceptions are property tests, which compare two hashes of the +implementation (e.g. equivalent inputs hash equal, different inputs differ). Cross-language +values are pinned by the Rust golden file in tests/test_golden_parity_format2.py. """ from __future__ import annotations @@ -36,6 +38,11 @@ def ha(flags: int = 0) -> bytes: # hash_array header return header(flags, b"A") +def sd(json_: bytes, flags: int = 0) -> bytes: + """Schema digest from a hand-written Phase 1 JSON (Section 2.5, no metadata).""" + return sha(hs(flags), json_) + + def all_valid(n: int) -> bytes: """Validity entry of n valid elements (the hash_array root is always nullable).""" return u64(n) + ((1 << n) - 1).to_bytes((n + 7) // 8, "little") @@ -158,7 +165,7 @@ def test_example_2_list() -> None: batch = pa.record_batch([pa.array([[1, None], None, []], t)], schema=schema) final = sha( hr(), - f2.hash_schema(schema)[3:], + sd(b'{"c":{"data_type":{"LargeList":{"data_type":"Int32","nullable":true}},"nullable":true}}'), u64(3), u64(3) + b"\x05", sha(u64(2) + u64(0)), @@ -178,7 +185,7 @@ def test_example_3_nullable_struct() -> None: batch = pa.record_batch([s], schema=schema) final = sha( hr(), - f2.hash_schema(schema)[3:], + sd(b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":true}]},"nullable":true}}'), u64(3), u64(3) + b"\x06", u64(3) + b"\x04", @@ -194,7 +201,10 @@ def test_example_4_list_of_nullable_struct() -> None: batch = pa.record_batch([pa.array([[None, {"a": 4}]], t)], schema=schema) final = sha( hr(), - f2.hash_schema(schema)[3:], + sd( + b'{"l":{"data_type":{"LargeList":{"data_type":{"Struct":[{"data_type":"Int32","name":"a",' + b'"nullable":true}]},"nullable":true}},"nullable":false}}' + ), u64(1), sha(u64(2)), # "l": lengths u64(2) + b"\x02", # "l/": validity [0,1] @@ -215,7 +225,11 @@ def test_example_4_as_printed_with_non_nullable_child() -> None: pa.StructArray.from_arrays([pa.array([0, 4], pa.int32())], fields=list(st), mask=pa.array([True, False])), ).cast(t) batch = pa.record_batch([arr], schema=schema) - final = sha(hr(), f2.hash_schema(schema)[3:], u64(1), sha(u64(2)), u64(2) + b"\x02", sha(i32(4))) + schema_digest = sd( + b'{"l":{"data_type":{"LargeList":{"data_type":{"Struct":[{"data_type":"Int32","name":"a",' + b'"nullable":false}]},"nullable":true}},"nullable":false}}' + ) + final = sha(hr(), schema_digest, u64(1), sha(u64(2)), u64(2) + b"\x02", sha(i32(4))) assert f2.hash_record_batch(batch) == V + final @@ -266,7 +280,12 @@ def test_phase2_paths_and_schema_metadata() -> None: expected_phase2 = ( b'{"fields":{"d/x":{"k":"1"},"l/":{"e":"2"},"s":{"c":"3"},"s/x":{"k":"1"}},"schema":{"a":"0","z":"9"}}' ) - phase1 = f2.phase1_json(schema, 0).encode() + x_struct = b'{"Struct":[{"data_type":"Int8","name":"x","nullable":true}]}' + phase1 = ( + b'{"d":{"data_type":' + x_struct + b',"nullable":true},' + b'"l":{"data_type":{"LargeList":{"data_type":"Int8","nullable":true}},"nullable":true},' + b'"s":{"data_type":' + x_struct + b',"nullable":true}}' + ) assert f2.hash_schema(schema, include_metadata=True) == V + sha(hs(), phase1, expected_phase2) @@ -293,7 +312,7 @@ def test_names_and_physical_variants_not_hashed(left, right) -> None: def test_non_nullable_child_of_null_struct_contributes_nothing() -> None: - """Spec 3.2: elements whose (AND-ed) bit is 0 contribute no values (pending E2).""" + """Spec 3.2: elements whose effective validity is 0 contribute no values (also non-nullable).""" s = pa.StructArray.from_arrays( [pa.array([1, 2, 3], pa.int32())], fields=[pa.field("a", pa.int32(), nullable=False)], @@ -301,7 +320,8 @@ def test_non_nullable_child_of_null_struct_contributes_nothing() -> None: ) schema = pa.schema([pa.field("s", s.type, nullable=True)]) batch = pa.record_batch([s], schema=schema) - final = sha(hr(), f2.hash_schema(schema)[3:], u64(3), u64(3) + b"\x05", sha(i32(1, 3))) + schema_digest = sd(b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"a","nullable":false}]},"nullable":true}}') + final = sha(hr(), schema_digest, u64(3), u64(3) + b"\x05", sha(i32(1, 3))) assert f2.hash_record_batch(batch) == V + final @@ -315,24 +335,23 @@ def batch(n): def test_entry_order_is_bytewise_node_path_order() -> None: schema = pa.schema([pa.field("b", pa.int8(), nullable=False), pa.field("a", pa.int8(), nullable=False)]) batch = pa.record_batch([pa.array([1], pa.int8()), pa.array([2], pa.int8())], schema=schema) - final = sha(hr(), f2.hash_schema(schema)[3:], u64(1), sha(b"\x02"), sha(b"\x01")) + schema_digest = sd(b'{"a":{"data_type":"Int8","nullable":false},"b":{"data_type":"Int8","nullable":false}}') + final = sha(hr(), schema_digest, u64(1), sha(b"\x02"), sha(b"\x01")) assert f2.hash_record_batch(batch) == V + final def test_leaf_value_bytes() -> None: cases = [ - (pa.array([1.5], pa.float64()), struct.pack(" None: f2.hash_array(pa.array([], t)) -# ── Section 2.3: extension types (E1 pending for pyarrow's C++ built-in types) ── +# ── Section 2.3: extension types ── class _Point(pa.ExtensionType): @@ -664,7 +683,8 @@ def test_child_null_masked_by_null_parent_is_accepted() -> None: st = pa.struct([pa.field("x", pa.int32(), nullable=False)]) s = pa.StructArray.from_arrays([pa.array([1, None], pa.int32())], fields=list(st), mask=pa.array([False, True])) schema = pa.schema([pa.field("s", st, nullable=True)]) - final = sha(hr(), f2.hash_schema(schema)[3:], u64(2), u64(2) + b"\x01", sha(i32(1))) + schema_digest = sd(b'{"s":{"data_type":{"Struct":[{"data_type":"Int32","name":"x","nullable":false}]},"nullable":true}}') + final = sha(hr(), schema_digest, u64(2), u64(2) + b"\x01", sha(i32(1))) assert f2.hash_record_batch(pa.record_batch([s], schema=schema)) == V + final @@ -722,16 +742,17 @@ def test_nullable_leaves_hashed_in_bounded_chunks(budget, monkeypatch) -> None: bools = [True, None, False, True, None, False, True] fsb = [b"\x01\x02", None, b"\x03\x04", b"\x05\x06", None, b"\x07\x08", b"\x09\x0a"] cases = [ - (pa.array(strs).slice(1), b"".join(u64(len(s.encode())) + s.encode() for s in strs[1:] if s is not None)), - (pa.array(ints, pa.int32()).slice(1), i32(*[v for v in ints[1:] if v is not None])), - (pa.array(bools).slice(1), bytes(int(v) for v in bools[1:] if v is not None)), - (pa.array(fsb, pa.binary(2)).slice(1), b"".join(v for v in fsb[1:] if v is not None)), + (pa.array(strs).slice(1), b'"LargeUtf8"', + b"".join(u64(len(s.encode())) + s.encode() for s in strs[1:] if s is not None)), + (pa.array(ints, pa.int32()).slice(1), b'"Int32"', i32(*[v for v in ints[1:] if v is not None])), + (pa.array(bools).slice(1), b'"Boolean"', bytes(int(v) for v in bools[1:] if v is not None)), + (pa.array(fsb, pa.binary(2)).slice(1), b'{"FixedSizeBinary":2}', b"".join(v for v in fsb[1:] if v is not None)), ] - for arr, value_bytes in cases: + for arr, type_json, value_bytes in cases: valid = [v is not None for v in arr.to_pylist()] bits = sum(1 << i for i, ok in enumerate(valid) if ok) validity = u64(len(arr)) + bits.to_bytes((len(arr) + 7) // 8, "little") - expected = V + sha(ha(), f2.type_json(arr.type, 0).encode(), u64(len(arr)), validity, sha(value_bytes)) + expected = V + sha(ha(), type_json, u64(len(arr)), validity, sha(value_bytes)) assert f2.hash_array(arr) == expected, (arr.type, budget) diff --git a/tests/test_golden_parity_format2.py b/tests/test_golden_parity_format2.py index 4ed8501..38737db 100644 --- a/tests/test_golden_parity_format2.py +++ b/tests/test_golden_parity_format2.py @@ -64,8 +64,15 @@ def _hash(vector: dict[str, Any]) -> str: return result.hex() +# Counts of the final golden file; the file is append-only, so they can only grow. +_MIN_VECTORS = 323 +_MIN_RELATIONS = 89 + + def test_fixture_is_well_formed() -> None: fixture = _fixture() + assert len(_vectors()) >= _MIN_VECTORS, f"only {len(_vectors())} vectors" + assert len(_relations()) >= _MIN_RELATIONS, f"only {len(_relations())} relations" assert fixture["format"] == 2 ids = [v["id"] for v in _vectors()] assert ids and len(ids) == len(set(ids)), "vector ids must be unique" From 786b9feb23b5063cee16b35cc88c4bf43901a95e Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:09:25 -0800 Subject: [PATCH 40/49] test: format2_v0.5.json at starfix b5398ce (entry-point kind, hash_array root); literals remapped (ITL-898) format2_v0.5.json (339 vectors, 96 relations; sha256 e049bc22...) and format1_to_format2.json (203 entries, unique ids; sha256 bda80b0b...) copied byte for byte from starfix b5398ce. Every hand-coded literal (108) moved to its new Rust value (joined on the format-1 hash). Parity 339/339 vectors and 96/96 relations, no skips, no xfails; minimum counts raised. Co-Authored-By: Claude Opus 5.5 --- tests/golden/format1_to_format2.json | 436 +++++++------- tests/golden/format2_v0.5.json | 864 +++++++++++++++++---------- tests/test_arrow_digester.py | 18 +- tests/test_golden_parity.py | 110 ++-- tests/test_golden_parity_format2.py | 4 +- tests/test_golden_parity_r2.py | 86 +-- tests/test_metadata_hashing.py | 2 +- 7 files changed, 869 insertions(+), 651 deletions(-) diff --git a/tests/golden/format1_to_format2.json b/tests/golden/format1_to_format2.json index dafab3e..7ae5934 100644 --- a/tests/golden/format1_to_format2.json +++ b/tests/golden/format1_to_format2.json @@ -1,74 +1,74 @@ { - "description": "Every format-1 golden or pinned value of this repository and its format-2 value (ITL-898, hash format bump 00 00 01 -> 00 00 02). Every value moves. Entries with format2_vector refer to tests/golden/format2_v0.5.json (same input). format1_defects lists the format-1 information losses that affected that input (byte-layout spec Section 10). Entries whose source is a starfix-python test were recovered by the Python side (tests/golden/python_literals_format1_inputs.json) and their format-1 values reproduced with starfix 0.4.", + "description": "Every format-1 golden or pinned value of this repository and its format-2 value (ITL-898, hash format bump 00 00 01 -> 00 00 02). Every value moves. Entries with format2_vector refer to tests/golden/format2_v0.5.json (same input). format1_defects lists the format-1 information losses that affected that input (byte-layout spec Section 10). Entries whose source is a starfix-python test were recovered by the Python side (tests/golden/python_literals_format1_inputs.json) and their format-1 values reproduced with starfix 0.4. Ids are unique: a source with several literals of the same test numbers the later ones #2, #3, ...", "entries": [ { "source": "tests/golden/include_metadata_v0.3.json", "id": "no_metadata_include_false", "format1_hash": "00000131f10e388ffb366939a37d877568320d681eb2c6e81793259274afd3b10ae38d", - "format2_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1", + "format2_hash": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3", "format2_vector": "no_metadata_include_false" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "schema_level_metadata", "format1_hash": "00000185971192458c11308853f8647b688810b7efd3afb5e1a3811ebf1c449969b18d", - "format2_hash": "000002c2cd6a73cf9a5cf24ce01fd184b7485e55a2c443e543fd981bf32929fb0cf234", + "format2_hash": "000002947adb029bfa2139d1cf5c2c34c2aeb4798be4154484f01368d3a4b0e9f3cbcc", "format2_vector": "schema_level_metadata" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "field_metadata_single_field", "format1_hash": "000001d1490be52114b6a5284a89e91522b111f3e6ee1534edf2e472956f07360df020", - "format2_hash": "0000020b130367ff66564f4f9978ca3e506e3e305d12cb6ff6ae2c4fe747a2cc7bd5f2", + "format2_hash": "000002ae0dd1f0e4e372edb7c1c2e03cad21aaf0fca9e1a8415016218242cc5d83b0ab", "format2_vector": "field_metadata_single_field" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "field_metadata_multiple_fields", "format1_hash": "000001fdaa74e60eec18b816ac8e732f943fe405aaa9465ad3b788c083322b0bf16757", - "format2_hash": "000002e03369228220921177c5c578c461e3916b6ef44bb21e32c216ef6c0925429e88", + "format2_hash": "000002557839de98aded74876685e0bee6cf73f79ec9ade25ce0767505720fe453881d", "format2_vector": "field_metadata_multiple_fields" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "schema_and_field_metadata", "format1_hash": "000001dd9181cde304d1e39d424283c46d0b63126fa12e1272ce92ca34d7d4389dec65", - "format2_hash": "0000027eda76a93d2e60bc24c6eaee85eb53a24199dc58a9e15cfb483df94f2ecfef02", + "format2_hash": "00000269fa67810dd0ffea5b7f22d32ba797bf4e1213d935d782046442334f9186ef9b", "format2_vector": "schema_and_field_metadata" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "unicode_metadata", "format1_hash": "00000155498f11ff0803127d60f8c6daa18b8c8dbb3411d2962e08ee0dfbce7054706b", - "format2_hash": "000002d82b81b3e7338563c258ad4df581c4033d24fa73ca8c533d943b2f6890e7c9bf", + "format2_hash": "0000027a667866945ffee424dec01ad00c7d6661329182b0991c28226f22e7ecf4c641", "format2_vector": "unicode_metadata" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "key_reorder_canonical", "format1_hash": "0000016a68d96d5c89d9b5de01d104c7ad1f51f9956bd8758691c9241ecacf32c701bf", - "format2_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e", + "format2_hash": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed", "format2_vector": "key_reorder_canonical" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "key_reorder_shuffled", "format1_hash": "0000016a68d96d5c89d9b5de01d104c7ad1f51f9956bd8758691c9241ecacf32c701bf", - "format2_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e", + "format2_hash": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed", "format2_vector": "key_reorder_shuffled" }, { "source": "tests/golden/include_metadata_v0.3.json", "id": "empty_metadata_invariant", "format1_hash": "00000131f10e388ffb366939a37d877568320d681eb2c6e81793259274afd3b10ae38d", - "format2_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1", + "format2_hash": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3", "format2_vector": "empty_metadata_invariant" }, { "source": "released starfix 0.4.0 crate (reference vectors)", "id": "cols_ab_rb_f0", "format1_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d", - "format2_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6", + "format2_hash": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd", "format2_vector": "cols_ab_rb_f0", "format1_defects": [] }, @@ -76,7 +76,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "cols_ba_rb_f0", "format1_hash": "000001de18d228593820186a858bad9fc4f8ffaddd33ee73531fcd2a72b6ac2ce2f01d", - "format2_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6", + "format2_hash": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd", "format2_vector": "cols_ba_rb_f0", "format1_defects": [] }, @@ -84,7 +84,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "cols_ab_schema_f0", "format1_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9", - "format2_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78", + "format2_hash": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864", "format2_vector": "cols_ab_schema_f0", "format1_defects": [] }, @@ -92,7 +92,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "cols_ba_schema_f0", "format1_hash": "0000012cf4307c187fb3bff39b94d42d85ca4fef5d46203082b014486f98423aa6fef9", - "format2_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78", + "format2_hash": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864", "format2_vector": "cols_ba_schema_f0", "format1_defects": [] }, @@ -100,7 +100,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "combo_ns_xy_f0", "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", - "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", "format2_vector": "combo_ns_xy_f0", "format1_defects": [ "boolean_packing" @@ -110,7 +110,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "combo_sn_xy_f0", "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", - "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", "format2_vector": "combo_sn_xy_f0", "format1_defects": [ "boolean_packing" @@ -120,7 +120,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "combo_ns_yx_f0", "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", - "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", "format2_vector": "combo_ns_yx_f0", "format1_defects": [ "boolean_packing" @@ -130,7 +130,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "combo_sn_yx_f0", "format1_hash": "00000104a7fc5a264db0cda632bf4ac856e8c2f1285af97c65430cfb361446ec0216cd", - "format2_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674", + "format2_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", "format2_vector": "combo_sn_yx_f0", "format1_defects": [ "boolean_packing" @@ -140,7 +140,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nested_struct_ab_schema_f0", "format1_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad", - "format2_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2", + "format2_hash": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e", "format2_vector": "nested_struct_ab_schema_f0", "format1_defects": [] }, @@ -148,7 +148,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nested_struct_ba_schema_f0", "format1_hash": "00000120a933e10f38c3793842e19452e62d42567ba293cdc57d48d1b33f5d8e6f6dad", - "format2_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2", + "format2_hash": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e", "format2_vector": "nested_struct_ba_schema_f0", "format1_defects": [] }, @@ -156,7 +156,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "list_struct_ab_rb_f0", "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", - "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", "format2_vector": "list_struct_ab_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -166,7 +166,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "list_struct_ba_rb_f0", "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", - "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", "format2_vector": "list_struct_ba_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -176,7 +176,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "large_list_struct_ab_rb_f0", "format1_hash": "000001ef7a82cdbf533f8f10c07b716c56be4aa9959fa0a3542ccd15baf974a04feafb", - "format2_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203", + "format2_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", "format2_vector": "large_list_struct_ab_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -186,7 +186,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "fsl_struct_ab_schema_f0", "format1_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5", - "format2_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc", + "format2_hash": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33", "format2_vector": "fsl_struct_ab_schema_f0", "format1_defects": [] }, @@ -194,7 +194,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "fsl_struct_ba_schema_f0", "format1_hash": "000001b77e167c5c284296608fb9bce12713821184d75c0bed506e30cd77fcf45ecec5", - "format2_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc", + "format2_hash": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33", "format2_vector": "fsl_struct_ba_schema_f0", "format1_defects": [] }, @@ -202,7 +202,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "map_struct_ab_schema_f0", "format1_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c", - "format2_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2", + "format2_hash": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777", "format2_vector": "map_struct_ab_schema_f0", "format1_defects": [] }, @@ -210,7 +210,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "map_struct_ba_schema_f0", "format1_hash": "000001c1f31d6085f292672bab0eb0523dbc5e8e6eb9a5fde5090dac8c81a2c830ac7c", - "format2_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2", + "format2_hash": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777", "format2_vector": "map_struct_ba_schema_f0", "format1_defects": [] }, @@ -218,7 +218,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "one_col_rb_f0", "format1_hash": "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857", - "format2_hash": "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b", + "format2_hash": "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27", "format2_vector": "one_col_rb_f0", "format1_defects": [] }, @@ -226,7 +226,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "one_col_schema_f0", "format1_hash": "000001b7f25ba092def78ecd57c231765bac9d23a37ef04734462c1f50ec5880e7f204", - "format2_hash": "0000021e21972ae342e0d1df1e326a7b21effda3967fcbcdfa1e35b404878354093ad4", + "format2_hash": "0000028ff3df6a3c3249959db37063755324949df6b294b624131d395269f8d3f64528", "format2_vector": "one_col_schema_f0", "format1_defects": [] }, @@ -234,7 +234,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "one_col_array_f0", "format1_hash": "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c", - "format2_hash": "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a", + "format2_hash": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f", "format2_vector": "one_col_array_f0", "format1_defects": [] }, @@ -242,7 +242,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "ext_struct_xy_rb_f0_im1", "format1_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb", - "format2_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a", + "format2_hash": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796", "format2_vector": "ext_struct_xy_rb_f0_im1", "format1_defects": [ "boolean_packing" @@ -252,7 +252,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "ext_struct_yx_rb_f0_im1", "format1_hash": "000001bccd1a055d1326bd7cd9d1f88da92cae6e250a2d10708e161afa86be068ccdfb", - "format2_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a", + "format2_hash": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796", "format2_vector": "ext_struct_yx_rb_f0_im1", "format1_defects": [ "boolean_packing" @@ -262,7 +262,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "zero_cols_0rows_rb_f0", "format1_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6", - "format2_hash": "000002b2a0b24f3e5df2eee53e0db16967b5727624ba316c984d3e5ba250495e0cc8e7", + "format2_hash": "00000250cb2fc7aaf1c32b7d195c543876c8333c0b15f85caf96b4ce43fe587f444d07", "format2_vector": "zero_cols_0rows_rb_f0", "format1_defects": [] }, @@ -270,7 +270,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "zero_cols_3rows_rb_f0", "format1_hash": "000001c74f3008fdd2f7c5ae5446ab2e522629f63346f68a4026b4f72b91b393475ff6", - "format2_hash": "00000245bae18d1db53b328b187930c2ed6f652be046f8156f30565ef09b22c10c8a08", + "format2_hash": "000002d1c4267472a7b0df719325b9fea373625afa4c828dce1f56a106e14c09987068", "format2_vector": "zero_cols_3rows_rb_f0", "format1_defects": [] }, @@ -278,7 +278,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_null_struct_rb_f0", "format1_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9", - "format2_hash": "000002db84efc10bb100fb89bc3dd8d36572cb411b2871732479f26eed388229c3b2af", + "format2_hash": "0000026630aa8326714cbd9cb8e539a9dc2aa9e966bc61cc43f4da30bb51a855c9cd06", "format2_vector": "nv_null_struct_rb_f0", "format1_defects": [ "nullable_struct" @@ -288,7 +288,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_null_fields_rb_f0", "format1_hash": "00000103d480f6459069c661bb0e93923fe8cfe505cf8d7daf363bef0d9cd7552295c9", - "format2_hash": "000002ae04d1306e82b99f8cfbc5c3d42d529b7f5e1e57eb728426c496781e93091027", + "format2_hash": "000002517a1bd090b9ddec71fb8656b6a5064b97e18ad760c14116ef1799cba4eb36fe", "format2_vector": "nv_null_fields_rb_f0", "format1_defects": [ "nullable_struct" @@ -298,7 +298,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_rows3_rb_f0", "format1_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a", - "format2_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd", + "format2_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f", "format2_vector": "nv_rows3_rb_f0", "format1_defects": [ "nullable_struct" @@ -308,7 +308,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_rows2_rb_f0", "format1_hash": "000001480a4649266dce9eb73e48072e37598caafe7be4cd92549920cfbbe2a7f9dd0a", - "format2_hash": "000002ba8982cfb0a3a959a78134c6d90f9fb7ffacbb8a71a3764bc50dbd623ae0d7b7", + "format2_hash": "000002cf2404bcc0218a195c4a262cc022bf7c77f4806d41e8c4431e3cfd5cc97ee9a4", "format2_vector": "nv_rows2_rb_f0", "format1_defects": [ "nullable_struct" @@ -318,7 +318,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_list_list_1row_rb_f0", "format1_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006", - "format2_hash": "00000281c6c806d1945038ecebdfb5b3afa115fb8322d74c682d4984e7c35b2fb8ac11", + "format2_hash": "0000022a14ec9cc1066b92f435f414832d0948a52d72dccfb2c4f35eea219da00c7c96", "format2_vector": "nv_list_list_1row_rb_f0", "format1_defects": [ "list_of_nullable_list" @@ -328,7 +328,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_list_list_2rows_rb_f0", "format1_hash": "000001cdc413731107ace52443c76e11051f1ef8b1bd98b81bfafa1e4800917d813006", - "format2_hash": "000002a2c92a16669aac9a5e1312db5966e75d3a15bfef192e651424462ec955fb6438", + "format2_hash": "0000021fae7750bc9e056286f3446edae67e8ad93c540edbd3290f6c4bf2d63882390d", "format2_vector": "nv_list_list_2rows_rb_f0", "format1_defects": [ "list_of_nullable_list" @@ -338,7 +338,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_list_null_elem_rb_f0", "format1_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6", - "format2_hash": "000002759eb8659b32aa8437b39c041effd8bbef2ae68d7a5d6c5deae8df2559df5a8b", + "format2_hash": "000002880943a6023e397289e89fb31d609807d68a56568133935693da686c53199eea", "format2_vector": "nv_list_null_elem_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -348,7 +348,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_list_null_fields_elem_rb_f0", "format1_hash": "0000017d4c97792f67c22b08676bd80a9ba94f5630905facc4455b7e90de966b5286d6", - "format2_hash": "00000262e139b737f1bcebd138ac4e9a6dbadb9a8e7a9c24d93bcf7db418693323619e", + "format2_hash": "00000276aeb72c9e3f36df94c629d354a68c357bf5306d86e2be7244de6c0a9f233c20", "format2_vector": "nv_list_null_fields_elem_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -358,7 +358,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_array_rows3_f0", "format1_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a", - "format2_hash": "0000025a437237556cf10c3516943f8c8137cd48a52cf16b1777262a0e36a2ec646c80", + "format2_hash": "00000281e68cbc71271d8bd4bd49ca0b4fc06ed9ee14d0a9b89e94c7b4d7f57a765fc2", "format2_vector": "nv_array_rows3_f0", "format1_defects": [ "nullable_struct" @@ -368,7 +368,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "nv_array_rows2_f0", "format1_hash": "0000015797829374325d96463f52c24c6d2749c861585b7c77914b431971dead0d861a", - "format2_hash": "000002e38a3d717443a885dd50d9f3cdf22d7cb1c69fa194a64a4168a384a7406e80e1", + "format2_hash": "0000026377ee1c5f0cf836051940feae161f2a199af2b37aa1fd0fe74c8c5debca90c5", "format2_vector": "nv_array_rows2_f0", "format1_defects": [] }, @@ -376,7 +376,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "phys_dict_rb_f0", "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", - "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", "format2_vector": "phys_dict_rb_f0", "format1_defects": [] }, @@ -384,7 +384,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "phys_utf8_rb_f0", "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", - "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", "format2_vector": "phys_utf8_rb_f0", "format1_defects": [] }, @@ -392,7 +392,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "phys_large_utf8_rb_f0", "format1_hash": "000001b20f5f8ba825da4b66187d9626335b6013ef9b2a6a7e4393ea877b9edcd7b66b", - "format2_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6", + "format2_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", "format2_vector": "phys_large_utf8_rb_f0", "format1_defects": [] }, @@ -400,7 +400,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "array_struct_xy_f0", "format1_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd", - "format2_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4", + "format2_hash": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456", "format2_vector": "array_struct_xy_f0", "format1_defects": [ "boolean_packing" @@ -410,7 +410,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "array_struct_yx_f0", "format1_hash": "0000014e329829b09545ca5b33545e37bb856b9e939568ed967b6dc7309674595ba0dd", - "format2_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4", + "format2_hash": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456", "format2_vector": "array_struct_yx_f0", "format1_defects": [ "boolean_packing" @@ -420,7 +420,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_1row_rb_f0", "format1_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31", - "format2_hash": "000002ef402ce172daaef8d7b354c4a1f733117057a2da38cd0c1ae5f1900e891c34d4", + "format2_hash": "0000026c3a344f7fcda6c51ee4bd97ecf4c3e6dc702ec2045323c52ad911534cff00ed", "format2_vector": "bool_1row_rb_f0", "format1_defects": [ "boolean_packing" @@ -430,7 +430,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_3rows_rb_f0", "format1_hash": "000001fdfad32e7d7dbc6dc064b22c955e4606083098ab660970559b57a58bab619a31", - "format2_hash": "0000024edc7f8dd7034021d850b6485a80dc9ab5867f804c6299ed3fd8c166989aea29", + "format2_hash": "000002c467967f693c01b3bbb0f924e190d94884dc5db908a61185960c78e69843bebb", "format2_vector": "bool_3rows_rb_f0", "format1_defects": [ "boolean_packing" @@ -440,7 +440,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_array_1_f0", "format1_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005", - "format2_hash": "0000026ff0c8a2aea22b471ee082f0f9e66f30f9994b09ea2d3623c1355daf7ae74e88", + "format2_hash": "000002dee12b05ca7ae8846ba2ee678edf4c2bebedea94bc4835a0530a76b7107cb2e2", "format2_vector": "bool_array_1_f0", "format1_defects": [ "boolean_packing" @@ -450,7 +450,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_array_2_f0", "format1_hash": "000001bfbf7b19b3c1de85d67ca1a1544c15adaf58ab9fe554ca2ad83967be3a24e005", - "format2_hash": "000002e7fd44616d2602d1ea7db25f770f0d4e0905f935b65c6ecd412b82fa7cf40121", + "format2_hash": "00000279d7cb82ab7366f2452bfd63a48e7750a32b174153e5c13fb80f2336adb2dbff", "format2_vector": "bool_array_2_f0", "format1_defects": [ "boolean_packing" @@ -460,7 +460,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_nullable_rb_f0", "format1_hash": "0000012374ef8a63a8cfe593283ae0336f8d9ea5a84c534655acd6eff15636812d388b", - "format2_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45", + "format2_hash": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92", "format2_vector": "bool_nullable_rb_f0", "format1_defects": [ "boolean_packing" @@ -470,7 +470,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "bool_nullable_stream_f0", "format1_hash": "000001185dc35a80c8f2e12d34ceaa7062f09b6edbba7131bd7298752debea7e9c9d04", - "format2_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45", + "format2_hash": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92", "format2_vector": "bool_nullable_stream_f0", "format1_defects": [ "boolean_packing" @@ -480,7 +480,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "names_schema_f0", "format1_hash": "00000158f3ffc55d1fb210829f8ac71f1b4a29f45e70b120217fd17df22abb0eca1a9b", - "format2_hash": "000002423c1e37af8c6fa77dbb0c8df920f6af969fd6398a804fc2656e73488c0102ab", + "format2_hash": "00000266430e24680d87a4279fd531bb8c02340f72b05682da212f5d525b0f7d3e147d", "format2_vector": "names_schema_f0", "format1_defects": [] }, @@ -488,7 +488,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "names_array_struct_f0", "format1_hash": "000001e445fa3cdc5fe37df7cb3de55cf94dcee2a8990bb8dd46fb5c3b00398f8cfb2c", - "format2_hash": "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728", + "format2_hash": "00000219e467d0280ccc83ad4c67e063997344cedd781f6cb4e449d03d713c989aa12b", "format2_vector": "names_array_struct_f0", "format1_defects": [] }, @@ -496,7 +496,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "names_array_struct_int8_f0", "format1_hash": "000001e131c1f05f488566a32e4d387451a8998a54d2207416681782e7a2c0ff3affa9", - "format2_hash": "0000029bdeaab1cdeabaffbe83de8f6bc0f2b4698050d17d47ed3707705c490a3ca11e", + "format2_hash": "000002360ce1cbd543917fa1444b88470e60303ba415e829d29754bdc20d1f9be2c4a0", "format2_vector": "names_array_struct_int8_f0", "format1_defects": [] }, @@ -504,7 +504,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "fsl_int_schema_f0", "format1_hash": "000001faa6e75b09b2788440c79a1e297c73c75a5cb4d36c9f9cad6e3062a33c91c696", - "format2_hash": "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc", + "format2_hash": "0000022fe3f8d8fcba7e393f3c5808894db2f930a8bd8388e9d04b3763d369cc6eae88", "format2_vector": "fsl_int_schema_f0", "format1_defects": [] }, @@ -512,7 +512,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "list_kv_ab_rb_f0", "format1_hash": "000001622d311ff5b38c734946fffc9088f1dc99bfe8e0cb04ccfda0e420aa8914f4dd", - "format2_hash": "000002a83e96153c214d6ed310666a91cc8c9e2dc8d885e8ef29eaa6d2fa3d2dee00b9", + "format2_hash": "000002fcc4a6000e54c88f15ce378526d2aaeb6257909dcda76889744ad3fe18e3d5e1", "format2_vector": "list_kv_ab_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -522,7 +522,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "list_kv_ba_rb_f0", "format1_hash": "0000015dd41853de5c821a2f13436e7d1886bb606be477024b795d0993cf00f55df2b5", - "format2_hash": "00000247a75ef3e08557f7535e36cdc15aa9da00acd0e4c7d776c4758f9297c8ed2b06", + "format2_hash": "0000024f30d74a4ecc5859895de78ae95fae3802012a4d6f1bd287c18dda362d11d54a", "format2_vector": "list_kv_ba_rb_f0", "format1_defects": [ "list_of_nullable_struct" @@ -532,7 +532,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_null_schema_f0", "format1_hash": "000001450e51629d5bf2b2ef7ab0639e64238f7598446f0dbd0716e3d7f4b64b8c640c", - "format2_hash": "000002d62f819d0655f1ca1c0fb2709da2c2e21f3ab1593a405c1063e2dcc22fa10af5", + "format2_hash": "000002ae91ac257762841aed12f8986a96ea10072d2e4573bb2cda0862d002bbe4e3b4", "format2_vector": "type_null_schema_f0", "format1_defects": [] }, @@ -540,7 +540,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_boolean_schema_f0", "format1_hash": "000001f9913189cc32c79fb14c307c8eef776bfe6a5ac40a7ccc49a0461b5ee557e0d1", - "format2_hash": "000002bf1bb213a02678908892fe2ad319eb1805155337f8f72fc3266eaf99617183f2", + "format2_hash": "000002013cdd44a14ee692b7d98d8909d5e2230a0b0375f03e2f1d64c51518567393d5", "format2_vector": "type_boolean_schema_f0", "format1_defects": [] }, @@ -548,7 +548,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_int8_schema_f0", "format1_hash": "0000012b83e283d49b73e9069da9861fc1741adb391ce8f592220935a64344ada102a8", - "format2_hash": "000002f2b11ea2df5836e3377ba522c83e8d4796b76e6b9af836c908eb97ca1d9c9ee9", + "format2_hash": "000002e8fa19e1f3e0f9ab96f3c77cfbe1b8a2eb42f0e41af3f9b61c76fd894636e82a", "format2_vector": "type_int8_schema_f0", "format1_defects": [] }, @@ -556,7 +556,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_int16_schema_f0", "format1_hash": "000001880d3e13346e5b9ee77784fc268e1627cf77e8b3411e11b46f6454c3510e381e", - "format2_hash": "000002fc7961c4b03e7a2a604e0c653b487b48b1bd13b2e2bfa616625ccd54d4380e04", + "format2_hash": "0000028103d67a1b84d9305488727baf6a5f9662278a49cfccda2c441a9f6fca337cfe", "format2_vector": "type_int16_schema_f0", "format1_defects": [] }, @@ -564,7 +564,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_int32_schema_f0", "format1_hash": "00000127e2d4e9ff00877d5f7d23ed3881633983fc7aef3b006a96fedb859d128c3989", - "format2_hash": "000002f48ea32296b9c2e0cf348606101abdc2dbc4a3101cce917da7fec025241b46ac", + "format2_hash": "0000021ce5d36566850439ffb338c1e4c5aae756e8250ffe681803328c75951f55914a", "format2_vector": "type_int32_schema_f0", "format1_defects": [] }, @@ -572,7 +572,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_int64_schema_f0", "format1_hash": "000001b025613f15b5f393a4989ef73a15771a1102a55ef411a4b632aabade82a3d01b", - "format2_hash": "0000027a23f6870e469f67974b74770c0c4256977e36c80f4142071129c786faaeb546", + "format2_hash": "000002b4753897cdef0036ac4ae0397dd4de049e0644effb0acad9bd5c57ea606f7c7e", "format2_vector": "type_int64_schema_f0", "format1_defects": [] }, @@ -580,7 +580,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_uint8_schema_f0", "format1_hash": "00000100824cb9155025aae789d5dd0df53c9c16c88deb0972fc9b1e863c39ec55acbd", - "format2_hash": "000002a5e423efe3ddad13f6c9d3da7093f44a9336879531fe36db98772ce70a23fc10", + "format2_hash": "000002722f2dbfd37702f6d2b38b5ee134eaa4d8d0c473f26a6fa9c9accdf5ff738bf0", "format2_vector": "type_uint8_schema_f0", "format1_defects": [] }, @@ -588,7 +588,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_uint16_schema_f0", "format1_hash": "000001b0f78a84d6b3598e5526341cd4f4570bc0ec6e98718f4d5249b851c6152eabc7", - "format2_hash": "00000216568c9ca5484137a316794c1af7741ba2054d2352e728f2f260f5d27ca696b4", + "format2_hash": "000002ac3e91bd728f7101209ba7cda9f99e9ba4bdbdae19a7ec52a945377246041842", "format2_vector": "type_uint16_schema_f0", "format1_defects": [] }, @@ -596,7 +596,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_uint32_schema_f0", "format1_hash": "000001351c5bba858bc19d1b0e76c645616c137ab578e680a168263de0c183d881ebfe", - "format2_hash": "0000023cbc740e1382c5c1b0c5d6c4f8700c3c3fc38aa1e027f7332850987a53622f65", + "format2_hash": "000002bdf9bea09e68f1e94c2903c635806055578a8e959f674ebb5fcc91d2950299cf", "format2_vector": "type_uint32_schema_f0", "format1_defects": [] }, @@ -604,7 +604,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_uint64_schema_f0", "format1_hash": "0000013f0e525838f78941dd7ebf1cf53a38aab1ce76083120f046e3c7d5d3a1d36674", - "format2_hash": "000002b338597d9c1f743d2b822b3ed4632632596ccadcc3dd63a3c34a8c4750b2adad", + "format2_hash": "0000029d53ed8a06173c17c1d5c3ac7c05e664906f4c38705b6d42531535b85516196a", "format2_vector": "type_uint64_schema_f0", "format1_defects": [] }, @@ -612,7 +612,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_float16_schema_f0", "format1_hash": "0000014da58ec28052f47317cbc02b5af025698cb2c541ca0c0296a0f37098e1bc8393", - "format2_hash": "000002d594fa2f108350ff54de3b6c52c9aaf7e0205a9470db2431963052029c704557", + "format2_hash": "000002fe84148cb5b19a35c8d7f0f74fb999dfbe73b39eb9d175acc56a68496bcae3c9", "format2_vector": "type_float16_schema_f0", "format1_defects": [] }, @@ -620,7 +620,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_float32_schema_f0", "format1_hash": "000001b79ddc004ecda1cacf1ca4129c9339f87231e38b3feb324f37505fbb00448261", - "format2_hash": "0000020f83fab9cf3e29428d8a06c8ebf814ad97179430798696eca196deddd5785e64", + "format2_hash": "000002cd80a7aa2d0d65df7a9b49fd4553e7810379df991305ec129049e3706dd27490", "format2_vector": "type_float32_schema_f0", "format1_defects": [] }, @@ -628,7 +628,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_float64_schema_f0", "format1_hash": "0000018a4b885963f8e74a322a01627a43ace66eff8b29f9bffaae78d75026d6c338f0", - "format2_hash": "0000028212ede094399bb7b21174e93890d671bcd092a21bbf13a7699f45e635ab6b85", + "format2_hash": "000002603514e8bc5a8e579d7fdb7e06bb05a7eaebaf38f91f474e2844dd34cdaa0747", "format2_vector": "type_float64_schema_f0", "format1_defects": [] }, @@ -636,7 +636,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_date32_schema_f0", "format1_hash": "0000017067a187a25f7004d66cca4b06e7e3e319f7f71288a9fc42df603f092b6c7f4b", - "format2_hash": "0000024e1f6ad045cfba15f60e1d2e5f48194091885c578a9772e49fb108a8c53c3edd", + "format2_hash": "00000202c0525336a81e428a90c726eb51a62bd8753aa055f0aad2df8b472e42f2b5dd", "format2_vector": "type_date32_schema_f0", "format1_defects": [] }, @@ -644,7 +644,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_date64_schema_f0", "format1_hash": "000001eafdd4283792f22e1655bf61378bdc53de9f32d3b34cba20ee33349b6d215d27", - "format2_hash": "00000247f383c084cb2540482ef193d29b2797cbfdc00647d0149bba4abf15b9d5e51d", + "format2_hash": "000002fedf19b8af467ee7acec8f738218feab196b07826821198b909bc82537e8f924", "format2_vector": "type_date64_schema_f0", "format1_defects": [] }, @@ -652,7 +652,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_time32_s_schema_f0", "format1_hash": "000001fedd3327155f022a4dd129ad3ed5afca9999f932498d991cc8efbb8e020052a2", - "format2_hash": "000002ba4c1ac02ac91418da73d12294a484feda0527423664c059676c605847d6c18c", + "format2_hash": "000002fa87e7ebb1972366c69da6e6656c5ae10c89906a9110bfb2764346f0b49c5228", "format2_vector": "type_time32_s_schema_f0", "format1_defects": [] }, @@ -660,7 +660,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_time32_ms_schema_f0", "format1_hash": "000001c2e1de3bcbf6a5a5faaec60dce7c65c5124061f0ccb97e7ef165a17a42b2fc4b", - "format2_hash": "00000240cb860fa8c49f36e13149eafe5e45bdae2c2f9be6fe6a571e85a76ddc223dd2", + "format2_hash": "000002e83f805720c95bd9f74201cea503c4a2b489dc84dc04dc1826aa81331cc774d1", "format2_vector": "type_time32_ms_schema_f0", "format1_defects": [] }, @@ -668,7 +668,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_time64_us_schema_f0", "format1_hash": "000001228968561050acaeb788b5475feba508a6ea8234768429d0671bf0e62d58d71b", - "format2_hash": "000002a084f937c053322ca9690f6c1a40dd1675d7c010730c9fdcefa1911a5c6314a6", + "format2_hash": "000002d4b6344eb6e36da5864993f7884283fd9d5f81e2b5e2bf2ef7942beb98d41e9b", "format2_vector": "type_time64_us_schema_f0", "format1_defects": [] }, @@ -676,7 +676,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_time64_ns_schema_f0", "format1_hash": "0000018b7675631dcdbdaf3dfa91e3f3286f7211cf2193dcae672411b09afe4050fe59", - "format2_hash": "0000029d6c2cda4d46a9522b83168856482f149953428bd0f51b08384b764f198424af", + "format2_hash": "000002c3d16ff0a20bd9e420a4a851018bb2e445ab4ae8973902b331a6312741ed7559", "format2_vector": "type_time64_ns_schema_f0", "format1_defects": [] }, @@ -684,7 +684,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_timestamp_s_naive_schema_f0", "format1_hash": "0000019fe4c7746047294fd6a07264648cedf7f0e64f08a644d779c852d270dde089db", - "format2_hash": "000002410b6c31dbac2fabdb5893cf393be0fd7ce3ac603fa592b858608ba3582881ee", + "format2_hash": "000002a0bc2bf04f37e9838f02f8f948619c298300b9a8c0ed90a2d4aaa80627fa6209", "format2_vector": "type_timestamp_s_naive_schema_f0", "format1_defects": [] }, @@ -692,7 +692,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_timestamp_ms_utc_schema_f0", "format1_hash": "00000196d90de77d3557403eb475d0f0d64774319117987aa1c588115c455666c597b5", - "format2_hash": "000002baca673fe3de658299ed83026512cf3980dd2c323a3fb9e304a206bbb9efe632", + "format2_hash": "000002f5a5aaa5002a1db4a752adf89927683d31f2896bd795cbb4385434051f5cc1c7", "format2_vector": "type_timestamp_ms_utc_schema_f0", "format1_defects": [] }, @@ -700,7 +700,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_timestamp_us_offset_schema_f0", "format1_hash": "000001c87d3b92444ee5a6b5e4e2f3bc098236ba7bcc9524ffe6e58cd012c3092bb922", - "format2_hash": "000002a63969413486c42e01fb9638f418f943b1e2749df379401a6db6174ece6c1bbd", + "format2_hash": "000002a8e4e8a46be0e1eee3876ae9f8996463c26f2020f36bd02dd5d15d063b9517cc", "format2_vector": "type_timestamp_us_offset_schema_f0", "format1_defects": [] }, @@ -708,7 +708,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_timestamp_ns_named_tz_schema_f0", "format1_hash": "000001940af673c638fc1ff9aefe02078d47ad1713ba21d3916a1a87bdb0ead51afc5e", - "format2_hash": "00000292879787e87c84632b13219bebcde6c59ed735eb58044f3d7df937ffcb234a9d", + "format2_hash": "00000257560dd4115945bb73829a8b42eb50c91441221b153e8e8af9cc741a98a1a9d2", "format2_vector": "type_timestamp_ns_named_tz_schema_f0", "format1_defects": [] }, @@ -716,7 +716,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_duration_s_schema_f0", "format1_hash": "0000019ef92ec048bd73719517bcdd78f1a52e57dd8d3ebbba8c3dbe689bf3473c8454", - "format2_hash": "000002c326fa8a3ae288735a556905748c1db265771accb49a63570baf1e9d8547911f", + "format2_hash": "000002e37ba68db00a13fda1269115c93112e82f47e0001954736e0dbac6ec0478529a", "format2_vector": "type_duration_s_schema_f0", "format1_defects": [] }, @@ -724,7 +724,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_duration_ms_schema_f0", "format1_hash": "0000015f844828d2b1cf182199ab026ac2903425f0f84898befe53f53b38a8468ae257", - "format2_hash": "000002b9bcfd0c6c9e97f81abe2b49da844b275f8712c81f8281b86e9943b3588c1aeb", + "format2_hash": "000002deafca82c59e247745cff3aa1be6df4f079b034bb74688a2941d8bd9a8eb43d1", "format2_vector": "type_duration_ms_schema_f0", "format1_defects": [] }, @@ -732,7 +732,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_duration_us_schema_f0", "format1_hash": "000001bc8e82b752d5d898ae332e360b8325e742b6d7359b6b6aed59ff21578b53141e", - "format2_hash": "000002325457512731593cd507ce3e7b011b9b7cca01dbd89e4f8920fb5994cf1d9d4a", + "format2_hash": "000002da4cfb6ead4c47fb7f40c73df8ba0ccf616d931461f48dadfb5a018772576078", "format2_vector": "type_duration_us_schema_f0", "format1_defects": [] }, @@ -740,7 +740,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_duration_ns_schema_f0", "format1_hash": "000001e881ee30b58bdaa77fbc333e13eb21a00d3ca4e96283f1eeb4062fb29995352f", - "format2_hash": "000002b73ed03cd62dd09e683c4059fbc97b46a742744f8720fb82aab81773efd787f1", + "format2_hash": "0000021140c59d69e5aff07c4c9fb5acede1eb2f93529ed40b42ea04d1fd873764be0d", "format2_vector": "type_duration_ns_schema_f0", "format1_defects": [] }, @@ -748,7 +748,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_interval_year_month_schema_f0", "format1_hash": "000001edfdb7dd18d6d1f1726bd0a820e82c13ba013ca920bd3d93d08530782119785b", - "format2_hash": "0000027209e6136116fc005f13f750a66837a8452c92912e147a54904f45255a18a1d3", + "format2_hash": "00000244ddd18aa817bdda2931252ba87319aaebce9b5bd9ac1400f3bff958e6bfa92c", "format2_vector": "type_interval_year_month_schema_f0", "format1_defects": [] }, @@ -756,7 +756,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_interval_day_time_schema_f0", "format1_hash": "000001ff900d6b57d11a3aed395b0a882a0cdf411450df8a497826e4cbdad57a41217f", - "format2_hash": "0000023aed3f6ad5f34d87f903ffb78bd76b8f289a61f8b60ee7902d9b981bbcc804c0", + "format2_hash": "000002d9e806587afcff2f7bf1e5bad572696f5fbfdb9ebf18813466549327b8d51211", "format2_vector": "type_interval_day_time_schema_f0", "format1_defects": [] }, @@ -764,7 +764,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_interval_month_day_nano_schema_f0", "format1_hash": "000001b8ebd94791c839fcf2572f1abfe6584d39ff559624dc3362f6ff6a9b43bfd9b7", - "format2_hash": "000002a1ef89129cd30cf70f293c654a4f430bb84831156a0e26a82e2ce3b585a36297", + "format2_hash": "000002e8eb312e375f9c65f3b3d0d029b19f0eb41821c5efeca2a59c9e17a287a0d83b", "format2_vector": "type_interval_month_day_nano_schema_f0", "format1_defects": [] }, @@ -772,7 +772,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_decimal32_schema_f0", "format1_hash": "000001dd88bf3c39e96145f03d8fc9054089eb4dd8c437d74b1d4aa1b25b8e351e5c75", - "format2_hash": "000002dd15d65f2ad53b58d6f4275e9e02284c6b2b85a9bcfd57c9329d3378fe01b916", + "format2_hash": "00000227ac504a2ceb17222240736fabb8a9bc473adf914921def7d552f85d324326f7", "format2_vector": "type_decimal32_schema_f0", "format1_defects": [] }, @@ -780,7 +780,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_decimal64_negative_scale_schema_f0", "format1_hash": "000001e16e0018ba784be83994c7a94db3071ab9c5462566161105d4ef8128105ed816", - "format2_hash": "0000020b8bd50d5e34cc66422d123c8ecad9985eaa5aab934706793d797b10ffdd7ef1", + "format2_hash": "0000025307a5443dbf29dde69b92ea0a4cb4dd4edec402ab3f21f3757ca21ffb6f0ef4", "format2_vector": "type_decimal64_negative_scale_schema_f0", "format1_defects": [] }, @@ -788,7 +788,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_decimal128_schema_f0", "format1_hash": "000001ebcc3afc437ac2f831005f29907440ae6d08ab647a04f974be15d44951326683", - "format2_hash": "00000230a8ad8ccebbb0f61cf11f600222fe8afda9bb33bb883b3a1dcbffd691626e83", + "format2_hash": "00000265fcc9e37a235725f68d94bd5a384603416c4893ca8c7e68f1b24cabb2a10f99", "format2_vector": "type_decimal128_schema_f0", "format1_defects": [] }, @@ -796,7 +796,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_decimal256_schema_f0", "format1_hash": "0000017bf47db10e1322b3ebd6780afe01406dd3680654a3b77133f8139ebd4c987e04", - "format2_hash": "000002adaac773e79c05738edbf6511ca2e2b78e5fbca6ed34ce50cb30dd50638e3437", + "format2_hash": "000002fb41d9fcaf8a1e416d559fa0b0c066e578dbb3ab5056732559faceba7c12d205", "format2_vector": "type_decimal256_schema_f0", "format1_defects": [] }, @@ -804,7 +804,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_fixed_size_binary_schema_f0", "format1_hash": "000001a1ed63688a1bfef27f1bb08ffbc85de0edc469fc74ca4a78b89d524c1524eaa4", - "format2_hash": "000002d7bb11b6df9b80954e3fd4bff19842697682f2092bd518e7866b51c4d82fab54", + "format2_hash": "000002f72c04377c44ba38abf0fc2b04cad73a66d97c290985810b594759b39e0e0751", "format2_vector": "type_fixed_size_binary_schema_f0", "format1_defects": [] }, @@ -812,7 +812,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_utf8_schema_f0", "format1_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8", - "format2_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3", + "format2_hash": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66", "format2_vector": "type_utf8_schema_f0", "format1_defects": [] }, @@ -820,7 +820,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_large_utf8_schema_f0", "format1_hash": "000001a3d7da25cd2184dbb26c33361e651f15494198c62c060256714159fe9ff0b5f8", - "format2_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3", + "format2_hash": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66", "format2_vector": "type_large_utf8_schema_f0", "format1_defects": [] }, @@ -828,7 +828,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_binary_schema_f0", "format1_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5", - "format2_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e", + "format2_hash": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8", "format2_vector": "type_binary_schema_f0", "format1_defects": [] }, @@ -836,7 +836,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_large_binary_schema_f0", "format1_hash": "000001551df4389549b007c7e698ab71bddf84a9946cdf127716abc37606b3a8911da5", - "format2_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e", + "format2_hash": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8", "format2_vector": "type_large_binary_schema_f0", "format1_defects": [] }, @@ -844,7 +844,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_utf8_view_schema_f0", "format1_hash": "000001c4f113df591f75ffe79c1da85c5000f0ade80eae214b97713872cab348800aa7", - "format2_hash": "00000227b6c1c19f55abb8f9c5397c44358179670b53e8cd0ac85c86a63efc077d3a45", + "format2_hash": "000002ae4524ad2af645eab4f9c6d0909c9361fd5b25f4381b6ef31aaf1edfcedf9ddf", "format2_vector": "type_utf8_view_schema_f0", "format1_defects": [] }, @@ -852,7 +852,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "type_binary_view_schema_f0", "format1_hash": "000001d212dca06f49287359b6359167ac3cc02782572c4463bb552297ae03a347b856", - "format2_hash": "00000269474d2dcf14686b5e68081944c59dd48e9723ec46045ef79de008d9ee75a565", + "format2_hash": "000002f66721c03015a7ef24bb7d084e984c2e4e7e1246e9573dcbf0ef0819f3f0abd8", "format2_vector": "type_binary_view_schema_f0", "format1_defects": [] }, @@ -860,7 +860,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_map_value_schema_f0_im1", "format1_hash": "0000018e90e39f63cff9891fa1536def277ab7c2545567c51cecf37e765e75f0609789", - "format2_hash": "000002f2ccfa54107bbf578a64ac6f09bf31d7c5eaab288c3b7003f8c0135d83928694", + "format2_hash": "000002e72a6e74a24550cd50f142e754901f4bd7aa2fbaf801ae1d8c1c7dbb49d6b83e", "format2_vector": "meta_map_value_schema_f0_im1", "format1_defects": [] }, @@ -868,7 +868,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_map_key_schema_f0_im1", "format1_hash": "00000197b0e3e6528d52a065864a687be4a19b4197dfb62a4ca9915c6b7d3e6bd31ee7", - "format2_hash": "000002b509290043f950377512a8c5d20d712ae470307a40f7be188e2acc048d52a444", + "format2_hash": "0000025e79da0f495b82e17ec4f2a2fdf191a6f92357073a0232f0f55ad7014b1401f6", "format2_vector": "meta_map_key_schema_f0_im1", "format1_defects": [] }, @@ -876,7 +876,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_map_entries_schema_f0_im1", "format1_hash": "00000138559b12d08a2cd6fc073ad2f98a22d75737b580905227d99207851c25e89951", - "format2_hash": "000002a2ea4c3e7aac3494e11cb4a863c257897c6fe24338111019718bb80f191e8f69", + "format2_hash": "000002e30b27b07b6518a7f089c4564e0bbdf34f6e566e83579764e8fc4873156b34c3", "format2_vector": "meta_map_entries_schema_f0_im1", "format1_defects": [] }, @@ -884,7 +884,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_map_all_schema_f0_im1", "format1_hash": "0000017f5cbc6a8a7a9e6f8b06fdb33a8689f413b5034a80e41451cc7d3e50d648dbaf", - "format2_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727", + "format2_hash": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a", "format2_vector": "meta_map_all_schema_f0_im1", "format1_defects": [] }, @@ -892,7 +892,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_struct_child_schema_f0_im1", "format1_hash": "0000013ad8bf07377e7c14cdf271b6626b203a28f2295391ef0e9ac21d40d99bd0473a", - "format2_hash": "0000021bad8bde5a431b6ffdc4b426a99a2a753e1f877876bfa4f0dcfe6acd8380d258", + "format2_hash": "000002f99bf8ec8a139a00a36a06178b72829b3cd4b5200576b48c8a8f7dc1ef5f00f3", "format2_vector": "meta_struct_child_schema_f0_im1", "format1_defects": [] }, @@ -900,7 +900,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_list_element_schema_f0_im1", "format1_hash": "00000138cb63f6c736f44536dbc3c1cef7a81d6caa89a68a35db9ef4fcb04a82cfe91f", - "format2_hash": "0000022aa3f2d31d47e16368a06eef1caf2733b78453a3de28ee37db44e63f68ef0deb", + "format2_hash": "00000277f78b5887bf2face0b85767b991be1ce3da47b1cc4d1cdc334829087f4f1a8f", "format2_vector": "meta_list_element_schema_f0_im1", "format1_defects": [] }, @@ -908,7 +908,7 @@ "source": "released starfix 0.4.0 crate (reference vectors)", "id": "meta_fsl_element_schema_f0_im1", "format1_hash": "00000167f097bbffcd5ab67297252711a30106996ce8d0d7940e91ceab68b69c07023a", - "format2_hash": "0000023e3eb301b7a8196190729dcec01c5456493177faef4790e9433a61796acc78ce", + "format2_hash": "00000253583e73e2411cdfe9480e8ce880911d8b4d8fd64a190df43e5bcfe05dc31a0f", "format2_vector": "meta_fsl_element_schema_f0_im1", "format1_defects": [] }, @@ -916,639 +916,639 @@ "source": "tests/arrow_digester.rs", "id": "binary_array_hashing", "format1_hash": "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57", - "format2_hash": "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" + "format2_hash": "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" }, { "source": "tests/arrow_digester.rs", "id": "boolean_array_hashing", "format1_hash": "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b", - "format2_hash": "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" + "format2_hash": "0000024c5223c9cdc2fe10fb4362890cfc763e1bea4829a30fa6bfedc7bacad05f783a" }, { "source": "tests/arrow_digester.rs", "id": "decimal_array_hashing", "format1_hash": "0000014f015bd5c4b6ce6e939a8c890333f3e110c2c28ef8014aafd352f8373791e547", - "format2_hash": "000002e83147c84038cb72cb3cc8e24e651e0491028c449cfe7f2a9d51ded84391ca40" + "format2_hash": "0000021480fe62da952e0f819540738817488f0da864a59e70604f88f00f6daec3a7fb" }, { "source": "tests/arrow_digester.rs", "id": "duration_array_hashing", "format1_hash": "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa", - "format2_hash": "000002f4db00404adc309eaa3c23518b36b56a44659edc0a4c4dbbddea90449cf90413" + "format2_hash": "000002ac73fa834511e4de143e7f5da1f2b6bef168f25a6d47f7851dd977328eaf20cc" }, { "source": "tests/arrow_digester.rs", "id": "int32_array_hashing", "format1_hash": "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138", - "format2_hash": "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" + "format2_hash": "00000264c8fe45cb550e25577276b2af8c1c9c125bc14b8439f5619c1f18c71d4d0078" }, { "source": "tests/arrow_digester.rs", "id": "list_array_hashing", "format1_hash": "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c", - "format2_hash": "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" + "format2_hash": "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" }, { "source": "tests/arrow_digester.rs", "id": "record_batch_hashing", "format1_hash": "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0", - "format2_hash": "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" + "format2_hash": "0000020ba4ed542e67ebc311d160ab54a11f25630a6b5fdd99e5dfc90917cb1d31e968" }, { "source": "tests/arrow_digester.rs", "id": "schema", "format1_hash": "0000012ac1decf89ab7e337d5df56bafd330f7e9a761953c58c39d5a3a8c49f6dfd4ff", - "format2_hash": "000002b4d7f0bc024ebf3eed85a31c1168c1f3cf60d88adf54e912550cf907af25db94" + "format2_hash": "000002951008748ed8a893f5ea7b6506d3ea8cb8be815956cbdf5ea330ae6a11f49519" }, { "source": "tests/arrow_digester.rs", "id": "string_array_hashing", "format1_hash": "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c", - "format2_hash": "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + "format2_hash": "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" }, { "source": "tests/arrow_digester.rs", "id": "time32_array_hashing", "format1_hash": "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc", - "format2_hash": "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" + "format2_hash": "0000026708f2d0b632bf3f324716cd32c7c41dd8b9bc75d326fb5ec3f3900201f08eb7" }, { "source": "tests/arrow_digester.rs", "id": "time64_array_hashing", "format1_hash": "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26", - "format2_hash": "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" + "format2_hash": "0000022ddc0ab9c1cfc0fda9353d66612a504cb63d6ee509c4f56b961f33855f1a82a4" }, { "source": "tests/arrow_digester.rs", "id": "timestamp_array_hashing", "format1_hash": "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b", - "format2_hash": "00000252859a0dad006bac78dd1ba3fa17fde43bfa2af9cc95bdd08b6611da1691f012" + "format2_hash": "00000255a8e82e6e1862a461c70c393f105522ee7fd6f4ed889fd69d21ace4bb54622e" }, { "source": "tests/arrow_digester.rs", - "id": "decimal_array_hashing", + "id": "decimal_array_hashing#2", "format1_hash": "000001dc08c7b9c583edecec36bc5dee21cd2edec9f402a651014fea5f8834d16ad737", - "format2_hash": "00000226d3b5c66b1fa3b3de097542369f89b2717f3026c778ce17d57817fbf2fec8f0" + "format2_hash": "000002efb97088aa7fc1adc578e6d68d0f2d2dbe5ef25b0999fcd7e7208ede6e7b2a41" }, { "source": "tests/arrow_digester.rs", - "id": "duration_array_hashing", + "id": "duration_array_hashing#2", "format1_hash": "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c", - "format2_hash": "000002767dcb630f550d41da343f63fb308d1e2ce97e68306f988573178da666fb156f" + "format2_hash": "000002cfc3e82b4f82cf9a39f2f86fb495acb6f481b91643bd8f5591a2ed34f794ee9a" }, { "source": "tests/arrow_digester.rs", - "id": "schema", + "id": "schema#2", "format1_hash": "0000011d2c77a01beb74029cb2a71fe52eac4ac3ef7b31b55df717fc8098dee73735cf", - "format2_hash": "000002b32e24cda163bcece18d19af32944a15142b99880e14a6552aab28c1da84e858" + "format2_hash": "000002808e6baa50d385bb8fc28d1a63b5eab6de57d73929e68f33d6422e2989d0a2a2" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#2", "format1_hash": "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5", - "format2_hash": "000002f6dcd4d91471e975d86257785c15f0d8e120a84b45f163378e913d10935f1ec9" + "format2_hash": "0000026b928249c5b3e8a99fff770aa7cff273da347a8dd5ee5c1647e7a03b41aeeac5" }, { "source": "tests/arrow_digester.rs", - "id": "decimal_array_hashing", + "id": "decimal_array_hashing#3", "format1_hash": "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e", - "format2_hash": "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" + "format2_hash": "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" }, { "source": "tests/arrow_digester.rs", - "id": "duration_array_hashing", + "id": "duration_array_hashing#3", "format1_hash": "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a", - "format2_hash": "00000267a46b80b8577b61b24e665edbe71f78d6af7170305cbe0b348ca07a1b2874d9" + "format2_hash": "0000022c8e105be42590d0cd332abcf8330269689cf66767322d1ba799271c6346744d" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#3", "format1_hash": "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e", - "format2_hash": "00000209c1c989349caa973563a880521cbcaaa4e62ccc77f380e69f0fc57c639b4bfa" + "format2_hash": "0000023277d54aec4f229bfd0f21e772c332d2d4851c8af07b3f36be29f655b91b6b48" }, { "source": "tests/arrow_digester.rs", - "id": "duration_array_hashing", + "id": "duration_array_hashing#4", "format1_hash": "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b", - "format2_hash": "00000265d49688aae1ade659148d969f4fd703fa688fd7e3dcbe3c00d5e7ef2ae50720" + "format2_hash": "00000257be9b6546267351273ab5c9bd7858c17b17b093f7f65a599bad8bde37ab5c9e" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#4", "format1_hash": "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0", - "format2_hash": "0000021d86082dfda0e2f0449320c2acd853756d79dc3080cf1ee14327c7c9f2201480" + "format2_hash": "0000022d542c28b882c3e78bd1758a04c628c829efb9c16e78ad4185cd97e45544e988" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#5", "format1_hash": "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30", - "format2_hash": "0000028fa5d6fbc775327e0c766cab77a00991dc87cf7ac7d45f875d049559b55cbb3e" + "format2_hash": "00000219b77ac863025bc3a0c519594e873846eaed63ed9d7c16763ad9eb36016623ed" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#6", "format1_hash": "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842", - "format2_hash": "000002c0d0e86c4e7ff759ad83bf887cf5b20f2b662ceeeba5865ed1f5353b6b7a9445" + "format2_hash": "000002973baeb308b246159206a6072825f4cb786d05ddff11649199c93df22abdaac7" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#7", "format1_hash": "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3", - "format2_hash": "000002148a265e62ae6878931d8d3316c4aec43f50da2e688d83bfe62901c3703e6b4f" + "format2_hash": "000002fe90da5f713e78f96eed1bf834e6fe2f871aa2c7f28174d8a2dcb3134f5dc4cc" }, { "source": "tests/arrow_digester.rs", - "id": "timestamp_array_hashing", + "id": "timestamp_array_hashing#8", "format1_hash": "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796", - "format2_hash": "00000292c1b50fa17e537e6afb5903cce37b5b28b03088e6ec3e23c346d9adafb071a7" + "format2_hash": "00000275a347fae688071e8d3d94d6ff48800f3dbbd9d8fc629c871eb4e16dd3e59976" }, { "source": "src/arrow_digester_core.rs (raw digest, no prefix)", "id": "nested_fields", "format1_hash": "9b52ad7430dea81b35f14a04d828b2424080fbc210570081c6e6cb62b6566c42", - "format2_hash": "8038c003912adbecc339cd6b1c1e9a62f59dc68a684c00cc1b29cff72d193361" + "format2_hash": "e87004b857524cdf72c644487132ae03f113a88662ca6ac32d90ab1a4d0c0c58" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestTemporalTypes::test_date64", "format1_hash": "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb", - "format2_hash": "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8", + "format2_hash": "00000273f2b0aeedb498d6980083f025b8e0c07c74c57c9130aabfed2af1b31e5ee0af", "format2_vector": "pylit_testtemporaltypes_test_date64" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_schema_only", "format1_hash": "0000010e62b3f3317d25413b7a4dc6e7a8a6e7c73a73c513cdbe9f9b1f5e5ec56f0e94", - "format2_hash": "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee", + "format2_hash": "00000221f1240fabe97f742ddb3195193cf785f61e327b7d64ec7363bbbce399df7e50", "format2_vector": "pylit_testmultitypebatch_test_multi_type_schema_only" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestMultiTypeBatch::test_multi_type_record_batch", "format1_hash": "0000010f8bb471cb34975f20c4b221abff1a90b2d98f24217a2257e3298ee3d4e9f9c4", - "format2_hash": "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce", + "format2_hash": "000002cb129d9295971fe47548a28b3070f18a4a000d449aa6e612446c37e7a104bdb2", "format2_vector": "pylit_testmultitypebatch_test_multi_type_record_batch" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_d_non_nullable_binary", "format1_hash": "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d", - "format2_hash": "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1", + "format2_hash": "0000020ee499da085a532f069ccfe218a9af0f2fa33ab8cc21b79991bdc36f5323f141", "format2_vector": "pylit_testspecexamples_test_example_d_non_nullable_binary" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestTemporalTypes::test_date32", "format1_hash": "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6", - "format2_hash": "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a", + "format2_hash": "00000248ddc5205e534b4a5dd91fb3ce5b5c4cddff659844e77de731435ab8eda086cc", "format2_vector": "pylit_testtemporaltypes_test_date32" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint8", "format1_hash": "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd", - "format2_hash": "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d", + "format2_hash": "000002f5401303c3c8609dde1c1162a0a5388183231ae9d7aad98a5165ca6cb949e474", "format2_vector": "pylit_testprimitivetypes_test_uint8" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestTemporalTypes::test_time64_nanoseconds", "format1_hash": "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f", - "format2_hash": "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1", + "format2_hash": "0000020ec4f4365fc43e57f5a229faf87d5e90dbe3ff53f64844c7bae443bb5c35bf07", "format2_vector": "pylit_testtemporaltypes_test_time64_nanoseconds" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint16", "format1_hash": "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357", - "format2_hash": "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc", + "format2_hash": "0000023c4a18350b71b2498685b732bf86aafa7edc9b6aea24de50e6a764cb4f0a8ec6", "format2_vector": "pylit_testprimitivetypes_test_uint16" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint64", "format1_hash": "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b", - "format2_hash": "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a", + "format2_hash": "000002bab5700cfdadfbc1a63b32bbab4c8154ad9696f024e6965266b10714d18ba772", "format2_vector": "pylit_testprimitivetypes_test_uint64" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestStructTypes::test_struct_with_nullable_children", "format1_hash": "0000015f1992c5f9130aaa64aa1360e53ddd00b427855ae02e380f534a629353135680", - "format2_hash": "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351", + "format2_hash": "00000223f577c71ad70b36baf8db3ae57304492642edeab6f98560180b624eb7127d40", "format2_vector": "pylit_teststructtypes_test_struct_with_nullable_children" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int16", "format1_hash": "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4", - "format2_hash": "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73", + "format2_hash": "0000021193e13fb74196a3ba1e2848d8b371cbaec0145408be4c10dce5c7da3d6f0ef8", "format2_vector": "pylit_testprimitivetypes_test_int16" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88", - "format2_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f", + "format2_hash": "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207", "format2_vector": "pylit_testspecexamples_test_example_a_two_column_table" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int64", "format1_hash": "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf", - "format2_hash": "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05", + "format2_hash": "00000273f6a64dd00ba1e2749c0ff21c64bb1984989efb7f94e37b188e6f0ea0ee3607", "format2_vector": "pylit_testprimitivetypes_test_int64" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_int8", "format1_hash": "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc", - "format2_hash": "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a", + "format2_hash": "0000024168dcfaf09c69c2fd848090fcff65c6e27c7a8575f419e6b5c011b28633c6ec", "format2_vector": "pylit_testprimitivetypes_test_int8" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_n_list_of_struct", "format1_hash": "0000019c9cc6230a42e646a475ec1c8125fe396dcace351d64ff6e63e8f53d329c4895", - "format2_hash": "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361", + "format2_hash": "000002a58f04b6bc45c95e5faa11155031bfb9dc8815187dde82b0f4d833cb8f376056", "format2_vector": "pylit_testspecexamples_test_example_n_list_of_struct" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestTemporalTypes::test_time32_milliseconds", "format1_hash": "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564", - "format2_hash": "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd", + "format2_hash": "0000028211097939067b80d7b9d622b88201aedc86254255f02f513e3acbf8da34e04a", "format2_vector": "pylit_testtemporaltypes_test_time32_milliseconds" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float64", "format1_hash": "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b", - "format2_hash": "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda", + "format2_hash": "000002f2dd5acce604d642d652fbbbc3bfb16807f36100aff5a84d1f6acb194e4d90e9", "format2_vector": "pylit_testprimitivetypes_test_float64" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_uint32", "format1_hash": "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e", - "format2_hash": "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389", + "format2_hash": "000002aa9b7f8fdea28a5651544e73648faa19f22b87912a4b18ec121df884a65e3440", "format2_vector": "pylit_testprimitivetypes_test_uint32" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_i_empty_table", "format1_hash": "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922", - "format2_hash": "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84", + "format2_hash": "0000028aa5ce23c0faa5de71df6c33cb88194f8555ce4c2ddf8398ebd15e7933081798", "format2_vector": "pylit_testspecexamples_test_example_i_empty_table" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_k_struct_column", "format1_hash": "000001e3516302d68fd1fc4860fa4b7e0d4a6d60d500a9d7ccae79e445c5980021e4ec", - "format2_hash": "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0", + "format2_hash": "000002b9461e7b30083397b2a328415184d53e8c27d315af89e22163aae5a0da91866a", "format2_vector": "pylit_testspecexamples_test_example_k_struct_column" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_o_nested_struct", "format1_hash": "000001e732b8458782d9a331722698883617eec7cd1492028947b4ce3e97c7d6201550", - "format2_hash": "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c", + "format2_hash": "000002ecebdb320ae446cd5347ec7cbff5272c36af957666f717c59df85cfd8410d5a4", "format2_vector": "pylit_testspecexamples_test_example_o_nested_struct" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_bool", "format1_hash": "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1", - "format2_hash": "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f", + "format2_hash": "000002b4fe586ae0a97fcc8ae84e83110f8980bde7c74aed4c66b60321116994982aeb", "format2_vector": "pylit_testprimitivetypes_test_bool" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_f_utf8_equivalence", "format1_hash": "000001f14d076ffc02533c6560f867b86cde7e15b1a0ac5a892b53697a609191cf307f", - "format2_hash": "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286", + "format2_hash": "000002644b2970be7606407afad7635d7f7111c2f668496e938bdff452604bd444065b", "format2_vector": "pylit_testspecexamples_test_example_f_utf8_equivalence" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestPrimitiveTypes::test_float32", "format1_hash": "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa", - "format2_hash": "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2", + "format2_hash": "00000279154d63290b405df71342d15c41dd9f288d5bd1dadae43f37950b85dcf74041", "format2_vector": "pylit_testprimitivetypes_test_float32" }, { "source": "starfix-python tests/test_golden_parity.py", "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_e_column_order_independence", "format1_hash": "000001f68bf6319f8ec4aa938e52dd911974348289fbdfb9b5ebed5e14e239a6d8a3a9", - "format2_hash": "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae", + "format2_hash": "00000201b7c533b770a31fd7bc0fefa6252c2fa7100305f07f991502437cc1a5ba1d24", "format2_vector": "pylit_testspecexamples_test_example_e_column_order_independence" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestBinaryVariedSizes::test_binary_varied_sizes", "format1_hash": "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05", - "format2_hash": "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1", + "format2_hash": "0000020885790654a7ce21e6afdfeaa4ad99490e1871149892eda8acf4d2a403566410", "format2_vector": "pylit_testbinaryvariedsizes_test_binary_varied_sizes" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_int32", "format1_hash": "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65", - "format2_hash": "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33", + "format2_hash": "000002a51121a9cb745bbcd08ebba07ce33ef64dcb630c241d4112d27d15106e3889d7", "format2_vector": "pylit_testallnullarrays_test_all_null_int32" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_hash_array", "format1_hash": "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc", - "format2_hash": "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa", + "format2_hash": "000002215978d8171df62a17e8b85524418ac182dc2b1f2132ab95b8a99922dfc9c725", "format2_vector": "pylit_testlistoflist_test_list_of_list_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListOfStruct::test_list_of_struct_hash_array", "format1_hash": "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626", - "format2_hash": "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2", + "format2_hash": "000002c1c713c7ee5c139a8799e83aff16049b6a6a935e3e3f8601e04db05c523e2d7b", "format2_vector": "pylit_testlistofstruct_test_list_of_struct_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_batch", "format1_hash": "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac", - "format2_hash": "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de", + "format2_hash": "000002e86fcf5b5a6b21b9f3f4a5f3eb6608c6e531ecabd95cbf365d01089d2a924619", "format2_vector": "pylit_testrealisticbatch_test_realistic_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestAllNullArrays::test_all_null_string", "format1_hash": "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070", - "format2_hash": "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc", + "format2_hash": "0000025a88292c68392ec7d5ac54666139cb4836c9267088dfabef093e7981c322df38", "format2_vector": "pylit_testallnullarrays_test_all_null_string" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_bool_false", "format1_hash": "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df", - "format2_hash": "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155", + "format2_hash": "0000023753cbe1173b2b0f1b81ce9de03a7c0a1ba1f5431dabbdbeef99172dd357bb29", "format2_vector": "pylit_testsingleelementarrays_test_single_bool_false" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestRealisticBatch::test_realistic_schema", "format1_hash": "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356", - "format2_hash": "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792", + "format2_hash": "000002b4caaae1356e990fdb4b8ed43bf8f67bcdc3ee2f094da6e0f71575dc52ec31c9", "format2_vector": "pylit_testrealisticbatch_test_realistic_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_hash_array", "format1_hash": "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0", - "format2_hash": "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26", + "format2_hash": "000002db3095dc0093c38b3aa668aee0f1805fc815542685d5d065008dc621512a8096", "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestNullableStructHashArray::test_nullable_struct_hash_array", "format1_hash": "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5", - "format2_hash": "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21", + "format2_hash": "000002f5c5e7555a574364d953e7ebeb45dbc9f232e5707133dd088420924300ae3c58", "format2_vector": "pylit_testnullablestructhasharray_test_nullable_struct_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_schema", "format1_hash": "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45", - "format2_hash": "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da", + "format2_hash": "0000029f1118411cb35c292b7950a626469bd8cb987faa8c114d6509f09f32ec816cb8", "format2_vector": "pylit_testmixedstructlistbatch_test_mixed_struct_list_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestStructEmptyBatch::test_struct_empty_batch", "format1_hash": "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773", - "format2_hash": "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93", + "format2_hash": "000002aaafa89ee39b32668aeb6f65c56501061b7194257ea88f14c3be0eca314f1d0d", "format2_vector": "pylit_teststructemptybatch_test_struct_empty_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestBatchAllNullColumn::test_batch_all_null_column", "format1_hash": "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494", - "format2_hash": "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752", + "format2_hash": "000002dca3ee7298f6495f2263e45eb2c876c9dc78f5b7462357f3be5f5d6579214e94", "format2_vector": "pylit_testbatchallnullcolumn_test_batch_all_null_column" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestMixedStructListBatch::test_mixed_struct_list_batch", "format1_hash": "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a", - "format2_hash": "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0", + "format2_hash": "00000227eb7540623891a51b93eb1f133f461cd3231bc03f3d5f36957b452a477b912c", "format2_vector": "pylit_testmixedstructlistbatch_test_mixed_struct_list_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_nullable_inner_field", "format1_hash": "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c", - "format2_hash": "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a", + "format2_hash": "0000023e818d98ed740fcd8240f4fdb39e4c53581b071c9ab6200a27924c186414f178", "format2_vector": "pylit_testliststructnullableinnerfield_test_nullable_inner_field" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_schema", "format1_hash": "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed", - "format2_hash": "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2", + "format2_hash": "00000231878b42f48260f2ba82a63298760afe8d214504d3b97a7019ff9a83eba48682", "format2_vector": "pylit_teststructwithlistchild_test_struct_with_list_child_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestNullableStructBatch::test_nullable_struct_batch", "format1_hash": "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048", - "format2_hash": "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b", + "format2_hash": "00000201b1aee1103d35dad74cda3c5a1c01e1aa5468beb02cc3cda5c1cb6c317f2d90", "format2_vector": "pylit_testnullablestructbatch_test_nullable_struct_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_schema", "format1_hash": "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330", - "format2_hash": "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835", + "format2_hash": "0000023014336b70e541ea20913795de44594938a32b325f17b5f03ed6ebf09859a95a", "format2_vector": "pylit_testlistoflist_test_list_of_list_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_string", "format1_hash": "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb", - "format2_hash": "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648", + "format2_hash": "00000229b25b121cf4b425c068c2ac17b1952497cf7015668b73a62f925a078fa69d67", "format2_vector": "pylit_testsingleelementarrays_test_single_string" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestNonNullableList::test_list_non_nullable", "format1_hash": "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b", - "format2_hash": "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96", + "format2_hash": "000002c60a39367e08f911e8d99db430267db89ca41e4cef6e87ac01520422354684a6", "format2_vector": "pylit_testnonnullablelist_test_list_non_nullable" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_int32_array", "format1_hash": "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a", - "format2_hash": "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f", + "format2_hash": "000002b87ccbba66f376281848a40936e3b3697d877c78ec651aa4151939d9f3af2277", "format2_vector": "pylit_testemptyarrays_test_empty_int32_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListOfList::test_list_of_list_batch", "format1_hash": "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10", - "format2_hash": "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f", + "format2_hash": "0000024354ac4eb6cef06e975af9b4a9f110e6baf409446897e122849553b159e6dc27", "format2_vector": "pylit_testlistoflist_test_list_of_list_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListStructNullableInnerField::test_non_nullable_inner_field", "format1_hash": "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c", - "format2_hash": "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f", + "format2_hash": "0000021a7aa4df873b7627617a5ce9a234a8849202508afc27eda81af271d8b12bf592", "format2_vector": "pylit_testliststructnullableinnerfield_test_non_nullable_inner_field" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestSchema4LevelNestedStruct::test_schema_4_level_nested_struct", "format1_hash": "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e", - "format2_hash": "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162", + "format2_hash": "000002a07f8d13692700d7b2cad515d343a2a1ce4b3dd7deac50316102a43638b496d2", "format2_vector": "pylit_testschema4levelnestedstruct_test_schema_4_level_nested_struct" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestSchemaListOfStructWithList::test_schema_list_of_struct_with_list", "format1_hash": "0000017f5258ff48e85b2a63cd1a29590ff3bfca39bf718365200ad74a8232bb654ec6", - "format2_hash": "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb", + "format2_hash": "000002a6a3ef288f2975f6a75b0336b2b7d69ffb4a2d129046710b7184d1eb76a45fe2", "format2_vector": "pylit_testschemalistofstructwithlist_test_schema_list_of_struct_with_list" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema", "format1_hash": "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83", - "format2_hash": "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd", + "format2_hash": "000002a157d896c73e72632c68cabed99b8351ca116199217e209552f9bfaf70721cff", "format2_vector": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestNullableListStructNullableChildren::test_nullable_list_struct_nullable_children_batch", "format1_hash": "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96", - "format2_hash": "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104", + "format2_hash": "000002411fa81d41e904d832eceea8e2041fc96bda4e4dc58e72b76380e086d400a008", "format2_vector": "pylit_testnullableliststructnullablechildren_test_nullable_list_struct_nullable_children_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestFloatSpecialValues::test_float64_special_values", "format1_hash": "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a", - "format2_hash": "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc", + "format2_hash": "000002b8e0f66c036e26098ba55673ee856b1b23fb6dcb9acfb63207cf8ad6fadc34dd", "format2_vector": "pylit_testfloatspecialvalues_test_float64_special_values" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestEmptyBatchComplexSchema::test_empty_batch_complex_schema_hash", "format1_hash": "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654", - "format2_hash": "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe", + "format2_hash": "00000286ebe427c00dea251c527cc286dc591efea4d6787cb3b40d3330a476b74f6d6c", "format2_vector": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema_hash" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestStructMixedTypes::test_struct_mixed_types_hash_array", "format1_hash": "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3", - "format2_hash": "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590", + "format2_hash": "00000269c3b3a491ea942d3067cfdf07b67a35bd708e4ee05c45cc302190016ab4a9f7", "format2_vector": "pylit_teststructmixedtypes_test_struct_mixed_types_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestEmptyArrays::test_empty_bool_array", "format1_hash": "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea", - "format2_hash": "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4", + "format2_hash": "000002754d4bf287e5b460d403a8468e526e92a738921b2aa8dbab8cc8a3450bcac203", "format2_vector": "pylit_testemptyarrays_test_empty_bool_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestListOfStruct::test_nullable_list_of_struct_hash_array", "format1_hash": "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8", - "format2_hash": "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca", + "format2_hash": "000002cd3cde5a0df63e3a6889556920e248890a882572450350a03da90f67f37e9f90", "format2_vector": "pylit_testlistofstruct_test_nullable_list_of_struct_hash_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestStructFieldOrderIndependence::test_struct_3field_order_independence", "format1_hash": "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25", - "format2_hash": "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283", + "format2_hash": "0000025560faf3d3f3ce308ad2c7129f24f42589e7b25f0c6dc70ddd2aa45f7464111a", "format2_vector": "pylit_teststructfieldorderindependence_test_struct_3field_order_independence" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestUnicodeStrings::test_unicode_string_array", "format1_hash": "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40", - "format2_hash": "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486", + "format2_hash": "0000029f656d188a338cc277592a06b5710796016037efc7fc7cb5746e65bfadd752b4", "format2_vector": "pylit_testunicodestrings_test_unicode_string_array" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestNestedNullableInnerStruct::test_nested_nullable_inner_struct", "format1_hash": "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c", - "format2_hash": "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820", + "format2_hash": "00000236f16a0a8179aefeb33f440a83a7d32aad8993c022796eab539de2e1d63521b8", "format2_vector": "pylit_testnestednullableinnerstruct_test_nested_nullable_inner_struct" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestLargeSchema::test_large_schema_12_fields", "format1_hash": "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd", - "format2_hash": "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d", + "format2_hash": "000002a89c186dbf815b7192ed4ac574196d1e0203db10d53dd7d16fbe12fbbdbb651e", "format2_vector": "pylit_testlargeschema_test_large_schema_12_fields" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestMultiBatchStruct::test_multi_batch_struct", "format1_hash": "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c", - "format2_hash": "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2", + "format2_hash": "0000025d4b5b129c220a3171a616f1ff060a00fdb3647a34434f4d83e9d0a68502c334", "format2_vector": "pylit_testmultibatchstruct_test_multi_batch_struct" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestSingleElementArrays::test_single_int64", "format1_hash": "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f", - "format2_hash": "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770", + "format2_hash": "000002ac6614ba2b81b9238b2888b17d9ccb5eb46a7ea3285c22a1b1ad25997d726e7b", "format2_vector": "pylit_testsingleelementarrays_test_single_int64" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestStructWithListChild::test_struct_with_list_child_batch", "format1_hash": "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d", - "format2_hash": "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83", + "format2_hash": "0000027699b386e4e56ce34d2a38f748566a75c36c62ca8f5fa36180f0ea8809ac528c", "format2_vector": "pylit_teststructwithlistchild_test_struct_with_list_child_batch" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_schema", "format1_hash": "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7", - "format2_hash": "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8", + "format2_hash": "000002613ec04c0f0d49d1eff685ac3ffc3ee80a47ddb2121860f9845ac0d3a33fe7b2", "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_schema" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestBooleanArrays::test_bool_17_elements", "format1_hash": "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a", - "format2_hash": "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068", + "format2_hash": "000002d8e326d69087a22ebe44e971f2673272ad044e99927c9c4cfcf1cf26f1e7dcf2", "format2_vector": "pylit_testbooleanarrays_test_bool_17_elements" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestMultiBatchList::test_multi_batch_list", "format1_hash": "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3", - "format2_hash": "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519", + "format2_hash": "00000248df16aca0c1f681b8b02cd0c859b3073c238101a6893bfa44d9f536a9819870", "format2_vector": "pylit_testmultibatchlist_test_multi_batch_list" }, { "source": "starfix-python tests/test_golden_parity_r2.py", "id": "tests/test_golden_parity_r2.py::TestThreeLevelStruct::test_three_level_struct_batch", "format1_hash": "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a", - "format2_hash": "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db", + "format2_hash": "000002207e061a060534d98724ad2beabd1cd5d1350e5614104815a6a6c0ef13d8935c", "format2_vector": "pylit_testthreelevelstruct_test_three_level_struct_batch" }, { "source": "starfix-python tests/test_metadata_hashing.py", - "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table", + "id": "tests/test_golden_parity.py::TestSpecExamples::test_example_a_two_column_table#2", "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88", - "format2_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f", + "format2_hash": "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207", "format2_vector": "pylit_testspecexamples_test_example_a_two_column_table_2" } ] diff --git a/tests/golden/format2_v0.5.json b/tests/golden/format2_v0.5.json index 60889f1..87b755a 100644 --- a/tests/golden/format2_v0.5.json +++ b/tests/golden/format2_v0.5.json @@ -11,7 +11,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" + "expected_hash": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" }, { "id": "cols_ba_rb_f0", @@ -21,7 +21,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000232bdf93232887698a4ec193cd978e6617c3d64a85be5d26c2853fcf82a42f3b6" + "expected_hash": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" }, { "id": "cols_ab_schema_f0", @@ -31,7 +31,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78" + "expected_hash": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864" }, { "id": "cols_ba_schema_f0", @@ -41,7 +41,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000021244ae884a7522607bc7e671ebc8b935e2a4ee0f5dc88827d0fa4d0fd3aaff78" + "expected_hash": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864" }, { "id": "cols_ab_rb_f1", @@ -51,7 +51,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002fd2f35d37a40f06e04e40249b7276576fbb1531b5e73f2f8f1d72a8fa919dbac" + "expected_hash": "000002f46be8acf0132c93a5998ae80c6972a3c91cb5ff5d8ef931b89ff953d172c76e" }, { "id": "cols_ba_rb_f1", @@ -61,7 +61,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e9b67dfcd80328c4f0b1c8ba2c4249aab468221b444b57fdd8332cf32b806456" + "expected_hash": "00000239bdd5d7e4ab08cc7a4e4e770de964d2b8aa3b75967e13281def353f08ce51d3" }, { "id": "cols_ab_schema_f1", @@ -71,7 +71,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002c0270743d441e19e40a9cb9c096122994f1b5855c1a8f792b1f7dcbbad3e1fda" + "expected_hash": "0000028f04578b9165686ed0110acd494b70a0b3d3886cabd745ee33f3fb2846e026af" }, { "id": "cols_ba_schema_f1", @@ -81,7 +81,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000026043b19dae69df86d76daf5a24c6aa30d040ff9765102f37a6e7f40edf4907f3" + "expected_hash": "0000028f8137c97398d96b8d1a49ac043c68278193a24d8cdc31fc80b9a6be1028dbb0" }, { "id": "cols_ba_stream_f1", @@ -91,7 +91,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002e9b67dfcd80328c4f0b1c8ba2c4249aab468221b444b57fdd8332cf32b806456" + "expected_hash": "00000239bdd5d7e4ab08cc7a4e4e770de964d2b8aa3b75967e13281def353f08ce51d3" }, { "id": "combo_ns_xy_f0", @@ -101,7 +101,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + "expected_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" }, { "id": "combo_sn_xy_f0", @@ -111,7 +111,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + "expected_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" }, { "id": "combo_ns_yx_f0", @@ -121,7 +121,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + "expected_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" }, { "id": "combo_sn_yx_f0", @@ -131,7 +131,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025e411c5e9318b7483d9fe382f815c5b20c9e7d878b19109d142994c1beef8674" + "expected_hash": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" }, { "id": "combo_ns_xy_f1", @@ -141,7 +141,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000299b420126277e1c35db38e343ae507eadbad5444d2298bf04dcffedb832bbfd5" + "expected_hash": "000002cb6c7c28389b3a9806541e5a00327662c35450906fe74fdeb029ef0a04362dfa" }, { "id": "combo_sn_xy_f1", @@ -151,7 +151,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002902e074f42ee3a1fb4f1bfc5796350923529b16425db919ade5495e86f800cfc" + "expected_hash": "0000028bfe6c9d2d41e7880f83a22d15b23f315276282fa10c952f095fcc14777b157f" }, { "id": "combo_ns_yx_f1", @@ -161,7 +161,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000299b420126277e1c35db38e343ae507eadbad5444d2298bf04dcffedb832bbfd5" + "expected_hash": "000002cb6c7c28389b3a9806541e5a00327662c35450906fe74fdeb029ef0a04362dfa" }, { "id": "combo_sn_yx_f1", @@ -171,7 +171,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002902e074f42ee3a1fb4f1bfc5796350923529b16425db919ade5495e86f800cfc" + "expected_hash": "0000028bfe6c9d2d41e7880f83a22d15b23f315276282fa10c952f095fcc14777b157f" }, { "id": "combo_ns_xy_f2", @@ -181,7 +181,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000257a9e2653caa2af9e1109882560fb987ff41232a5635d26830281f9d72417144" + "expected_hash": "000002420d0566f1ef5d0880b12a4431cca4a0f7ca37ff50fbbc2a580c75d5a0e52618" }, { "id": "combo_sn_xy_f2", @@ -191,7 +191,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000257a9e2653caa2af9e1109882560fb987ff41232a5635d26830281f9d72417144" + "expected_hash": "000002420d0566f1ef5d0880b12a4431cca4a0f7ca37ff50fbbc2a580c75d5a0e52618" }, { "id": "combo_ns_yx_f2", @@ -201,7 +201,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000255754414ebe823c9b0e4fc4db6a5e764043a54a3aa5723425440e54cd0921c5a" + "expected_hash": "000002ae016e8ceb41644142fd9370fad2087d49a36b22c1a45696e833b020f4971a5b" }, { "id": "combo_sn_yx_f2", @@ -211,7 +211,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000255754414ebe823c9b0e4fc4db6a5e764043a54a3aa5723425440e54cd0921c5a" + "expected_hash": "000002ae016e8ceb41644142fd9370fad2087d49a36b22c1a45696e833b020f4971a5b" }, { "id": "combo_ns_xy_f3", @@ -221,7 +221,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADQAAAAIAAAA5P///6T///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAHkAAADM////EAAAABgAAAAAAAACFAAAALz///8gAAAAAAAAAQAAAAABAAAAeAAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b60dcf77a903bb7f3f15da8e6e3c4d204eabc525e9df8196294f8b22e9fcd5e1" + "expected_hash": "000002defaa77ea7f9a96b205c41605c03464fe860ba0437445f3c747a12b6db84f32b" }, { "id": "combo_sn_xy_f3", @@ -231,7 +231,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAIj///8QAAAAGAAAAAAAAAIUAAAAeP///yAAAAAAAAABAAAAAAEAAABuAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024e7c431a7ca9e214fde4ad9863e82afe27dc5bcbd0b84b9533946fa3f8bcece6" + "expected_hash": "0000026bfeb3264ccf8ffdaa022dbd7a7273b82e079dfb2b43686c25fd9d267eb81cf9" }, { "id": "combo_ns_yx_f3", @@ -241,7 +241,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACYAAAABAAAAID///8cAAAADAAAAAAAAA1oAAAAAgAAADgAAAAIAAAAuP///6T///8QAAAAGAAAAAAAAAIUAAAAlP///yAAAAAAAAABAAAAAAEAAAB4AAAA0P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAAAEAAABzAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f47e306bb3a3af19b2f5014534dd5859df55ceed4328be3ec371c15f3fdbae2b" + "expected_hash": "0000028a064f5ae16bb17c763e9c2e5ddf63758249350b35ee85ddffaf73a639994809" }, { "id": "combo_sn_yx_f3", @@ -251,7 +251,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002171397f6490e1ab445bf0ca56c6290acd75cc091295d6ac80e12656f55d91c48" + "expected_hash": "0000029b18d33ff5310a20b71324654fabe6bff0c2018e02e2e2a597431a67c300d381" }, { "id": "nested_struct_ab_schema_f0", @@ -261,7 +261,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2" + "expected_hash": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e" }, { "id": "nested_struct_ba_schema_f0", @@ -271,7 +271,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a566fd4383d6aa887f3d313d78b2d21eb46e66e206e3909839e3077611790ca2" + "expected_hash": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e" }, { "id": "list_struct_ab_rb_f0", @@ -281,7 +281,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + "expected_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" }, { "id": "list_struct_ba_rb_f0", @@ -291,7 +291,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + "expected_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" }, { "id": "large_list_struct_ab_rb_f0", @@ -301,7 +301,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025c4b5fef978e579e96f94e3777eb01b875f6b901ece27ec07eca8e2f1144b203" + "expected_hash": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" }, { "id": "fsl_struct_ab_schema_f0", @@ -311,7 +311,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc" + "expected_hash": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33" }, { "id": "fsl_struct_ba_schema_f0", @@ -321,7 +321,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000246b33c9ed0926cbf79d864c4473193402e1ac18c5f21c352437dbea53dadeacc" + "expected_hash": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33" }, { "id": "map_struct_ab_schema_f0", @@ -331,7 +331,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2" + "expected_hash": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777" }, { "id": "map_struct_ba_schema_f0", @@ -341,7 +341,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029ce6a87ebf7f0e2d64ce941179a308f10fde9ffc767e85c643cae837025e12c2" + "expected_hash": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777" }, { "id": "nested_struct_ab_schema_f2", @@ -351,7 +351,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABiAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002d32d17fc90639336690608e3ed79d49ddcfed560a3ce6c841407afde83d0969c" + "expected_hash": "0000029f9c29a1e3d9b1c09f0e0a193865a9cf334c90242944583ae7a2da5dd52aa6ac" }, { "id": "nested_struct_ba_schema_f2", @@ -361,7 +361,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAABhAAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAGIAAAABAAAAcAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABxAAAAAQAAAHMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000249b92b055ce95a9c6abf84c1b7e2a8c2746149966a41dcfbf9d1ece44e507291" + "expected_hash": "00000285b339b70e8d2bc368c0ea6ae56843afa7deaf0d00275ba5e15e2ad62457b804" }, { "id": "list_struct_ab_rb_f2", @@ -371,7 +371,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002be3f261e757e47d19ac6cf63c86a698e458c183dba3019c7a30d7709b3bae179" + "expected_hash": "000002b8f040dfb0562ccea535a45ca321233ffad27738a54d6bc2e2d092928bfdf07d" }, { "id": "list_struct_ba_rb_f2", @@ -381,7 +381,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e3144a68d34997bea027c96823733d42a3c3ffa0d53412f10170e213f851ab22" + "expected_hash": "0000029e617bff9390de342ac8df0f255256ed7bcf543f7a834e179ef15f6d478299cc" }, { "id": "large_list_struct_ab_rb_f2", @@ -391,7 +391,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFbwAAAABAAAACAAAALD////c////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAACAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002be3f261e757e47d19ac6cf63c86a698e458c183dba3019c7a30d7709b3bae179" + "expected_hash": "000002b8f040dfb0562ccea535a45ca321233ffad27738a54d6bc2e2d092928bfdf07d" }, { "id": "fsl_struct_ab_schema_f2", @@ -401,7 +401,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAADc////HAAAAAwAAAAAAAENkAAAAAIAAABUAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAABAAAAYgAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002019f912d8bfa8199312c5210150fce6dc1e7bf8173201fb2a1074e0a225f4a3c" + "expected_hash": "0000021ebf27630271ca9ef53a9153c5310b979d7d53b5c246c8582c693aef78c5ff1e" }, { "id": "fsl_struct_ba_schema_f2", @@ -411,7 +411,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///yAAAAAMAAAAAAAAEMgAAAABAAAAFAAAAAAABgAIAAQABgAAAAIAAACY////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002925dc2273e700e690d7b5e5f9b0f8760be4b21557765871b04d0e85c33e12ed6" + "expected_hash": "000002a14d5ec048cb3ebd9c9e1ba94e56b2096ab6ab4c7aee2e1203254b091e9c3788" }, { "id": "map_struct_ab_schema_f2", @@ -421,7 +421,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAmP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz////c////HAAAAAwAAAAAAAENfAAAAAIAAABAAAAAGAAAAGD///8QABQAEAAOAA8ABAAAAAgAEAAAABQAAAAMAAAAAAABBQwAAAAAAAAAjP///wEAAABiAAAAwP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002a18ed04210f29c9b171da2dd6bd635442be7e0c8785e9d21ab87b1b4207dec3d" + "expected_hash": "000002e5f3c8a98f577eceaded46c0a9af72fc43376a2b3aa3c98e8661de6d2f432f3d" }, { "id": "map_struct_ba_schema_f2", @@ -431,7 +431,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABERABAAABAAAACAAAABj///9E////HAAAAAwAAAAAAAAN5AAAAAIAAAC0AAAACAAAADz///+o////HAAAAAwAAAAAAAENfAAAAAIAAABQAAAACAAAAGD///+M////GAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAADAAAAAAAAQUMAAAAAAAAAMD///8BAAAAYgAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000021cff4e9ecfc52c3cb6d9acd9b02241b3a8340b708b626b2342f319b5a62c8fd9" + "expected_hash": "000002aeacee15f252f685ca6ffa636d4ed1e1ea2763da0c0e6078a5099fd77dd336e7" }, { "id": "one_col_rb_f0", @@ -441,7 +441,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b" + "expected_hash": "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27" }, { "id": "one_col_schema_f0", @@ -451,7 +451,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "0000021e21972ae342e0d1df1e326a7b21effda3967fcbcdfa1e35b404878354093ad4" + "expected_hash": "0000028ff3df6a3c3249959db37063755324949df6b294b624131d395269f8d3f64528" }, { "id": "one_col_array_f0", @@ -461,7 +461,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" + "expected_hash": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" }, { "id": "one_col_rb_f1", @@ -471,7 +471,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002d212f8b185b21b800f584b38910145a4b81ee7f276f71830d9001f61f78c71e4" + "expected_hash": "000002c561a8faffd7f221815520f26cbc214640dc54c14a5cfa986e31e6978b53c3d8" }, { "id": "one_col_schema_f1", @@ -481,7 +481,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000002bfaa329e4ab9a16f95370d38879da26bc40860ca84d59a2364d53cffb6a07baf" + "expected_hash": "000002f78a226fad9d52501db434f7a0d63d5c8ecf8c8032e508d45739e8be34535bcd" }, { "id": "one_col_array_f1", @@ -491,7 +491,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025afda948e8a8efb2e0976f237c06dc00555ed6ca69ec8abf21f43179d14009d7" + "expected_hash": "000002bdec9d15a144f01c0287210e62d82472cf33d5ce6a0351833e9851b6c0269e96" }, { "id": "one_col_rb_f2", @@ -501,7 +501,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022b4b208408375278f5f1eee9b66a9cdbbe2e158af35b936e8410bd20951c3f15" + "expected_hash": "000002d52e9bcf59ec55166263d52292a7383240c5b6d5ed956b2c7b23a8d7ef96e6a0" }, { "id": "one_col_schema_f2", @@ -511,7 +511,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000002f300e48cd58d3abc1a35b0df83ed620acff982922d68192c945094bdc8a2cd2e" + "expected_hash": "00000282e20df356301b02bb6ac0b359c5264f9fa6907a96b82c87cda1bc0af690928e" }, { "id": "one_col_array_f2", @@ -521,7 +521,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b6f8dedb0f20b24c40ea03ec391ccc7656bf9d428b550b1c9f1cc7e92309a73b" + "expected_hash": "000002b697545027698c19c381e6bdf63663cd01239fa0dfce229da818812227eeb766" }, { "id": "one_col_rb_f3", @@ -531,7 +531,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022a57199ec1d348f8a03cc5ff16823af138262dafe9e94c2c0ef575730471fb78" + "expected_hash": "0000028764580f51fc33f448a01a83d66952b7f529f899fb49163dfa51fc992c2be5cf" }, { "id": "one_col_schema_f3", @@ -541,7 +541,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHYAAAD/////AAAAAA==", - "expected_hash": "000002bf9151fa730fbdb16eb1e4da8dc110d4cb6635ed25da37ae2fcf46365b777650" + "expected_hash": "0000028311d4a59ed443d04ecee00b977e3055629be729aaf79adfb1f6269a06ada645" }, { "id": "one_col_array_f3", @@ -551,7 +551,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000283a0a8b132c33bd58c78b2536fe801bd033d7e03c40147f3e5f395872629acbc" + "expected_hash": "0000028747189dc0ce0fe089a03fbf5f4d5af3d11a75195949daf06f25edc430633a88" }, { "id": "plain_schema_f1_im0", @@ -561,7 +561,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f8d23756dd1ca8ee57511dbfe1c3cb087d8732fd9c4d8a72256ed4af45592387" + "expected_hash": "0000020a2732b0de633930e317e0d74b00c92e88cd163907f4fd2de331c9e8895ad390" }, { "id": "plain_schema_f1_im1", @@ -571,7 +571,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f8d23756dd1ca8ee57511dbfe1c3cb087d8732fd9c4d8a72256ed4af45592387" + "expected_hash": "0000020a2732b0de633930e317e0d74b00c92e88cd163907f4fd2de331c9e8895ad390" }, { "id": "meta_schema_f1_im1", @@ -581,7 +581,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002493eba96d0e764e218f4072f621d0b9ecfe22daac21d561f842e0eafc1260bf5" + "expected_hash": "000002d9e0d412e4a1f9f09707d320f38231738a4a8c932068e953b9dfbcbc58533745" }, { "id": "plain_schema_f3_im0", @@ -591,7 +591,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000257d9dd9d561c4232e2d07269004f9db141adc853c5ad944f7ec9b31b4ecadc65" + "expected_hash": "000002ca1221c5456782dce99f6c3bbe66dd0deab57f8d4fc41fe463ec8233873f3a36" }, { "id": "plain_schema_f3_im1", @@ -601,7 +601,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABEAAAABAAAANT///8QAAAAGAAAAAAAAAIUAAAAxP///yAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000257d9dd9d561c4232e2d07269004f9db141adc853c5ad944f7ec9b31b4ecadc65" + "expected_hash": "000002ca1221c5456782dce99f6c3bbe66dd0deab57f8d4fc41fe463ec8233873f3a36" }, { "id": "meta_schema_f3_im1", @@ -611,7 +611,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAwAAAAAQAAAAQAAABE////CAAAABAAAAAGAAAAZ29sZGVuAAAGAAAAc291cmNlAAACAAAAVAAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABAAAAAYAAAAAAAAAhQAAADA////IAAAAAAAAAEAAAAAAQAAAGEAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGIAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f8d5fbb2a37aee3411400a0696f42373a09225c4e85013dc5bfa70bbd74e970e" + "expected_hash": "000002447b4b733d5401aaf7a1441eefbef0f96fec67a0daf19e847a424a1d7896ca1a" }, { "id": "ext_struct_xy_rb_f0_im1", @@ -621,7 +621,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a" + "expected_hash": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796" }, { "id": "ext_struct_yx_rb_f0_im1", @@ -631,7 +631,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ccfcb759239c88570778d931e777a1ca484076a3c8be9e3936f7ec934347000a" + "expected_hash": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796" }, { "id": "ext_struct_xy_rb_f2_im1", @@ -641,7 +641,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAQAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000211f3efef88ef314c928160341ce1df3cea468b4b905671f0fb8debd04126523e" + "expected_hash": "000002bf55d73c724270acff73eb548a913a4debfd268161ee20fb5c0569baeb1303f3" }, { "id": "ext_struct_yx_rb_f2_im1", @@ -651,7 +651,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAmAAAABwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAGUAAAACAAAATAAAAAQAAADE////CAAAABgAAAANAAAAZXhhbXBsZS5wb2ludAAAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAQAAAAAAAAAAAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029f008ce8fc460ce82e719a84f32d630363563e017ccf3e2814acdbef4e451fc0" + "expected_hash": "000002b61578fa2262cb59cb43bc62ed5178ccea96442fea059332632bfbc644a246a6" }, { "id": "empty_stream_f1", @@ -661,7 +661,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024addf88e806e549394af82afebcb8f7b03e3d67769216814464d7342b7e70362" + "expected_hash": "000002f6e55b477db784b8472b1cd7cac8d9af2c5ed4bc435e4463aad68769d08cb69e" }, { "id": "zero_row_rb_f1", @@ -671,7 +671,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABcAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAA/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAADAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024addf88e806e549394af82afebcb8f7b03e3d67769216814464d7342b7e70362" + "expected_hash": "000002f6e55b477db784b8472b1cd7cac8d9af2c5ed4bc435e4463aad68769d08cb69e" }, { "id": "zero_cols_0rows_rb_f0", @@ -681,7 +681,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b2a0b24f3e5df2eee53e0db16967b5727624ba316c984d3e5ba250495e0cc8e7" + "expected_hash": "00000250cb2fc7aaf1c32b7d195c543876c8333c0b15f85caf96b4ce43fe587f444d07" }, { "id": "zero_cols_3rows_rb_f0", @@ -691,7 +691,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000245bae18d1db53b328b187930c2ed6f652be046f8156f30565ef09b22c10c8a08" + "expected_hash": "000002d1c4267472a7b0df719325b9fea373625afa4c828dce1f56a106e14c09987068" }, { "id": "zero_cols_0rows_rb_f1", @@ -701,7 +701,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAEAAAAAAACgAOAAwACwAEAAoAAAAUAAAAAAAAAwQACgAMAAAACAAEAAoAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000028d3e59d17471807ff6d8794816c2556c15d96f707d991fe0af4838eeccc52ba1" + "expected_hash": "0000022b4bc34d58bf66048529ffea97a18505809ea102836c19467516c388092db7ef" }, { "id": "zero_cols_3rows_rb_f1", @@ -711,7 +711,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAAAAAAAAAAAAAAAAP////94AAAAFAAAAAAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAHAAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002bc2b2a94f2edadb19e438ce5c0bddbba813bf3b945767126e2a36c2ab48d8aa7" + "expected_hash": "0000029edc93ce2109bb4e931489baddc900e904dacac2cfbba356464f986ce4da3c63" }, { "id": "leaf_nulls_rb_f3", @@ -721,7 +721,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAABwAAAANAAAAAQAAACs////EAAAABgAAAAAAAECFAAAAJz///8gAAAAAAAAAQAAAAABAAAAegAAANj///8YAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGEAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAACAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002c0b1052c44299def8c050e5dc3036737551bdb2aba6cc0defebbe5a0b39693f3" + "expected_hash": "000002b15be8f2ffc47d7dc2b88d82ea2acd2a35506a7746df85c3a2b2d20ffde439e5" }, { "id": "nv_null_struct_rb_f0", @@ -731,7 +731,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002db84efc10bb100fb89bc3dd8d36572cb411b2871732479f26eed388229c3b2af" + "expected_hash": "0000026630aa8326714cbd9cb8e539a9dc2aa9e966bc61cc43f4da30bb51a855c9cd06" }, { "id": "nv_null_fields_rb_f0", @@ -741,7 +741,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ae04d1306e82b99f8cfbc5c3d42d529b7f5e1e57eb728426c496781e93091027" + "expected_hash": "000002517a1bd090b9ddec71fb8656b6a5064b97e18ad760c14116ef1799cba4eb36fe" }, { "id": "nv_rows3_rb_f0", @@ -751,7 +751,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + "expected_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" }, { "id": "nv_rows2_rb_f0", @@ -761,7 +761,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ba8982cfb0a3a959a78134c6d90f9fb7ffacbb8a71a3764bc50dbd623ae0d7b7" + "expected_hash": "000002cf2404bcc0218a195c4a262cc022bf7c77f4806d41e8c4431e3cfd5cc97ee9a4" }, { "id": "nv_list_list_1row_rb_f0", @@ -771,7 +771,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000281c6c806d1945038ecebdfb5b3afa115fb8322d74c682d4984e7c35b2fb8ac11" + "expected_hash": "0000022a14ec9cc1066b92f435f414832d0948a52d72dccfb2c4f35eea219da00c7c96" }, { "id": "nv_list_list_2rows_rb_f0", @@ -781,7 +781,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a2c92a16669aac9a5e1312db5966e75d3a15bfef192e651424462ec955fb6438" + "expected_hash": "0000021fae7750bc9e056286f3446edae67e8ad93c540edbd3290f6c4bf2d63882390d" }, { "id": "nv_list_null_elem_rb_f0", @@ -791,7 +791,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002759eb8659b32aa8437b39c041effd8bbef2ae68d7a5d6c5deae8df2559df5a8b" + "expected_hash": "000002880943a6023e397289e89fb31d609807d68a56568133935693da686c53199eea" }, { "id": "nv_list_null_fields_elem_rb_f0", @@ -801,7 +801,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000262e139b737f1bcebd138ac4e9a6dbadb9a8e7a9c24d93bcf7db418693323619e" + "expected_hash": "00000276aeb72c9e3f36df94c629d354a68c357bf5306d86e2be7244de6c0a9f233c20" }, { "id": "nv_null_struct_rb_f3", @@ -811,7 +811,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f781933978ce32299ef7591304c4874fd80fbd044858c558cdeda41aee960cf8" + "expected_hash": "0000027e7b9052d16a3bb2a65de3de6b099781626668f023583a6268c411b4c3146a9e" }, { "id": "nv_null_fields_rb_f3", @@ -821,7 +821,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000262c2ceab507d05a742a70bd04e99a30dcca2832b27bb91d21956ac827cc3e17d" + "expected_hash": "000002f8d0cad8f2f257bc9754fcc1ba34ee9de2759d377a2985dbcfd5ab821d727f4e" }, { "id": "nv_rows3_rb_f3", @@ -831,7 +831,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000027bc8d972783ed84371e0396f6414883927de8b45ddb69819c42195942f32d8ac" + "expected_hash": "0000024f8a88ee53d98f07c353289631d09ad5c5df0033b700b7de7684aeaa7ef10c5b" }, { "id": "nv_rows2_rb_f3", @@ -841,7 +841,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002c225743b59aff3372d541db2f35a17b4d4432cb7c467eb251f83ed27926e3d84" + "expected_hash": "00000274b9aafeb1cec10353639e0e61accfbbb1504495ae83f08e5cfb7f042da675b6" }, { "id": "nv_list_list_1row_rb_f3", @@ -851,7 +851,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024be9127d5b421c42e6960135981628f13c4750a89ebff4492cc6a87daafaa6d9" + "expected_hash": "00000291782733ce1ef1799c15a2727c9f8792f71714fad00afb19fadaec4927e3c23c" }, { "id": "nv_list_list_2rows_rb_f3", @@ -861,7 +861,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b14609a3a15d9b4ac1cad514416809d66dd755c11d3559fd29fc021e3dc1d64e" + "expected_hash": "000002b0ae5216ef5d178e64a98107d83eb1a461c611b17d611e2c779a3f0a8896b6f3" }, { "id": "nv_list_null_elem_rb_f3", @@ -871,7 +871,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002766b2b94169e0ef73a59814a47706df329da0a8e8f987fde2ccf74436799cec5" + "expected_hash": "000002038a10043e3b9955bd29cd1ed8df9e145b620b0084df5c3606e836197d4f4517" }, { "id": "nv_list_null_fields_elem_rb_f3", @@ -881,7 +881,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyEAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000028e489475ea979dcc6cc663fb1f31ddbf87a8706d3d2b5f5091b2f099d88ff431" + "expected_hash": "00000217932a02d84ea18735d3535c8d1caf2ede51ce21a1dd5bf9c28ad9766ba40433" }, { "id": "nv_nested_structs_rb_f0", @@ -891,7 +891,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e7bd89d9f653eae5fa33dd933472baacdc180e17580a067776476042525a2c1b" + "expected_hash": "000002c915fc059403168923cb1bca8c577cd50ba76ac3ecb9db2c419cde716f1afea1" }, { "id": "nv_nested_structs_rb_f3", @@ -901,7 +901,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAuP///xwAAAAMAAAAAAABDcAAAAACAAAAhAAAAAgAAADg////3P///xwAAAAMAAAAAAABDVAAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAvP///yAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAGkAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAdwAAAAEAAABvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAABAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAIAAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAABAAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000279f0bd3373da8205c1f529f766d2ea9e411c4240ecb5bfae8b9cdf9b5e67c44a" + "expected_hash": "0000026efd81f7599fee7503b0ae97f5a45bca1541a8bd8f3dcb85e4f5e9ee4b828b77" }, { "id": "nv_rows3_stream_f0", @@ -911,7 +911,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + "expected_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" }, { "id": "nv_array_rows3_f0", @@ -921,7 +921,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025a437237556cf10c3516943f8c8137cd48a52cf16b1777262a0e36a2ec646c80" + "expected_hash": "00000281e68cbc71271d8bd4bd49ca0b4fc06ed9ee14d0a9b89e94c7b4d7f57a765fc2" }, { "id": "nv_array_rows2_f0", @@ -931,7 +931,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e38a3d717443a885dd50d9f3cdf22d7cb1c69fa194a64a4168a384a7406e80e1" + "expected_hash": "0000026377ee1c5f0cf836051940feae161f2a199af2b37aa1fd0fe74c8c5debca90c5" }, { "id": "nv_array_rows3_f3", @@ -941,7 +941,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025998218109dc90a6abe2a1b53ab9e149fd6d765fc63f75b83e8b5c4108def858" + "expected_hash": "00000273951df95fbecbab7f34e569e023397c1b0890b29c84ebed68f774e1a12092a3" }, { "id": "nv_array_rows2_f3", @@ -951,7 +951,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002bd633876ba1380b3d9454d6e93959a608953eb173652156d636d11952111bae9" + "expected_hash": "00000251c6c06562499d5b7cc779fc3c43945e5c26372ac7a500d2c109d7388ddb7811" }, { "id": "phys_dict_rb_f0", @@ -961,7 +961,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + "expected_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" }, { "id": "phys_utf8_rb_f0", @@ -971,7 +971,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + "expected_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" }, { "id": "phys_large_utf8_rb_f0", @@ -981,7 +981,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000026deab300e85823f54f1d8fe9c387b2ee7cabe25c115dfb5f45e76a4cc5746fa6" + "expected_hash": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" }, { "id": "phys_dict_rb_f3", @@ -991,7 +991,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAxP///wQAAAACAAAAcAAAABQAAAAQABgAFAAAAA8ABAAQAAgAEAAAADgAAAAsAAAAAAAABRAAAAAsAAAACAAIAAAABAAIAAAABAAAALz///8gAAAAAAAAAQAAAAAEAAQABAAAAAEAAABkAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + "expected_hash": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" }, { "id": "phys_utf8_rb_f3", @@ -1001,7 +1001,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + "expected_hash": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" }, { "id": "phys_large_utf8_rb_f3", @@ -1011,7 +1011,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABAAAAABAAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b62fc72af0abe97bb6a998f50f08c28c39b85c68dee78d420b57fd202508bbcf" + "expected_hash": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" }, { "id": "array_struct_xy_f0", @@ -1021,7 +1021,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4" + "expected_hash": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456" }, { "id": "array_struct_yx_f0", @@ -1031,7 +1031,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000023810b1200c9ad4e72fb6aae772d29506f8ec83f4507ec19eaccb5aa8ccd750b4" + "expected_hash": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456" }, { "id": "array_struct_xy_f2", @@ -1041,7 +1041,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002477608cc8f61796978d5e863bfa56ba6b7b8620aee386bc93c6b007d2b110911" + "expected_hash": "0000021c7248fb925c72a6f3736d2726d4dabebd21719374e36f719b016bcb41b6913f" }, { "id": "array_struct_yx_f2", @@ -1051,7 +1051,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002ec8d4e01557a6e80f126a91049699f00ae90bdf0e38a9ba49095e635e90942a7" + "expected_hash": "000002357aea0047d56e03b89e5c7cccab769bcbda1e8f5c9b92b59ddcd13364b7d430" }, { "id": "array_struct_xy_f3", @@ -1061,7 +1061,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAtP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027222886512d91f93ff578714967bffe25099e787ca277eebfab052900c93b774" + "expected_hash": "000002e14df9d1686586ed6f4be4c5871badcbd7879b55c2ef94acc61037ed40336981" }, { "id": "array_struct_yx_f3", @@ -1071,7 +1071,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002a393af972e9dd3225c50181bc1fd8b4e84f499baeed9c0f759a6cb6a384ec451" + "expected_hash": "000002510338a913e5edf04937368329dea10df409b70f5ffae6f5c9cfd970f9030e84" }, { "id": "array_list_struct_f2", @@ -1081,7 +1081,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000023ae35e8ff85e58f481d0121aba6a098eef05dd939754a4d4d3e5079912e1ac8a" + "expected_hash": "0000026e041b5e9234671c85d59a78d96ec1c0349c6932cb7c83aef4c2d083ee916816" }, { "id": "array_list_struct_f3", @@ -1091,7 +1091,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAeP///xgAAAAMAAAAAAABDLwAAAABAAAACAAAAGz///+Y////HAAAAAwAAAAAAAENkAAAAAIAAABgAAAAGAAAAJD///8QABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEFEAAAAAAAAAAEAAQABAAAAAEAAABiAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b32296f9475c4a92e605084e9091b7f11a3a0220a89aacb4e0e53964c1ed19e0" + "expected_hash": "00000225cf7664ca164996e08dc955260f09dd82b229b07bffc6796f7b693bb30824cb" }, { "id": "combo_sn_yx_3rows_rb_f3", @@ -1101,7 +1101,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAAHz///8QAAAAGAAAAAAAAAIUAAAAsP///yAAAAAAAAABAAAAAAEAAABuAAAAqP///xwAAAAMAAAAAAAADYAAAAACAAAAUAAAAAgAAACg////zP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002223743a17543e2cafaa8fe33b3ec42cd45391ed2f6cd370d03d626e8b0d88468" + "expected_hash": "000002d4ac9219266d2a330085e8a922040b7fe37b31c831be6a497053b39bfffe01ec" }, { "id": "combo_sn_yx_3rows_stream_f3", @@ -1111,7 +1111,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "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", - "expected_hash": "000002223743a17543e2cafaa8fe33b3ec42cd45391ed2f6cd370d03d626e8b0d88468" + "expected_hash": "000002d4ac9219266d2a330085e8a922040b7fe37b31c831be6a497053b39bfffe01ec" }, { "id": "bool_1row_rb_f0", @@ -1121,7 +1121,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002ef402ce172daaef8d7b354c4a1f733117057a2da38cd0c1ae5f1900e891c34d4" + "expected_hash": "0000026c3a344f7fcda6c51ee4bd97ecf4c3e6dc702ec2045323c52ad911534cff00ed" }, { "id": "bool_3rows_rb_f0", @@ -1131,7 +1131,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000024edc7f8dd7034021d850b6485a80dc9ab5867f804c6299ed3fd8c166989aea29" + "expected_hash": "000002c467967f693c01b3bbb0f924e190d94884dc5db908a61185960c78e69843bebb" }, { "id": "bool_array_1_f0", @@ -1141,7 +1141,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026ff0c8a2aea22b471ee082f0f9e66f30f9994b09ea2d3623c1355daf7ae74e88" + "expected_hash": "000002dee12b05ca7ae8846ba2ee678edf4c2bebedea94bc4835a0530a76b7107cb2e2" }, { "id": "bool_array_2_f0", @@ -1151,7 +1151,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002e7fd44616d2602d1ea7db25f770f0d4e0905f935b65c6ecd412b82fa7cf40121" + "expected_hash": "00000279d7cb82ab7366f2452bfd63a48e7750a32b174153e5c13fb80f2336adb2dbff" }, { "id": "bool_1row_rb_f3", @@ -1161,7 +1161,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027b575c88cd22fbdddb8944d4774af3b0ab66cbcdece5510a394881932ac64a85" + "expected_hash": "000002603a9d732b4fcfb5c541cc34cf555700eae9bc784f1134ba92f4b9cad77fc891" }, { "id": "bool_3rows_rb_f3", @@ -1171,7 +1171,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026b64b994a93b6ecab6b739afb3584b04bb228518144138b91df0cd77f9193fb5" + "expected_hash": "000002cd74712d5e98d95dc6483bb7a4b138cab87599aafc4078a56113da4ea2ddf96b" }, { "id": "bool_array_1_f3", @@ -1181,7 +1181,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002bb184a7f992ecf751cb1d32c00360eb32ca6015f3eaa7f4b62926f839894f9ce" + "expected_hash": "0000029c417b86f36a682f15febad4cf56d2fab64955343f01947d2fc7f2d85f3c624b" }, { "id": "bool_array_2_f3", @@ -1191,7 +1191,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022bfab5ca77eb2d9831200ddca6994409f75ae68d7558757a5b53183b2f0e4217" + "expected_hash": "000002e021597c0c578e92250e14aa209a20f98fea2f771b1f0d432934ebeb2d060246" }, { "id": "bool_nullable_rb_f0", @@ -1201,7 +1201,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45" + "expected_hash": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92" }, { "id": "bool_nullable_stream_f0", @@ -1211,7 +1211,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000026e498ca56275a1ec0f864b549100f8bdba5de4b9b826aff1720a40b25b368d45" + "expected_hash": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92" }, { "id": "bool_nullable_rb_f3", @@ -1221,7 +1221,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002a07b77e36c7d66633230f1a9204bcfea6a5456d77bb84da747c084d790a5e321" + "expected_hash": "0000023346eede62527944ffd5add8c56010873cc2cb8b3fe8a10177559ebb7abdb365" }, { "id": "bool_nullable_stream_f3", @@ -1231,7 +1231,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002a07b77e36c7d66633230f1a9204bcfea6a5456d77bb84da747c084d790a5e321" + "expected_hash": "0000023346eede62527944ffd5add8c56010873cc2cb8b3fe8a10177559ebb7abdb365" }, { "id": "names_schema_f0", @@ -1241,7 +1241,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "000002423c1e37af8c6fa77dbb0c8df920f6af969fd6398a804fc2656e73488c0102ab" + "expected_hash": "00000266430e24680d87a4279fd531bb8c02340f72b05682da212f5d525b0f7d3e147d" }, { "id": "names_array_struct_f0", @@ -1251,7 +1251,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002cf1133b1070ab1b15f56e2013e4c4fe7a560d94d359c07868c42e4cfadfbe728" + "expected_hash": "00000219e467d0280ccc83ad4c67e063997344cedd781f6cb4e449d03d713c989aa12b" }, { "id": "names_schema_f1", @@ -1261,7 +1261,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "00000208fcc9eae81e4072d484bda90504f7ec75253b050722e0b001829a46cc2c9756" + "expected_hash": "00000243e86acd4c8280d660a2d9d195ac84e24cc5b2e32cdb98a149cf96b90fb00cd2" }, { "id": "names_array_struct_f1", @@ -1271,7 +1271,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000022a408eab093882422f42e11eef4d01a9705bb3b49a8932dc0005d8976e839e00" + "expected_hash": "000002804e03e0e3a2f206695994b8981023659f80f059c3846f7e0129984e825ffefe" }, { "id": "names_schema_f3", @@ -1281,7 +1281,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAQAAADUAAAAlAAAAEwAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAEAAAAa20vaAAAAACQ////EAAAABgAAAAAAAACFAAAAID///8gAAAAAAAAAQAAAAAJAAAAYQpiGwkicSJcAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAABgAAAOWQjeWJjQAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAD/////AAAAAA==", - "expected_hash": "000002b6b15853f87b8e68918955cb1ebce961f5da388f2f98e91e9d41bfb3a929e94a" + "expected_hash": "0000022ae8b1738e6d60639997d031f836ff00ad648ae80338ed8842165a7dc6c9e194" }, { "id": "names_array_struct_f3", @@ -1291,7 +1291,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000254b2c8adca9a81bd352340688113ac024f0f541898586a236c7d446929360dd1" + "expected_hash": "00000239b35cec44b0388712b60c7552f76a70ce9389090c309745cb69ff6d4a70e69f" }, { "id": "names_array_struct_int8_f0", @@ -1301,7 +1301,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAgAAAMOpAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029bdeaab1cdeabaffbe83de8f6bc0f2b4698050d17d47ed3707705c490a3ca11e" + "expected_hash": "000002360ce1cbd543917fa1444b88470e60303ba415e829d29754bdc20d1f9be2c4a0" }, { "id": "fsl_int_schema_f0", @@ -1311,7 +1311,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002e04a62c05b99b0fce4b391ba58561f4a9df1e92319baaf3644496ad6e4209dcc" + "expected_hash": "0000022fe3f8d8fcba7e393f3c5808894db2f930a8bd8388e9d04b3763d369cc6eae88" }, { "id": "fsl_int_schema_f1", @@ -1321,7 +1321,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAABBkAAAAAQAAACQAAAAAAAYACAAEAAYAAAACAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026c0f3381c1659e4c0fc37d0e00d11b2c901b4ee97efc81fbab85bdabc0ab5c05" + "expected_hash": "0000021025d6b1094cff9fe38507c3084f946706d87c3ea3e75450eea8f90dda88c1ae" }, { "id": "list_kv_ab_rb_f0", @@ -1331,7 +1331,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002a83e96153c214d6ed310666a91cc8c9e2dc8d885e8ef29eaa6d2fa3d2dee00b9" + "expected_hash": "000002fcc4a6000e54c88f15ce378526d2aaeb6257909dcda76889744ad3fe18e3d5e1" }, { "id": "list_kv_ba_rb_f0", @@ -1341,7 +1341,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000247a75ef3e08557f7535e36cdc15aa9da00acd0e4c7d776c4758f9297c8ed2b06" + "expected_hash": "0000024f30d74a4ecc5859895de78ae95fae3802012a4d6f1bd287c18dda362d11d54a" }, { "id": "list_kv_ab_rb_f1", @@ -1351,7 +1351,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002c698e900b998f58ae155ac23d899c5bcb337098a7cf50dfdafc8c73c1988da48" + "expected_hash": "000002de72c4fd435d790c5de13417fb3d095234f8dc758c3f5e98f69da140df633991" }, { "id": "list_kv_ba_rb_f1", @@ -1361,7 +1361,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000216d4dd6267ab5ce6a72315a1af3fc2d894dde4a45fed41396842e7f3cd7f7289" + "expected_hash": "000002447bea7a601dfa82970dcbebc6329000e919834962a41b80bf828129833cf1a7" }, { "id": "list_kv_ab_rb_f2", @@ -1371,7 +1371,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000020ad24b15e8ffa67e671bfb59c8f0fd39292d925fe85a81b5e84c2fc2e444bf88" + "expected_hash": "000002e8507fd72e9443507bebbd5e1f6650a0e761f259fd4d0ebc28de1f0f045ae4c3" }, { "id": "list_kv_ba_rb_f2", @@ -1381,7 +1381,7 @@ "ordered_columns": false, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002592d2eebd2c4906930f49d7807a1a9932ac1a809c1b56d04b915501bb586b0d2" + "expected_hash": "000002f425dc7d65912c647b28863bdb42bdc25d0bfcf5d0bc0c00ad5ea1fdaf64979e" }, { "id": "list_kv_ab_rb_f3", @@ -1391,7 +1391,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f552cc5c5e5f7eb7994925045315f306437340586f9f7832b5280fe614620b91" + "expected_hash": "000002fc56f2b28899780f7ad99a1166f620767b834918ddc5be06ef06a4a03311c1d2" }, { "id": "list_kv_ba_rb_f3", @@ -1401,7 +1401,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAdP///xgAAAAMAAAAAAAADMAAAAABAAAAGAAAAGj///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAAVAAAAAgAAACc////yP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAFAAAAdmFsdWUAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABpdGVtAAAAAAIAAABrdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAIAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002dd17ed9dbd6f16c24eb8ae3a70b1937e3a3d87a1ed71afea21131a6dd962a8be" + "expected_hash": "000002a33d14f20c923bd3083eb2257edb5e89f216a3612d122e6d47adfb29409e2feb" }, { "id": "type_null_schema_f0", @@ -1411,7 +1411,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQEQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002d62f819d0655f1ca1c0fb2709da2c2e21f3ab1593a405c1063e2dcc22fa10af5" + "expected_hash": "000002ae91ac257762841aed12f8986a96ea10072d2e4573bb2cda0862d002bbe4e3b4" }, { "id": "type_boolean_schema_f0", @@ -1421,7 +1421,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002bf1bb213a02678908892fe2ad319eb1805155337f8f72fc3266eaf99617183f2" + "expected_hash": "000002013cdd44a14ee692b7d98d8909d5e2230a0b0375f03e2f1d64c51518567393d5" }, { "id": "type_int8_schema_f0", @@ -1431,7 +1431,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000002f2b11ea2df5836e3377ba522c83e8d4796b76e6b9af836c908eb97ca1d9c9ee9" + "expected_hash": "000002e8fa19e1f3e0f9ab96f3c77cfbe1b8a2eb42f0e41af3f9b61c76fd894636e82a" }, { "id": "type_int16_schema_f0", @@ -1441,7 +1441,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000002fc7961c4b03e7a2a604e0c653b487b48b1bd13b2e2bfa616625ccd54d4380e04" + "expected_hash": "0000028103d67a1b84d9305488727baf6a5f9662278a49cfccda2c441a9f6fca337cfe" }, { "id": "type_int32_schema_f0", @@ -1451,7 +1451,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000002f48ea32296b9c2e0cf348606101abdc2dbc4a3101cce917da7fec025241b46ac" + "expected_hash": "0000021ce5d36566850439ffb338c1e4c5aae756e8250ffe681803328c75951f55914a" }, { "id": "type_int64_schema_f0", @@ -1461,7 +1461,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "0000027a23f6870e469f67974b74770c0c4256977e36c80f4142071129c786faaeb546" + "expected_hash": "000002b4753897cdef0036ac4ae0397dd4de049e0644effb0acad9bd5c57ea606f7c7e" }, { "id": "type_uint8_schema_f0", @@ -1471,7 +1471,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a5e423efe3ddad13f6c9d3da7093f44a9336879531fe36db98772ce70a23fc10" + "expected_hash": "000002722f2dbfd37702f6d2b38b5ee134eaa4d8d0c473f26a6fa9c9accdf5ff738bf0" }, { "id": "type_uint16_schema_f0", @@ -1481,7 +1481,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000216568c9ca5484137a316794c1af7741ba2054d2352e728f2f260f5d27ca696b4" + "expected_hash": "000002ac3e91bd728f7101209ba7cda9f99e9ba4bdbdae19a7ec52a945377246041842" }, { "id": "type_uint32_schema_f0", @@ -1491,7 +1491,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023cbc740e1382c5c1b0c5d6c4f8700c3c3fc38aa1e027f7332850987a53622f65" + "expected_hash": "000002bdf9bea09e68f1e94c2903c635806055578a8e959f674ebb5fcc91d2950299cf" }, { "id": "type_uint64_schema_f0", @@ -1501,7 +1501,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b338597d9c1f743d2b822b3ed4632632596ccadcc3dd63a3c34a8c4750b2adad" + "expected_hash": "0000029d53ed8a06173c17c1d5c3ac7c05e664906f4c38705b6d42531535b85516196a" }, { "id": "type_float16_schema_f0", @@ -1511,7 +1511,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAUAAAAFAAAAAAAAQMQAAAABAAEAAQAAAAAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002d594fa2f108350ff54de3b6c52c9aaf7e0205a9470db2431963052029c704557" + "expected_hash": "000002fe84148cb5b19a35c8d7f0f74fb999dfbe73b39eb9d175acc56a68496bcae3c9" }, { "id": "type_float32_schema_f0", @@ -1521,7 +1521,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000020f83fab9cf3e29428d8a06c8ebf814ad97179430798696eca196deddd5785e64" + "expected_hash": "000002cd80a7aa2d0d65df7a9b49fd4553e7810379df991305ec129049e3706dd27490" }, { "id": "type_float64_schema_f0", @@ -1531,7 +1531,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000028212ede094399bb7b21174e93890d671bcd092a21bbf13a7699f45e635ab6b85" + "expected_hash": "000002603514e8bc5a8e579d7fdb7e06bb05a7eaebaf38f91f474e2844dd34cdaa0747" }, { "id": "type_date32_schema_f0", @@ -1541,7 +1541,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024e1f6ad045cfba15f60e1d2e5f48194091885c578a9772e49fb108a8c53c3edd" + "expected_hash": "00000202c0525336a81e428a90c726eb51a62bd8753aa055f0aad2df8b472e42f2b5dd" }, { "id": "type_date64_schema_f0", @@ -1551,7 +1551,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000247f383c084cb2540482ef193d29b2797cbfdc00647d0149bba4abf15b9d5e51d" + "expected_hash": "000002fedf19b8af467ee7acec8f738218feab196b07826821198b909bc82537e8f924" }, { "id": "type_time32_s_schema_f0", @@ -1561,7 +1561,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002ba4c1ac02ac91418da73d12294a484feda0527423664c059676c605847d6c18c" + "expected_hash": "000002fa87e7ebb1972366c69da6e6656c5ae10c89906a9110bfb2764346f0b49c5228" }, { "id": "type_time32_ms_schema_f0", @@ -1571,7 +1571,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000240cb860fa8c49f36e13149eafe5e45bdae2c2f9be6fe6a571e85a76ddc223dd2" + "expected_hash": "000002e83f805720c95bd9f74201cea503c4a2b489dc84dc04dc1826aa81331cc774d1" }, { "id": "type_time64_us_schema_f0", @@ -1581,7 +1581,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAgBAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "000002a084f937c053322ca9690f6c1a40dd1675d7c010730c9fdcefa1911a5c6314a6" + "expected_hash": "000002d4b6344eb6e36da5864993f7884283fd9d5f81e2b5e2bf2ef7942beb98d41e9b" }, { "id": "type_time64_ns_schema_f0", @@ -1591,7 +1591,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "0000029d6c2cda4d46a9522b83168856482f149953428bd0f51b08384b764f198424af" + "expected_hash": "000002c3d16ff0a20bd9e420a4a851018bb2e445ab4ae8973902b331a6312741ed7559" }, { "id": "type_timestamp_s_naive_schema_f0", @@ -1601,7 +1601,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQoYAAAAAAAAAAQABAAEAAAAAAAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002410b6c31dbac2fabdb5893cf393be0fd7ce3ac603fa592b858608ba3582881ee" + "expected_hash": "000002a0bc2bf04f37e9838f02f8f948619c298300b9a8c0ed90a2d4aaa80627fa6209" }, { "id": "type_timestamp_ms_utc_schema_f0", @@ -1611,7 +1611,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQokAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAEAAwAAAFVUQwABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002baca673fe3de658299ed83026512cf3980dd2c323a3fb9e304a206bbb9efe632" + "expected_hash": "000002f5a5aaa5002a1db4a752adf89927683d31f2896bd795cbb4385434051f5cc1c7" }, { "id": "type_timestamp_us_offset_schema_f0", @@ -1621,7 +1621,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQooAAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAIABgAAACswNTozMAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002a63969413486c42e01fb9638f418f943b1e2749df379401a6db6174ece6c1bbd" + "expected_hash": "000002a8e4e8a46be0e1eee3876ae9f8996463c26f2020f36bd02dd5d15d063b9517cc" }, { "id": "type_timestamp_ns_named_tz_schema_f0", @@ -1631,7 +1631,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQo0AAAAAAAAAAgADAAKAAQACAAAAAgAAAAAAAMAEAAAAEFtZXJpY2EvTmV3X1lvcmsAAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000292879787e87c84632b13219bebcde6c59ed735eb58044f3d7df937ffcb234a9d" + "expected_hash": "00000257560dd4115945bb73829a8b42eb50c91441221b153e8e8af9cc741a98a1a9d2" }, { "id": "type_duration_s_schema_f0", @@ -1641,7 +1641,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002c326fa8a3ae288735a556905748c1db265771accb49a63570baf1e9d8547911f" + "expected_hash": "000002e37ba68db00a13fda1269115c93112e82f47e0001954736e0dbac6ec0478529a" }, { "id": "type_duration_ms_schema_f0", @@ -1651,7 +1651,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARIQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b9bcfd0c6c9e97f81abe2b49da844b275f8712c81f8281b86e9943b3588c1aeb" + "expected_hash": "000002deafca82c59e247745cff3aa1be6df4f079b034bb74688a2941d8bd9a8eb43d1" }, { "id": "type_duration_us_schema_f0", @@ -1661,7 +1661,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002325457512731593cd507ce3e7b011b9b7cca01dbd89e4f8920fb5994cf1d9d4a" + "expected_hash": "000002da4cfb6ead4c47fb7f40c73df8ba0ccf616d931461f48dadfb5a018772576078" }, { "id": "type_duration_ns_schema_f0", @@ -1671,7 +1671,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARIYAAAAAAAAAAAABgAIAAYABgAAAAAAAwABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b73ed03cd62dd09e683c4059fbc97b46a742744f8720fb82aab81773efd787f1" + "expected_hash": "0000021140c59d69e5aff07c4c9fb5acede1eb2f93529ed40b42ea04d1fd873764be0d" }, { "id": "type_interval_year_month_schema_f0", @@ -1681,7 +1681,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQsQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000027209e6136116fc005f13f750a66837a8452c92912e147a54904f45255a18a1d3" + "expected_hash": "00000244ddd18aa817bdda2931252ba87319aaebce9b5bd9ac1400f3bff958e6bfa92c" }, { "id": "type_interval_day_time_schema_f0", @@ -1691,7 +1691,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAQABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023aed3f6ad5f34d87f903ffb78bd76b8f289a61f8b60ee7902d9b981bbcc804c0" + "expected_hash": "000002d9e806587afcff2f7bf1e5bad572696f5fbfdb9ebf18813466549327b8d51211" }, { "id": "type_interval_month_day_nano_schema_f0", @@ -1701,7 +1701,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQsYAAAAAAAAAAAABgAIAAYABgAAAAAAAgABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a1ef89129cd30cf70f293c654a4f430bb84831156a0e26a82e2ce3b585a36297" + "expected_hash": "000002e8eb312e375f9c65f3b3d0d029b19f0eb41821c5efeca2a59c9e17a287a0d83b" }, { "id": "type_decimal32_schema_f0", @@ -1711,7 +1711,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAAAgAAAAAgAAAAkAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002dd15d65f2ad53b58d6f4275e9e02284c6b2b85a9bcfd57c9329d3378fe01b916" + "expected_hash": "00000227ac504a2ceb17222240736fabb8a9bc473adf914921def7d552f85d324326f7" }, { "id": "type_decimal64_negative_scale_schema_f0", @@ -1721,7 +1721,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQckAAAAAAAAAAAACgAQAAwACAAEAAoAAABAAAAA/f///xIAAAABAAAAYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000020b8bd50d5e34cc66422d123c8ecad9985eaa5aab934706793d797b10ffdd7ef1" + "expected_hash": "0000025307a5443dbf29dde69b92ea0a4cb4dd4edec402ab3f21f3757ca21ffb6f0ef4" }, { "id": "type_decimal128_schema_f0", @@ -1731,7 +1731,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQccAAAAAAAAAAgADAAIAAQACAAAAAoAAAAmAAAAAQAAAGMAAAD/////AAAAAA==", - "expected_hash": "00000230a8ad8ccebbb0f61cf11f600222fe8afda9bb33bb883b3a1dcbffd691626e83" + "expected_hash": "00000265fcc9e37a235725f68d94bd5a384603416c4893ca8c7e68f1b24cabb2a10f99" }, { "id": "type_decimal256_schema_f0", @@ -1741,7 +1741,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQcgAAAAAAAAAAAACgAMAAgAAAAEAAoAAAAAAQAATAAAAAEAAABjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002adaac773e79c05738edbf6511ca2e2b78e5fbca6ed34ce50cb30dd50638e3437" + "expected_hash": "000002fb41d9fcaf8a1e416d559fa0b0c066e578dbb3ab5056732559faceba7c12d205" }, { "id": "type_fixed_size_binary_schema_f0", @@ -1751,7 +1751,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAYwAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002d7bb11b6df9b80954e3fd4bff19842697682f2092bd518e7866b51c4d82fab54" + "expected_hash": "000002f72c04377c44ba38abf0fc2b04cad73a66d97c290985810b594759b39e0e0751" }, { "id": "type_utf8_schema_f0", @@ -1761,7 +1761,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQUQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3" + "expected_hash": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66" }, { "id": "type_large_utf8_schema_f0", @@ -1771,7 +1771,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000022ce4aa5b52dc850cb13733a272ecbffd7f9ae5bed93225ecf44bcbfc4427c8d3" + "expected_hash": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66" }, { "id": "type_binary_schema_f0", @@ -1781,7 +1781,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e" + "expected_hash": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8" }, { "id": "type_large_binary_schema_f0", @@ -1791,7 +1791,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARMQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f284a0be421bdb8d043b328bb957b34011915b605b6dc07454b5b7cad79dc53e" + "expected_hash": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8" }, { "id": "type_utf8_view_schema_f0", @@ -1801,7 +1801,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARgQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000227b6c1c19f55abb8f9c5397c44358179670b53e8cd0ac85c86a63efc077d3a45" + "expected_hash": "000002ae4524ad2af645eab4f9c6d0909c9361fd5b25f4381b6ef31aaf1edfcedf9ddf" }, { "id": "type_binary_view_schema_f0", @@ -1811,7 +1811,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARcQAAAAAAAAAAQABAAEAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000269474d2dcf14686b5e68081944c59dd48e9723ec46045ef79de008d9ee75a565" + "expected_hash": "000002f66721c03015a7ef24bb7d084e984c2e4e7e1246e9573dcbf0ef0819f3f0abd8" }, { "id": "meta_map_value_schema_f0_im1", @@ -1821,7 +1821,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f2ccfa54107bbf578a64ac6f09bf31d7c5eaab288c3b7003f8c0135d83928694" + "expected_hash": "000002e72a6e74a24550cd50f142e754901f4bd7aa2fbaf801ae1d8c1c7dbb49d6b83e" }, { "id": "meta_map_key_schema_f0_im1", @@ -1831,7 +1831,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b509290043f950377512a8c5d20d712ae470307a40f7be188e2acc048d52a444" + "expected_hash": "0000025e79da0f495b82e17ec4f2a2fdf191a6f92357073a0232f0f55ad7014b1401f6" }, { "id": "meta_map_entries_schema_f0_im1", @@ -1841,7 +1841,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002a2ea4c3e7aac3494e11cb4a863c257897c6fe24338111019718bb80f191e8f69" + "expected_hash": "000002e30b27b07b6518a7f089c4564e0bbdf34f6e566e83579764e8fc4873156b34c3" }, { "id": "meta_map_all_schema_f0_im1", @@ -1851,7 +1851,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", - "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + "expected_hash": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" }, { "id": "meta_struct_child_schema_f0_im1", @@ -1861,7 +1861,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000021bad8bde5a431b6ffdc4b426a99a2a753e1f877876bfa4f0dcfe6acd8380d258" + "expected_hash": "000002f99bf8ec8a139a00a36a06178b72829b3cd4b5200576b48c8a8f7dc1ef5f00f3" }, { "id": "meta_list_element_schema_f0_im1", @@ -1871,7 +1871,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022aa3f2d31d47e16368a06eef1caf2733b78453a3de28ee37db44e63f68ef0deb" + "expected_hash": "00000277f78b5887bf2face0b85767b991be1ce3da47b1cc4d1cdc334829087f4f1a8f" }, { "id": "meta_fsl_element_schema_f0_im1", @@ -1881,7 +1881,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", - "expected_hash": "0000023e3eb301b7a8196190729dcec01c5456493177faef4790e9433a61796acc78ce" + "expected_hash": "00000253583e73e2411cdfe9480e8ce880911d8b4d8fd64a190df43e5bcfe05dc31a0f" }, { "id": "meta_map_value_schema_f1_im1", @@ -1891,7 +1891,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARH8AAAAAQAAAAgAAAAs////WP///yAAAAAMAAAAAAAADdAAAAACAAAAoAAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABrZwAABAAAAHVuaXQAAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e76732f144114761329c7194b5d716c1b164f9fd57d4da254f863afb630c51cf" + "expected_hash": "00000253e505e95c4ad8f282aa77bcf40b16765a083d12c4c9d53e40ae68a8637312c3" }, { "id": "meta_map_key_schema_f1_im1", @@ -1901,7 +1901,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAArP///xgAAAAMAAAAAAABEQQBAAABAAAAGAAAAFT///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADcgAAAACAAAAZAAAABgAAACI////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlABIAGAAUAAAAEwAIAAAADAAEABIAAAAoAAAAGAAAAAwAAAAAAAAFEAAAAAAAAAAEAAQABAAAAAMAAABrZXkAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000025611a6f49df4c4e65a895f2209dcfe7b6e957cd41b2e7085274f6e6b1dccf68b" + "expected_hash": "000002a8f5cf7e6b91be0295d993bcbd390aca1f760f0b372542835fd33e0a4ce90555" }, { "id": "meta_map_entries_schema_f1_im1", @@ -1911,7 +1911,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xwAAAAMAAAAAAABERABAAABAAAAIAAAAAQABgAEAAAAAAASABgAFAAAABMACAAAAAwABAASAAAAsAAAABwAAAAMAAAAAAAADZQAAAACAAAAZAAAABgAAACM////EAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQAHAAAAZW50cmllcwABAAAADAAAAAgADAAIAAQACAAAAAgAAAAQAAAABQAAAHBhaXJzAAAABAAAAHJvbGUAAAAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029051855dd7d48ad692cb5ffecf76ffb4509e295b6d066a8530b3f8aa24110de3" + "expected_hash": "0000025ef8e7c3170ab5e170f2c2b8d7b77387d75ad36f4839a3744abfc65a9e2ea55d" }, { "id": "meta_map_all_schema_f1_im1", @@ -1921,7 +1921,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", - "expected_hash": "0000025b1546156ad74adefaf9a90a7934731b3e7aaf1fc7554ad9ed31b631dfd31711" + "expected_hash": "000002c1c097d82552031e54c21b51c6cf949cf3c06ffb2a97d03fa406b5c6ea362883" }, { "id": "meta_struct_child_schema_f1_im1", @@ -1931,7 +1931,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA2P///yAAAAAMAAAAAAAADcwAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAEAAAABgAAAAAAAACFAAAAMD///8gAAAAAAAAAQAAAAABAAAAYgASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAbQAAAAQAAAB1bml0AAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000028eefb9d2aac3ca46e0063567f507b88597c200263316433ee0a3ab7c0a455a83" + "expected_hash": "0000020b6be72d5ed5a3e707ed0987da88d5159fad1e49efbd4b65ac54cf6cd8d14ad1" }, { "id": "meta_list_element_schema_f1_im1", @@ -1941,7 +1941,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQyUAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAABAAAAHVuaXQAAAAAAQAAAGwAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000029865426d25592eb80b7c223b9ad2688b557e6aab5963c5788bed1ccdc42fc5ea" + "expected_hash": "00000222ad2565aa0ac5b76e6c37fca1dc25079ec5cedadbbfe2839b5371271eff9e4b" }, { "id": "meta_fsl_element_schema_f1_im1", @@ -1951,7 +1951,7 @@ "ordered_columns": true, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAARCcAAAAAQAAACgAAAAAAAYACgAEAAYAAAACAAAAAAASABgAFAASABMACAAAAAwABAASAAAAOAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAQAAAHMAAAAEAAAAdW5pdAAAAAABAAAAZgAAAP////8AAAAA", - "expected_hash": "00000207a7f6f53345f59a6236f6e097b592ed2ee311ee3fdb45aabee1add7f63d0801" + "expected_hash": "000002b7df9a84f9fc083ba5ea3af2bf52039a3e12aa361b9fa76560df38e958ca8098" }, { "id": "no_metadata_include_false", @@ -1961,7 +1961,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAA/////wAAAAA=", - "expected_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1" + "expected_hash": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3" }, { "id": "schema_level_metadata", @@ -1971,7 +1971,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAA0AAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAAAyAAAABwAAAHZlcnNpb24AAQAAABQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAABAAAAAAAAAAQAAAAACAAAAaWQAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002c2cd6a73cf9a5cf24ce01fd184b7485e55a2c443e543fd981bf32929fb0cf234" + "expected_hash": "000002947adb029bfa2139d1cf5c2c34c2aeb4798be4154484f01368d3a4b0e9f3cbcc" }, { "id": "field_metadata_single_field", @@ -1981,7 +1981,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000020b130367ff66564f4f9978ca3e506e3e305d12cb6ff6ae2c4fe747a2cc7bd5f2" + "expected_hash": "000002ae0dd1f0e4e372edb7c1c2e03cad21aaf0fca9e1a8415016218242cc5d83b0ab" }, { "id": "field_metadata_multiple_fields", @@ -1991,7 +1991,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAACIAAAAGAAAAAAAEgAaABQAAAATAAgAAAAMAAQAEgAAADAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAeQAAAAEAAAAEAAAAkP///wgAAAAMAAAAAQAAAG0AAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAADQAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002e03369228220921177c5c578c461e3916b6ef44bb21e32c216ef6c0925429e88" + "expected_hash": "000002557839de98aded74876685e0bee6cf73f79ec9ade25ce0767505720fe453881d" }, { "id": "schema_and_field_metadata", @@ -2001,7 +2001,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAABBAAKAAwAAAAIAAQACgAAAAgAAAAsAAAAAQAAAAQAAACE////CAAAAAwAAAABAAAAMQAAAAcAAAB2ZXJzaW9uAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027eda76a93d2e60bc24c6eaee85eb53a24199dc58a9e15cfb483df94f2ecfef02" + "expected_hash": "00000269fa67810dd0ffea5b7f22d32ba797bf4e1213d935d782046442334f9186ef9b" }, { "id": "unicode_metadata", @@ -2011,7 +2011,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAALAAAABgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAEAAAAZGF0YQAAAAACAAAAOAAAAAQAAADY////CAAAABQAAAAJAAAA5pel5pys6KqeAAAABgAAAOS4reaWhwAACAAMAAgABAAIAAAACAAAABQAAAAJAAAAdmFsdWVf4pyTAAAADgAAAGVtb2ppX2tleV/wn5SRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002d82b81b3e7338563c258ad4df581c4033d24fa73ca8c533d943b2f6890e7c9bf" + "expected_hash": "0000027a667866945ffee424dec01ad00c7d6661329182b0991c28226f22e7ecf4c641" }, { "id": "key_reorder_canonical", @@ -2021,7 +2021,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAMAAABUAAAAKAAAAAQAAADA////CAAAAAwAAAABAAAAMwAAAAUAAABnYW1tYQAAAOD///8IAAAADAAAAAEAAAAyAAAABAAAAGJldGEAAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAMQAAAAUAAABhbHBoYQAAAP////8AAAAA", - "expected_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e" + "expected_hash": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed" }, { "id": "key_reorder_shuffled", @@ -2031,7 +2031,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAAAABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAeAAAAAMAAABUAAAAKAAAAAQAAADA////CAAAAAwAAAABAAAAMwAAAAUAAABnYW1tYQAAAOD///8IAAAADAAAAAEAAAAyAAAABAAAAGJldGEAAAAACAAMAAgABAAIAAAACAAAAAwAAAABAAAAMQAAAAUAAABhbHBoYQAAAP////8AAAAA", - "expected_hash": "000002abd761907e2c74305cebc235664ae08543b4d481ec4c968f30edbd456cc2a94e" + "expected_hash": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed" }, { "id": "empty_metadata_invariant", @@ -2041,7 +2041,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAA/////wAAAAA=", - "expected_hash": "0000022d143e0d93a0eceafb6a0e24e3645eb92ea97bc77975408c7ec66035c75e93f1" + "expected_hash": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3" }, { "id": "name_list_item_rb_f0_im1", @@ -2051,7 +2051,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAyQAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAAAQAAAHUAAAABAAAAbAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000283422b18f431bd7741e5ba6cbf89ff3a21193b7e139680d5459c4dcba7832418" + "expected_hash": "0000024f19ee8cdd0a37b10f2c6fba59ab8b1d3dee84d1f87a7a6f261c73f74fa010a1" }, { "id": "name_list_element_rb_f0_im1", @@ -2061,7 +2061,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAyQAAAAAQAAACAAAAAEAAYABAAAAAAAEgAYABQAEgATAAgAAAAMAAQAEgAAADgAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABwAAAGVsZW1lbnQAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAADAAAAAEAAABzAAAAAQAAAHUAAAABAAAAbAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000283422b18f431bd7741e5ba6cbf89ff3a21193b7e139680d5459c4dcba7832418" + "expected_hash": "0000024f19ee8cdd0a37b10f2c6fba59ab8b1d3dee84d1f87a7a6f261c73f74fa010a1" }, { "id": "name_map_standard_schema_f0_im1", @@ -2071,7 +2071,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARE4AQAAAQAAABgAAAAg////EAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAAA38AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAnP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAADAAAAAgADAAIAAQACAAAAAgAAAAMAAAAAgAAAGlkAAAEAAAAcm9sZQAAAAAHAAAAZW50cmllcwABAAAAbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + "expected_hash": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" }, { "id": "name_map_custom_schema_f0_im1", @@ -2081,7 +2081,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAREwAQAAAQAAABgAAAAk////EAAUABAAAAAPAAQAAAAIABAAAAAgAAAADAAAAAAAAA34AAAAAgAAAJQAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA0AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB2AAAAAQAAAAQAAACc////CAAAAAwAAAACAAAAa2cAAAQAAAB1bml0AAASABgAFAAAABMACAAAAAwABAASAAAAKAAAABgAAAAMAAAAAAAABRAAAAAAAAAABAAEAAQAAAABAAAAawAAAAEAAAAMAAAACAAMAAgABAAIAAAACAAAAAwAAAACAAAAaWQAAAQAAAByb2xlAAAAAAIAAABrdgAAAQAAAG0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + "expected_hash": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" }, { "id": "name_map_entries_meta_schema_f0_im1", @@ -2091,7 +2091,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARFYAQAAAQAAAAgAAAAs////Xv///xABAAAgAAAADAAAAAAAAA30AAAAAgAAAJgAAAAgAAAABAAGAAQAAAAAABIAGAAUABIAEwAIAAAADAAEABIAAAA4AAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAUAAAB2YWx1ZQAAAAEAAAAEAAAAaP///wgAAAAMAAAAAgAAAGtnAAAEAAAAdW5pdAAAEgAYABQAAAATAAgAAAAMAAQAEgAAACgAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAAAwAAAGtleQABAAAABAAAAMz///8IAAAADAAAAAIAAABpZAAABAAAAHJvbGUAAAAABwAAAGVudHJpZXMAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAEAAAAAUAAABwYWlycwAAAAQAAAByb2xlAAAAAAEAAABtAAAAAAAAAP////8AAAAA", - "expected_hash": "0000024e907e0c8e5ba102a32c4716e849d89221da426457b27f6fad566e7d5227c727" + "expected_hash": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" }, { "id": "name_dict_int8_rb_f0", @@ -2101,7 +2101,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAQAAAADQAAAAAAAAFEAAAADQAAAAIAAgAAAAEAAgAAAAMAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABAAEAAQAAAABAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAADAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b95312b46f1b45bbf80d43dbea467cc0f3341aed8e31b3c0b3532ff27e0e8c2d" + "expected_hash": "000002f219e560a2d1045160dc48a55e11e8887cb74a99b623d7db0865e3b5074980a3" }, { "id": "name_dict_int32_ordered_rb_f0", @@ -2111,7 +2111,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAaABQAAAAPAAQAEAAIABAAAABIAAAAPAAAAAAAAAUUAAAAPAAAAAAACgAMAAAACAAHAAoAAAAAAAABDAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQABAAEAAAAAQAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAADAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002b95312b46f1b45bbf80d43dbea467cc0f3341aed8e31b3c0b3532ff27e0e8c2d" + "expected_hash": "000002f219e560a2d1045160dc48a55e11e8887cb74a99b623d7db0865e3b5074980a3" }, { "id": "ext_uuid_rb_f0_im0", @@ -2121,7 +2121,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAAB1AAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + "expected_hash": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" }, { "id": "ext_uuid_storage_rb_f0_im0", @@ -2131,7 +2131,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAdQAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + "expected_hash": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" }, { "id": "ext_point_rb_f0_im0", @@ -2141,7 +2141,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAcAAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA0AAABleGFtcGxlLnBvaW50AAAAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAUAAAACgAAAHsiZGltcyI6MX0AABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + "expected_hash": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" }, { "id": "ext_point_storage_rb_f0_im0", @@ -2151,7 +2151,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + "expected_hash": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" }, { "id": "ext_uuid_rb_f0_im1", @@ -2161,7 +2161,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAAB1AAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022010d79ac4e8927002e34b59113123c9a7fd7c6eb163fb99e00e53f894200592" + "expected_hash": "000002ca148a2e68b471062c6e7ed9c4c2a3a6ee92fe0d3805f1f92184598253a3e85b" }, { "id": "ext_uuid_storage_rb_f0_im1", @@ -2171,7 +2171,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ8YAAAAAAAAAAAABgAIAAQABgAAABAAAAABAAAAdQAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBwcHBwcHBwcHBwcHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000263965df166153e929115f42374b452e4d1bc9991a7b58754a3769ff8250d978d" + "expected_hash": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" }, { "id": "ext_point_rb_f0_im1", @@ -2181,7 +2181,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAANAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAcAAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA0AAABleGFtcGxlLnBvaW50AAAAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAUAAAACgAAAHsiZGltcyI6MX0AABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027e3a814a74f801c73faebfca7c556d8de3f238e3bf889f6970d73fcb05c1510a" + "expected_hash": "000002afd27bf348c998c8887f50b0a0cb68b267dd88df01da348ee0b08891379c4957" }, { "id": "ext_point_storage_rb_f0_im1", @@ -2191,7 +2191,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000026d844672549315e3e70953d80f00d23fe1812e18773501829059ff539376cec0" + "expected_hash": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" }, { "id": "empty_struct_1row_rb_f0", @@ -2201,7 +2201,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA0QAAAAAAAAAAQABAAEAAAAAQAAAGUAAAAAAAAAAAAAAAAAAAD/////eAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002be4b2b6cc8d07d170e65ef733c5fb0a1815debbb7e5359e7fbe3d7c0c3061a6d" + "expected_hash": "0000025b9596ac0d5dc5e8a2ae603e04c3b0f5695375b256bdd7095c9b51e0814dcd24" }, { "id": "empty_struct_2rows_rb_f0", @@ -2211,7 +2211,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA0QAAAAAAAAAAQABAAEAAAAAQAAAGUAAAAAAAAAAAAAAAAAAAD/////eAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002ebda3848a7c2967e0de3d1be8074588fb46d03e6198015e97dbb21ca5c69090a" + "expected_hash": "0000021636f6baaccd50c67dedb2222ec5652222d01e2a892db8970aa408203a7a969b" }, { "id": "nested_null_inner_list_rb_f0", @@ -2221,7 +2221,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002bb8a3a08b13b4b69360bf7bbe98cfdb3ade364d346d382833a32d5a8da4693d5" + "expected_hash": "0000021e8d72a56f40f4232502b6ddbcb34190230a8becee8b12b80749d1660108724b" }, { "id": "nested_empty_inner_list_rb_f0", @@ -2231,7 +2231,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAyIAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f9a5269ea92b74cd7989fe86e996deb25a29f642b9593ece125da69d88fac58e" + "expected_hash": "000002032cd8892cf7c5fb1f48fa368fb97f9a4fe5dbae881ea76cc7d3b376c5aa72da" }, { "id": "depth4_rb_f0", @@ -2241,7 +2241,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAzYAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAABDawAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAEMhAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABAAAAGl0ZW0AAAAAAQAAAHYAAAAEAAAAaXRlbQAAAAABAAAAZAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABAAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002d3b145fa59fb21f4d8ba08d7e106467deb7a34c8f0d3bf1337a8535e941bd800" + "expected_hash": "0000024e70410d1fbcf7125cb5869c2e52f4eb6164a2db360abf56132992baded0ab72" }, { "id": "depth4_rb_f3", @@ -2251,7 +2251,7 @@ "ordered_columns": true, "ordered_struct_fields": true, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAzYAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAABDawAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAEMhAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAABAAAAGl0ZW0AAAAAAQAAAHYAAAAEAAAAaXRlbQAAAAABAAAAZAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABAAAAAAAAAAQAEAAAAAAAABAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002ec115c0ea4fb82a4ffb8bb08f832aa9e2e43c39733a200d6a05408972fab3899" + "expected_hash": "000002b2c471d31fd1a5aeba30d713a5cfde4248b4bfb9783b405cd87200ca972bcbdc" }, { "id": "list_in_struct_rb_f0", @@ -2261,7 +2261,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABDYQAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAgAAAAAAABAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000232db5d9adfd7fff17cef5441b385214fb327d12959c91740b07a75408ac436d4" + "expected_hash": "000002e1a72384de35cdf6b30c2fcb5c3ce4cbdbd48893fe63a51fc56702cf52d68b16" }, { "id": "null_list_slot_with_values_rb_f0", @@ -2271,7 +2271,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAGIAAABjAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002e85d0e5a5b04ff2164ff8f57d98f1c7aebfb6bc689d1d06d91764af79f64702b" + "expected_hash": "00000260d928527fcec14757ec61388ce41a91d63226f0429eaf5970b5b8b483caea5a" }, { "id": "null_list_slot_empty_rb_f0", @@ -2281,7 +2281,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002e85d0e5a5b04ff2164ff8f57d98f1c7aebfb6bc689d1d06d91764af79f64702b" + "expected_hash": "00000260d928527fcec14757ec61388ce41a91d63226f0429eaf5970b5b8b483caea5a" }, { "id": "struct_null_hides_5_rb_f0", @@ -2291,7 +2291,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + "expected_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" }, { "id": "struct_null_hides_6_rb_f0", @@ -2301,7 +2301,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + "expected_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" }, { "id": "empty_list_rb_f0", @@ -2311,7 +2311,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024fcb565252f9418a8eed4b700cb58a0bf30917b787bb30f43a451c4c0ec0511a" + "expected_hash": "0000023e1e7782881c99015db80e75c5022d0e4e173fb75b58f403b37d81cc87c37aad" }, { "id": "null_list_rb_f0", @@ -2321,7 +2321,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAAAQAAAGwAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023f7fff0c51cc55ba029e93647178320eb86822c0f906dbb48983bacedd19508e" + "expected_hash": "0000028fa28d8bd77393a4b5eec8440bb37e7cad92ac780cf9496a16aac487f0536cc2" }, { "id": "dict_null_unused_dup_rb_f0", @@ -2331,7 +2331,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAAEAAAAAAAAECEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAUAAAAAAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAYwAAAAAAAAAeAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000226c56c574822d3dcea32d8ad6066970e38d4d203319ef234350283e35bf069b0" + "expected_hash": "00000253ac95a2126faff99f0883443caf8148d98c6c111e687d8f167aeb8cf3edb28e" }, { "id": "dict_null_unused_dup_plain_rb_f0", @@ -2341,7 +2341,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAACAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000226c56c574822d3dcea32d8ad6066970e38d4d203319ef234350283e35bf069b0" + "expected_hash": "00000253ac95a2126faff99f0883443caf8148d98c6c111e687d8f167aeb8cf3edb28e" }, { "id": "dict_same_keys_other_values_rb_f0", @@ -2351,7 +2351,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAAEAAAAAAAAECEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAAAQAAAHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAUAAAAAAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAAAAAAYwAAAAAAAAAeAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002bfe6f457dc24215c98f6b0a115b02551c7f061a7ced4163034baf7e78eb8a009" + "expected_hash": "000002af97f3ab1aa4341a2515f97de07d7b5859440dccee1a1a0447764a00b0095c4f" }, { "id": "list_dict_rb_f0", @@ -2361,7 +2361,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAlP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAHAAAAAwAAAAAAAAMfAAAAAEAAAAcAAAABAAEAAQAAAAQABgAFAAOAA8ABAAQAAgAEAAAADgAAABAAAAAAAABAhAAAAA4AAAACAAIAAAABAAIAAAABAAAAPT///8gAAAAAAAAAQgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAGMAAAAAAAAAHgAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABQAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002df102beda16264a918f04162e0eb6b2efc0f14b1029657ba996ce60bd39aeec1" + "expected_hash": "000002951df50c18d2e83009c1084a63f60fcba7082719400aade93421887e2ba782ac" }, { "id": "list_plain_rb_f0", @@ -2371,7 +2371,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACgAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002df102beda16264a918f04162e0eb6b2efc0f14b1029657ba996ce60bd39aeec1" + "expected_hash": "000002951df50c18d2e83009c1084a63f60fcba7082719400aade93421887e2ba782ac" }, { "id": "list_dict_sliced_rb_f0", @@ -2381,7 +2381,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAlP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAHAAAAAwAAAAAAAAMfAAAAAEAAAAcAAAABAAEAAQAAAAQABgAFAAOAA8ABAAQAAgAEAAAADgAAABAAAAAAAABAhAAAAA4AAAACAAIAAAABAAIAAAABAAAAPT///8gAAAAAAAAAQgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAGMAAAAAAAAAHgAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000216640c77eda7d4ca8ea6cfb8e5116a03f0107e49b01297ef030a02476797c10d" + "expected_hash": "000002f73821d0ed4e08eace96e4c3967cb5c4a30e73184360bf3b4e3f17efbd334dd4" }, { "id": "list_plain_sliced_rb_f0", @@ -2391,7 +2391,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000216640c77eda7d4ca8ea6cfb8e5116a03f0107e49b01297ef030a02476797c10d" + "expected_hash": "000002f73821d0ed4e08eace96e4c3967cb5c4a30e73184360bf3b4e3f17efbd334dd4" }, { "id": "list_struct_dict_rb_f0", @@ -2401,7 +2401,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAdP///wQAAAABAAAABAAAAOD///8YAAAADAAAAAAAAAy0AAAAAQAAABgAAADQ////EAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAA14AAAAAQAAABwAAAAEAAQABAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAAEAAAAAAAAADEAAAADgAAAAIAAgAAAAEAAgAAAAMAAAACAAKAAQACQAIAAAAIAAAAAABBgAIAAYABgAAAAAAAgAAAAAAAQAAAGYAAAAEAAAAaXRlbQAAAAABAAAAbAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAgAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgPwAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAEwAAAAQAAAAAgAAAAAAAAAAAAAAAwAAAAIAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000268f11f1c1d2b9ee547edc62e0ebbb71d7712d16b95c1b30041a10707f83bf9cd" + "expected_hash": "0000026be3fe52e7473c5427d6631e64214bd791df16f1c2beeb9fc268f36eb40884c5" }, { "id": "list_struct_plain_rb_f0", @@ -2411,7 +2411,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAAADJAAAAABAAAAGAAAAND///8QABQAEAAAAA8ABAAAAAgAEAAAABwAAAAMAAAAAAAADVQAAAABAAAAHAAAAAQABAAEAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAABAAAAZgAAAAQAAABpdGVtAAAAAAEAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAAAAADgPwAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000268f11f1c1d2b9ee547edc62e0ebbb71d7712d16b95c1b30041a10707f83bf9cd" + "expected_hash": "0000026be3fe52e7473c5427d6631e64214bd791df16f1c2beeb9fc268f36eb40884c5" }, { "id": "list_list_dict_rb_f0", @@ -2421,7 +2421,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAaP///wQAAAABAAAAFAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAMsAAAAAEAAAAYAAAAfP///xAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEMdAAAAAEAAAAYAAAArP///xAAGAAUAA4ADwAEABAACAAQAAAAQAAAADQAAAAAAAEFEAAAADQAAAAIAAgAAAAEAAgAAAAMAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABAAEAAQAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAMAAAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAACwAAAAQAAAAAgAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAATAAAABAAAAABAAAAAAAAAAAAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024158ce1007c65d355cf1644d32abe212f8236f8d21ea58a9320b70ff800010e9" + "expected_hash": "000002ac5c10d1baa87b285918b4e1dbaf94d6116141299d4d1143f04758b6ac51d043" }, { "id": "list_list_plain_rb_f0", @@ -2431,7 +2431,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAx4AAAAAQAAAAgAAAC0////4P///xgAAAAMAAAAAAABDEwAAAABAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABBRAAAAAAAAAABAAEAAQAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAwAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAUAAAAAAAAAIABAAAAAAAAAwAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eXgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024158ce1007c65d355cf1644d32abe212f8236f8d21ea58a9320b70ff800010e9" + "expected_hash": "000002ac5c10d1baa87b285918b4e1dbaf94d6116141299d4d1143f04758b6ac51d043" }, { "id": "dict_of_struct_array_f0", @@ -2441,7 +2441,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAACwAAAAAAAANEAAAAHQAAAAIAAgAAAAEAAgAAAAEAAAAwP///yAAAAAAAAABAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAwAAAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAAPAAAABAAAAACAAAAAAAAAAAAAAACAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e3a21f5303e4921a2492cfbed2a4fb1562ef08040f22b80add07c74c4a6004fb" + "expected_hash": "0000026954b6975ed1333509d737413df196e9e2cccd1ad1abe5e3727f49a47e719ca1" }, { "id": "dict_of_struct_plain_array_f0", @@ -2451,7 +2451,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002e3a21f5303e4921a2492cfbed2a4fb1562ef08040f22b80add07c74c4a6004fb" + "expected_hash": "0000026954b6975ed1333509d737413df196e9e2cccd1ad1abe5e3727f49a47e719ca1" }, { "id": "dict_key_to_null_array_f0", @@ -2461,7 +2461,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAAEAAAAAAAAACEAAAADgAAAAIAAgAAAAEAAgAAAAEAAAA9P///yAAAAAAAAABCAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAAAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAAAsAAAAEAAAAAIAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000216a7d4c93bef3b7a6ac5af47a534c5fe0f5e9cbdd7629d688e4b01a8405d724b" + "expected_hash": "000002f3cb9cdcdfe5bf02a007141a4e2c770717536ddae50c30846c8f4ffb5df5a12e" }, { "id": "dict_key_to_null_plain_array_f0", @@ -2471,7 +2471,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAgAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000216a7d4c93bef3b7a6ac5af47a534c5fe0f5e9cbdd7629d688e4b01a8405d724b" + "expected_hash": "000002f3cb9cdcdfe5bf02a007141a4e2c770717536ddae50c30846c8f4ffb5df5a12e" }, { "id": "ext_custom_python_schema_f0_im1", @@ -2481,7 +2481,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAKAAAABgAAAAMAAAAAAABExAAAAAAAAAABAAEAAQAAAABAAAAZQAAAAIAAABMAAAABAAAAMT///8IAAAAGAAAAA8AAABvcmNhcG9kLm5kYXJyYXkAFAAAAEFSUk9XOmV4dGVuc2lvbjpuYW1lAAAAAAgADAAIAAQACAAAAAgAAAAYAAAADQAAAHsidmVyc2lvbiI6MX0AAAAYAAAAQVJST1c6ZXh0ZW5zaW9uOm1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025c65180626b6f291abd2cdfa7e333bd2fa22a49c756725f065f40d42747620c5" + "expected_hash": "000002c2405711658508f6d05bb7011a4de526b8754e5cc7c1d872fad755a2ddcb88e5" }, { "id": "ext_uuid_name_only_schema_f0_im1", @@ -2491,7 +2491,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAABlAAAAAQAAAAwAAAAIAAwACAAEAAgAAAAIAAAAFAAAAAoAAABhcnJvdy51dWlkAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002807125ef2f793c11e3c015a8eeafcec037c3e9d96963cd5d6570d289ec71f2fe" + "expected_hash": "000002f14382940d07ab355d30c3e52e0e8bd7a9dfba578fed90fd814e2c3a0548aa07" }, { "id": "ext_uuid_empty_metadata_schema_f0_im1", @@ -2501,7 +2501,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAMAAAABwAAAAMAAAAAAABDxgAAAAAAAAAAAAGAAgABAAGAAAAEAAAAAEAAABlAAAAAgAAAEgAAAAEAAAAyP///wgAAAAUAAAACgAAAGFycm93LnV1aWQAABQAAABBUlJPVzpleHRlbnNpb246bmFtZQAAAAAIAAwACAAEAAgAAAAIAAAADAAAAAAAAAAAAAAAGAAAAEFSUk9XOmV4dGVuc2lvbjptZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002807125ef2f793c11e3c015a8eeafcec037c3e9d96963cd5d6570d289ec71f2fe" + "expected_hash": "000002f14382940d07ab355d30c3e52e0e8bd7a9dfba578fed90fd814e2c3a0548aa07" }, { "id": "ext_tensor_canonical_schema_f0_im1", @@ -2511,7 +2511,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAeAAAACAAAAAMAAAAAAABEGAAAAABAAAAJAAAAAAABgAIAAQABgAAAAQAAAAQABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAQAAABpdGVtAAAAAAEAAABlAAAAAgAAAFgAAAAEAAAAuP///wgAAAAkAAAAGAAAAGFycm93LmZpeGVkX3NoYXBlX3RlbnNvcgAAAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAACAAMAAgABAAIAAAACAAAABgAAAAPAAAAeyJzaGFwZSI6WzIsMl19ABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002953966b9d16f403c2c5cdc37b6fdcb31e760ca7d9c4d7329120a8a491448d81d" + "expected_hash": "000002b56ac70e07b9d186d9f33fd6533423e31492c541c207e595cc7bd45de6ad57df" }, { "id": "empty_name_child_schema_f0", @@ -2521,7 +2521,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAAAAAAAAAAABAAAAcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024398254f34467d369ac87ee50160490a036583014f473c59672af76289f26f20" + "expected_hash": "000002f4c4b4f12d9c4c864fc79415620c964ccdb2ed70596c57e0ece56f45cdffd190" }, { "id": "empty_name_column_schema_f0", @@ -2531,7 +2531,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAAA0AAAABAAAALD///8QAAAAGAAAAAAAAAIUAAAAoP///yAAAAAAAAABAAAAAAEAAAB4AAAA3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002399b32197aaa8b631b1f0c6fb96284ebd93604410755ed454b446027d2b008b0" + "expected_hash": "00000235321696f80bfbbdc5aa40e47100ccd1729824b88c52057babcae9c9e0dfac93" }, { "id": "struct_nonnull_child_rb_f0", @@ -2541,7 +2541,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABhAAAAAQAAAHMAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAADAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002178ad205d340b789e89291b7cb467e21cd0efd09c240f625ef106db364881fbd" + "expected_hash": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" }, { "id": "pylit_testtemporaltypes_test_date64", @@ -2551,7 +2551,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQgQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnO8SfgEAAAAAAAAAAAAAAKTZ+v////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8" + "expected_hash": "00000273f2b0aeedb498d6980083f025b8e0c07c74c57c9130aabfed2af1b31e5ee0af" }, { "id": "pylit_testmultitypebatch_test_multi_type_schema_only", @@ -2561,7 +2561,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gFAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAABgAAABABQAA9AQAAKwEAABoBAAAOAQAAAQEAADUAwAAoAMAAHADAAA4AwAACAMAANgCAACsAgAAdAIAAEACAAD8AQAAxAEAAJgBAABkAQAAOAEAAAgBAACoAAAARAAAAAQAAAAw+///HAAAAAwAAAAAAAEHHAAAAAAAAAAIAAwACAAEAAgAAAAFAAAAJgAAAAoAAABkZWNpbWFsMTI4AABs+///GAAAAAwAAAAAAAEVQAAAAAEAAAAIAAAAYPv//4z7//8QAAAAGAAAAAAAAQIUAAAAxPv//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAoAAABsYXJnZV9saXN0AADM+///GAAAAAwAAAAAAAEMQAAAAAEAAAAIAAAAwPv//+z7//8QAAAAGAAAAAAAAQIUAAAAJPz//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABsaXN0AAAAACj8//8UAAAADAAAAAAAARQMAAAAAAAAABj8//8KAAAAbGFyZ2VfdXRmOAAAVPz//xQAAAAMAAAAAAABBQwAAAAAAAAARPz//wQAAAB1dGY4AAAAAHz8//8UAAAADAAAAAAAARMMAAAAAAAAAGz8//8MAAAAbGFyZ2VfYmluYXJ5AAAAAKz8//8UAAAADAAAAAAAAQQMAAAAAAAAAJz8//8GAAAAYmluYXJ5AAAc/f//FAAAAAwAAAAAAAAJFAAAAAAAAADM////AAADAEAAAAALAAAAdGltZTY0X25hbm8AUP3//xwAAAAMAAAAAAAACRwAAAAAAAAACAAMAAYACAAIAAAAAAACAEAAAAAMAAAAdGltZTY0X21pY3JvAAAAAJD9//8UAAAADAAAAAAAAAkMAAAAAAAAADj9//8NAAAAdGltZTMyX21pbGxpcwAAAMD9//8UAAAADAAAAAAAAAkQAAAAAAAAAE7///8AAAAADQAAAHRpbWUzMl9zZWNvbmQAAAD0/f//FAAAAAwAAAAAAAAIDAAAAAAAAACc/f//BgAAAGRhdGU2NAAAHP7//xQAAAAMAAAAAAAACBAAAAAAAAAAqv///wAAAAAGAAAAZGF0ZTMyAABI/v//EAAAABQAAAAAAAADEAAAANL///8AAAIAAAAAAAcAAABmbG9hdDY0ALj+//8YAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAAHAAAAZmxvYXQzMgCo/v//EAAAABQAAAAAAAACEAAAANr+//9AAAAAAAAAAAYAAAB1aW50NjQAANT+//8QAAAAGAAAAAAAAAIUAAAAxP7//0AAAAAAAAABAAAAAAUAAABpbnQ2NAAAAAT///8QAAAAFAAAAAAAAAIQAAAANv///yAAAAAAAAAABgAAAHVpbnQzMgAAMP///xAAAAAYAAAAAAAAAhQAAAAg////IAAAAAAAAAEAAAAABQAAAGludDMyAAAAYP///xAAAAAUAAAAAAAAAhAAAACS////EAAAAAAAAAAGAAAAdWludDE2AACM////EAAAABgAAAAAAAACFAAAAHz///8QAAAAAAAAAQAAAAAFAAAAaW50MTYAAAAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAhgAAAAAAAYACAAEAAYAAAAIAAAAAAAAAAUAAAB1aW50OAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAAgAAAAAAAABAAAAAAQAAABpbnQ4AAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAQAAABib29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee" + "expected_hash": "00000221f1240fabe97f742ddb3195193cf785f61e327b7d64ec7363bbbce399df7e50" }, { "id": "pylit_testmultitypebatch_test_multi_type_record_batch", @@ -2571,7 +2571,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "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", - "expected_hash": "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce" + "expected_hash": "000002cb129d9295971fe47548a28b3070f18a4a000d449aa6e612446c37e7a104bdb2" }, { "id": "pylit_testspecexamples_test_example_d_non_nullable_binary", @@ -2581,7 +2581,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAACAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAADAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1" + "expected_hash": "0000020ee499da085a532f069ccfe218a9af0f2fa33ab8cc21b79991bdc36f5323f141" }, { "id": "pylit_testtemporaltypes_test_date32", @@ -2591,7 +2591,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQgYAAAAAAAAAAAABgAIAAYABgAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFKAAAAAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a" + "expected_hash": "00000248ddc5205e534b4a5dd91fb3ce5b5c4cddff659844e77de731435ab8eda086cc" }, { "id": "pylit_testprimitivetypes_test_uint8", @@ -2601,7 +2601,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAACAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d" + "expected_hash": "000002f5401303c3c8609dde1c1162a0a5388183231ae9d7aad98a5165ca6cb949e474" }, { "id": "pylit_testtemporaltypes_test_time64_nanoseconds", @@ -2611,7 +2611,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQkcAAAAAAAAAAgADAAGAAgACAAAAAAAAwBAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKmjsAAAAAAAAAAAAAAAAA8gUqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1" + "expected_hash": "0000020ec4f4365fc43e57f5a229faf87d5e90dbe3ff53f64844c7bae443bb5c35bf07" }, { "id": "pylit_testprimitivetypes_test_uint16", @@ -2621,7 +2621,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAEAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoAwAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc" + "expected_hash": "0000023c4a18350b71b2498685b732bf86aafa7edc9b6aea24de50e6a764cb4f0a8ec6" }, { "id": "pylit_testprimitivetypes_test_uint64", @@ -2631,7 +2631,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAQAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAypo7AAAAAAAAAAAAAAAA//////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a" + "expected_hash": "000002bab5700cfdadfbc1a63b32bbab4c8154ad9696f024e6965266b10714d18ba772" }, { "id": "pylit_teststructtypes_test_struct_with_nullable_children", @@ -2641,7 +2641,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAApP///xwAAAAMAAAAAAAADZAAAAACAAAAVAAAABgAAADU////EAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351" + "expected_hash": "00000223f577c71ad70b36baf8db3ae57304492642edeab6f98560180b624eb7127d40" }, { "id": "pylit_testprimitivetypes_test_int16", @@ -2651,7 +2651,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAEAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOgDAAAY/P9/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73" + "expected_hash": "0000021193e13fb74196a3ba1e2848d8b371cbaec0145408be4c10dce5c7da3d6f0ef8" }, { "id": "pylit_testspecexamples_test_example_a_two_column_table", @@ -2661,7 +2661,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAMAAABhZ2UA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBbGljZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" + "expected_hash": "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" }, { "id": "pylit_testprimitivetypes_test_int64", @@ -2671,7 +2671,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBCDwAAAAAAAAAAAAAAAADAvfD//////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05" + "expected_hash": "00000273f6a64dd00ba1e2749c0ff21c64bb1984989efb7f94e37b188e6f0ea0ee3607" }, { "id": "pylit_testprimitivetypes_test_int8", @@ -2681,7 +2681,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAACAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA/38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a" + "expected_hash": "0000024168dcfaf09c69c2fd848090fcff65c6e27c7a8575f419e6b5c011b28633c6ec" }, { "id": "pylit_testspecexamples_test_example_n_list_of_struct", @@ -2691,7 +2691,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARWwAAAAAQAAAAgAAADA////sP///xwAAAAMAAAAAAAADYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABpdGVtcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361" + "expected_hash": "000002a58f04b6bc45c95e5faa11155031bfb9dc8815187dde82b0f4d833cb8f376056" }, { "id": "pylit_testtemporaltypes_test_time32_milliseconds", @@ -2701,7 +2701,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQkQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEIPAAAAAABAS0wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd" + "expected_hash": "0000028211097939067b80d7b9d622b88201aedc86254255f02f513e3acbf8da34e04a" }, { "id": "pylit_testprimitivetypes_test_float64", @@ -2711,7 +2711,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+D8AAAAAAAAAAB+F61G4HgnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda" + "expected_hash": "000002f2dd5acce604d642d652fbbbc3bfb16807f36100aff5a84d1f6acb194e4d90e9" }, { "id": "pylit_testprimitivetypes_test_uint32", @@ -2721,7 +2721,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQIYAAAAAAAGAAgABAAGAAAAIAAAAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBCDwAAAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389" + "expected_hash": "000002aa9b7f8fdea28a5651544e73648faa19f22b87912a4b18ec121df884a65e3440" }, { "id": "pylit_testspecexamples_test_example_i_empty_table", @@ -2731,7 +2731,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAEAAABiAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84" + "expected_hash": "0000028aa5ce23c0faa5de71df6c33cb88194f8555ce4c2ddf8398ebd15e7933081798" }, { "id": "pylit_testspecexamples_test_example_k_struct_column", @@ -2741,7 +2741,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAsP///xwAAAAMAAAAAAAADYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAEAAAAbmFtZQAAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAADAAAAYWdlAAYAAABwZXJzb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAABgAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFsaWNlQm9iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0" + "expected_hash": "000002b9461e7b30083397b2a328415184d53e8c27d315af89e22163aae5a0da91866a" }, { "id": "pylit_testspecexamples_test_example_o_nested_struct", @@ -2751,7 +2751,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAUP///xwAAAAMAAAAAAAADeQAAAACAAAAqAAAAAgAAADc////dP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAJz///8QAAAAGAAAAAAAAAIUAAAAjP///yAAAAAAAAABAAAAAAEAAABxAAAAyP///xAAAAAYAAAAAAAAAhQAAAC4////IAAAAAAAAAEAAAAAAQAAAHAAAAAGAAAAbmVzdGVkAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c" + "expected_hash": "000002ecebdb320ae446cd5347ec7cbff5272c36af957666f717c59df85cfd8410d5a4" }, { "id": "pylit_testprimitivetypes_test_bool", @@ -2761,7 +2761,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f" + "expected_hash": "000002b4fe586ae0a97fcc8ae84e83110f8980bde7c74aed4c66b60321116994982aeb" }, { "id": "pylit_testspecexamples_test_example_f_utf8_equivalence", @@ -2771,7 +2771,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAUQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286" + "expected_hash": "000002644b2970be7606407afad7635d7f7111c2f668496e938bdff452604bd444065b" }, { "id": "pylit_testprimitivetypes_test_float32", @@ -2781,7 +2781,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAADgAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAQMYAAAAAAAGAAgABgAGAAAAAAABAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAEAAAAAAAAAAAAAAABAAAABAAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAPwAAAADD9UjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2" + "expected_hash": "00000279154d63290b405df71342d15c41dd9f288d5bd1dadae43f37950b85dcf74041" }, { "id": "pylit_testspecexamples_test_example_e_column_order_independence", @@ -2791,7 +2791,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABQAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEGEAAAAAAAAAAEAAQABAAAAAEAAAB5AAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHgAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAQAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae" + "expected_hash": "00000201b7c533b770a31fd7bc0fefa6252c2fa7100305f07f991502437cc1a5ba1d24" }, { "id": "pylit_testbinaryvariedsizes_test_binary_varied_sizes", @@ -2801,7 +2801,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABEAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgMEBQYHCAkKCwwNDg//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1" + "expected_hash": "0000020885790654a7ce21e6afdfeaa4ad99490e1871149892eda8acf4d2a403566410" }, { "id": "pylit_testallnullarrays_test_all_null_int32", @@ -2811,7 +2811,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAABAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33" + "expected_hash": "000002a51121a9cb745bbcd08ebba07ce33ef64dcb630c241d4112d27d15106e3889d7" }, { "id": "pylit_testlistoflist_test_list_of_list_hash_array", @@ -2821,7 +2821,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAKAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAFAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa" + "expected_hash": "000002215978d8171df62a17e8b85524418ac182dc2b1f2132ab95b8a99922dfc9c725" }, { "id": "pylit_testlistofstruct_test_list_of_struct_hash_array", @@ -2831,7 +2831,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAkP///xgAAAAMAAAAAAAAFbAAAAABAAAACAAAAMD///+w////HAAAAAwAAAAAAAANhAAAAAIAAABIAAAACAAAAOT////U////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2" + "expected_hash": "000002c1c713c7ee5c139a8799e83aff16049b6a6a935e3e3f8601e04db05c523e2d7b" }, { "id": "pylit_testrealisticbatch_test_realistic_batch", @@ -2841,7 +2841,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "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", - "expected_hash": "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de" + "expected_hash": "000002e86fcf5b5a6b21b9f3f4a5f3eb6608c6e531ecabd95cbf365d01089d2a924619" }, { "id": "pylit_testallnullarrays_test_all_null_string", @@ -2851,7 +2851,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAADAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc" + "expected_hash": "0000025a88292c68392ec7d5ac54666139cb4836c9267088dfabef093e7981c322df38" }, { "id": "pylit_testsingleelementarrays_test_single_bool_false", @@ -2861,7 +2861,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155" + "expected_hash": "0000023753cbe1173b2b0f1b81ce9de03a7c0a1ba1f5431dabbdbeef99172dd357bb29" }, { "id": "pylit_testrealisticbatch_test_realistic_schema", @@ -2871,7 +2871,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAgAQAAZAAAAAQAAAD8/v//GAAAAAwAAAAAAAEVPAAAAAEAAAAIAAAA8P7//6D///8QAAAAFAAAAAAAAAMQAAAAVv///wAAAQAAAAAABAAAAGl0ZW0AAAAACAAAAHJlYWRpbmdzAAAAANz///8cAAAADAAAAAAAAA2MAAAAAgAAAFQAAAAYAAAAUP///xAAFAAQAAAADwAEAAAACAAQAAAAEAAAABQAAAAAAAADEAAAAMb///8AAAIAAAAAAAMAAABsb24AEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAADAAAAbGF0AAYAAABjb29yZHMAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792" + "expected_hash": "000002b4caaae1356e990fdb4b8ed43bf8f67bcdc3ee2f094da6e0f71575dc52ec31c9" }, { "id": "pylit_testthreelevelstruct_test_three_level_struct_hash_array", @@ -2881,7 +2881,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xwAAAAMAAAAAAAADdwAAAACAAAAOAAAAAgAAACU////iP///xAAAAAYAAAAAAAAAhQAAAB4////IAAAAAAAAAEAAAAAAQAAAHgAAAC0////HAAAAAwAAAAAAAANgAAAAAIAAABEAAAACAAAAOT////Y////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAEAAAB6AAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAHkAAAAFAAAAaW5uZXIAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAACAAAAAAAAAAAAAAAFAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAACQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAACAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAIABAAAAAAAAAgAAAAAAAADAAQAAAAAAAAEAAAAAAAAAAAIAAAAAAAAIAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26" + "expected_hash": "000002db3095dc0093c38b3aa668aee0f1805fc815542685d5d065008dc621512a8096" }, { "id": "pylit_testnullablestructhasharray_test_nullable_struct_hash_array", @@ -2891,7 +2891,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ2AAAAAAgAAAEQAAAAIAAAA5P///9j///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAACAAAAAAAAAAQAEAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh5egAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21" + "expected_hash": "000002f5c5e7555a574364d953e7ebeb45dbc9f232e5707133dd088420924300ae3c58" }, { "id": "pylit_testmixedstructlistbatch_test_mixed_struct_list_schema", @@ -2901,7 +2901,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAIAQAAXAAAAAQAAACI////GAAAAAwAAAAAAAEVOAAAAAEAAAAIAAAATP///6j///8UAAAADAAAAAAAARQMAAAAAAAAAGj///8EAAAAaXRlbQAAAAAEAAAAdGFncwAAAABo////HAAAAAwAAAAAAAANfAAAAAIAAABMAAAAGAAAAKT///8QABQAEAAOAA8ABAAAAAgAEAAAABAAAAAYAAAAAAABAhQAAACM////IAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAzP///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABtZXRhAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da" + "expected_hash": "0000029f1118411cb35c292b7950a626469bd8cb987faa8c114d6509f09f32ec816cb8" }, { "id": "pylit_teststructemptybatch_test_struct_empty_batch", @@ -2911,7 +2911,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAYP///yAAAAAMAAAAAAAADcwAAAADAAAAmAAAAFAAAAAYAAAAXP///xAAFgAQAAAADwAEAAAACAAQAAAAGAAAABwAAAAAAAADGAAAAAAABgAIAAYABgAAAAAAAgAAAAAABQAAAHNjb3JlAAAAzP///xgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAADAAAAYWdlABAAFAAQAAAADwAEAAAACAAQAAAAGAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAAAYAAABwZXJzb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93" + "expected_hash": "000002aaafa89ee39b32668aeb6f65c56501061b7194257ea88f14c3be0eca314f1d0d" }, { "id": "pylit_testbatchallnullcolumn_test_batch_all_null_column", @@ -2921,7 +2921,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAUAAAB2YWx1ZQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAMAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAMAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752" + "expected_hash": "000002dca3ee7298f6495f2263e45eb2c876c9dc78f5b7462357f3be5f5d6579214e94" }, { "id": "pylit_testmixedstructlistbatch_test_mixed_struct_list_batch", @@ -2931,7 +2931,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "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", - "expected_hash": "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0" + "expected_hash": "00000227eb7540623891a51b93eb1f133f461cd3231bc03f3d5f36957b452a477b912c" }, { "id": "pylit_testliststructnullableinnerfield_test_nullable_inner_field", @@ -2941,7 +2941,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAgP///xgAAAAMAAAAAAAAFcAAAAABAAAAGAAAALD///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDYQAAAACAAAASAAAAAgAAADk////1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a" + "expected_hash": "0000023e818d98ed740fcd8240f4fdb39e4c53581b071c9ab6200a27924c186414f178" }, { "id": "pylit_teststructwithlistchild_test_struct_with_list_child_schema", @@ -2951,7 +2951,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAbP///xwAAAAMAAAAAAAADcgAAAACAAAAjAAAAAgAAADg////3P///xwAAAAMAAAAAAABDFQAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAtP///yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAAB0YWdzAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABgAAAHJlY29yZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2" + "expected_hash": "00000231878b42f48260f2ba82a63298760afe8d214504d3b97a7019ff9a83eba48682" }, { "id": "pylit_testnullablestructbatch_test_nullable_struct_batch", @@ -2961,7 +2961,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQ2AAAAAAgAAAEQAAAAIAAAA5P///9j///8YAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAEAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAMAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b" + "expected_hash": "00000201b1aee1103d35dad74cda3c5a1c01e1aa5468beb02cc3cda5c1cb6c317f2d90" }, { "id": "pylit_testlistoflist_test_list_of_list_schema", @@ -2971,7 +2971,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAADAAAAY29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835" + "expected_hash": "0000023014336b70e541ea20913795de44594938a32b325f17b5f03ed6ebf09859a95a" }, { "id": "pylit_testsingleelementarrays_test_single_string", @@ -2981,7 +2981,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhlbGxvIHdvcmxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648" + "expected_hash": "00000229b25b121cf4b425c068c2ac17b1952497cf7015668b73a62f925a078fa69d67" }, { "id": "pylit_testnonnullablelist_test_list_non_nullable", @@ -2991,7 +2991,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAYAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96" + "expected_hash": "000002c60a39367e08f911e8d99db430267db89ca41e4cef6e87ac01520422354684a6" }, { "id": "pylit_testemptyarrays_test_empty_int32_array", @@ -3001,7 +3001,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gAAAAQAAAAAAAKAA4ADAALAAQACgAAABQAAAAAAAADBAAKAAwAAAAIAAQACgAAACAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f" + "expected_hash": "000002b87ccbba66f376281848a40936e3b3697d877c78ec651aa4151939d9f3af2277" }, { "id": "pylit_testlistoflist_test_list_of_list_batch", @@ -3011,7 +3011,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAAAFYgAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAAVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAADAAAAY29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAKAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAFAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f" + "expected_hash": "0000024354ac4eb6cef06e975af9b4a9f110e6baf409446897e122849553b159e6dc27" }, { "id": "pylit_testliststructnullableinnerfield_test_non_nullable_inner_field", @@ -3021,7 +3021,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAkP///xgAAAAMAAAAAAAAFbAAAAABAAAACAAAAMD///+w////HAAAAAwAAAAAAAANhAAAAAIAAABIAAAACAAAAOT////U////GAAAAAwAAAAAAAAUEAAAAAAAAAAEAAQABAAAAAUAAABsYWJlbAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAoAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYmNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f" + "expected_hash": "0000021a7aa4df873b7627617a5ce9a234a8849202508afc27eda81af271d8b12bf592" }, { "id": "pylit_testschema4levelnestedstruct_test_schema_4_level_nested_struct", @@ -3031,7 +3031,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAfP///xgAAAAMAAAAAAAADdQAAAABAAAACAAAAKD///+c////GAAAAAwAAAAAAAANrAAAAAEAAAAIAAAAwP///7z///8YAAAADAAAAAAAAA2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGxlYWYAAAAAAgAAAGwzAAACAAAAbDIAAAIAAABsMQAABAAAAHJvb3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162" + "expected_hash": "000002a07f8d13692700d7b2cad515d343a2a1ce4b3dd7deac50316102a43638b496d2" }, { "id": "pylit_testschemalistofstructwithlist_test_schema_list_of_struct_with_list", @@ -3041,7 +3041,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAZP///xgAAAAMAAAAAAABFRQBAAABAAAACAAAAFj///9M////IAAAAAwAAAAAAAAN6AAAAAMAAACsAAAAcAAAAAgAAACA////rP///xgAAAAMAAAAAAABFTgAAAABAAAACAAAAKD///+U////FAAAAAwAAAAAAAAUDAAAAAAAAAC8////BAAAAGl0ZW0AAAAABAAAAHRhZ3MAAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAAAwAAAG1zZwAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAABAAAAAAAAAAQAAAAACAAAAdHMAAAQAAABpdGVtAAAAAAYAAABldmVudHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb" + "expected_hash": "000002a6a3ef288f2975f6a75b0336b2b7d69ffb4a2d129046710b7184d1eb76a45fe2" }, { "id": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema", @@ -3051,7 +3051,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAADkAAAAqAAAAAQAAAA4////HAAAAAwAAAAAAAANeAAAAAIAAABMAAAAGAAAAGj///8QABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAIAAAAAAAEAAABiAAAAnP///xQAAAAMAAAAAAAABgwAAAAAAAAAxP///wEAAABhAAAAAQAAAHoAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd" + "expected_hash": "000002a157d896c73e72632c68cabed99b8351ca116199217e209552f9bfaf70721cff" }, { "id": "pylit_testnullableliststructnullablechildren_test_nullable_list_struct_nullable_children_batch", @@ -3061,7 +3061,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAvP///xgAAAAMAAAAAAABFcAAAAABAAAACAAAALD///+g////HAAAAAwAAAAAAAANlAAAAAIAAABYAAAAGAAAANT///8QABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAAFAAAAbGFiZWwAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAQAAABpdGVtAAAAAAUAAABpdGVtcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAACAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAGAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104" + "expected_hash": "000002411fa81d41e904d832eceea8e2041fc96bda4e4dc58e72b76380e086d400a008" }, { "id": "pylit_testfloatspecialvalues_test_float64_special_values", @@ -3071,7 +3071,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAWABAAAAAPAAQAAAAIABAAAAAYAAAAHAAAAAAAAAMYAAAAAAAGAAgABgAGAAAAAAACAAAAAAAFAAAAYXJyYXkAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+H8AAAAAAADwfwAAAAAAAPD/AAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc" + "expected_hash": "000002b8e0f66c036e26098ba55673ee856b1b23fb6dcb9acfb63207cf8ad6fadc34dd" }, { "id": "pylit_testemptybatchcomplexschema_test_empty_batch_complex_schema_hash", @@ -3081,7 +3081,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAADkAAAAqAAAAAQAAAA4////HAAAAAwAAAAAAAANeAAAAAIAAABMAAAAGAAAAGj///8QABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAIAAAAAAAEAAABiAAAAnP///xQAAAAMAAAAAAAABgwAAAAAAAAAxP///wEAAABhAAAAAQAAAHoAAAAQABQAEAAOAA8ABAAAAAgAEAAAABgAAAAMAAAAAAABFBAAAAAAAAAABAAEAAQAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe" + "expected_hash": "00000286ebe427c00dea251c527cc286dc591efea4d6787cb3b40d3330a476b74f6d6c" }, { "id": "pylit_teststructmixedtypes_test_struct_mixed_types_hash_array", @@ -3091,7 +3091,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAFP///yQAAAAMAAAAAAAADSABAAAEAAAA5AAAAKQAAAB4AAAACAAAAFD///9A////GAAAAAwAAAAAAAAMUAAAAAEAAAAYAAAAcP///xAAFAAQAA4ADwAEAAAACAAQAAAAEAAAABgAAAAAAAECFAAAAGD///8gAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAGAAAAc2NvcmVzAACs////FAAAAAwAAAAAAAAGDAAAAAAAAADY////BgAAAGFjdGl2ZQAA1P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAAEAAAAbmFtZQAAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAACAAAAaWQAAAUAAABhcnJheQAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAwAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAHwAAAAQAAAAAgAAAAAAAAAAAAAABgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAgAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAGAAAAAAAAABAAQAAAAAAAAgAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAAAQAAAAAAAAAAAgAAAAAAAAEAAAAAAAAAQAIAAAAAAAAMAAAAAAAAAIACAAAAAAAAAQAAAAAAAADAAgAAAAAAAAwAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBbGljZUJvYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABaAAAAVQAAAEYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590" + "expected_hash": "00000269c3b3a491ea942d3067cfdf07b67a35bd708e4ee05c45cc302190016ab4a9f7" }, { "id": "pylit_testemptyarrays_test_empty_bool_array", @@ -3101,7 +3101,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAAYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////eAAAABAAAAAAAAoADgAMAAsABAAKAAAAFAAAAAAAAAMEAAoADAAAAAgABAAKAAAAIAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4" + "expected_hash": "000002754d4bf287e5b460d403a8468e526e92a738921b2aa8dbab8cc8a3450bcac203" }, { "id": "pylit_testlistofstruct_test_nullable_list_of_struct_hash_array", @@ -3111,7 +3111,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARWsAAAAAQAAAAgAAADA////tP///xwAAAAMAAAAAAAADYAAAAACAAAARAAAAAgAAADk////2P///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAADAAAAdmFsABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAgAAAAAAAAAMABAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAFAAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca" + "expected_hash": "000002cd3cde5a0df63e3a6889556920e248890a882572450350a03da90f67f37e9f90" }, { "id": "pylit_teststructfieldorderindependence_test_struct_3field_order_independence", @@ -3121,7 +3121,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAjP///yAAAAAMAAAAAAAADagAAAADAAAAbAAAADAAAAAIAAAAwP///7T///8UAAAADAAAAAAAAAYMAAAAAAAAANz///8BAAAAYwAAANj///8YAAAADAAAAAAAABQQAAAAAAAAAAQABAAEAAAAAQAAAGIAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAYQAAAAUAAABhcnJheQAAAP////84AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAIAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABcAAAAEAAAAAIAAAAAAAAAAAAAAAQAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAACAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAAYAAAAAAAAAEABAAAAAAAAAgAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283" + "expected_hash": "0000025560faf3d3f3ce308ad2c7129f24f42589e7b25f0c6dc70ddd2aa45f7464111a" }, { "id": "pylit_testunicodestrings_test_unicode_string_array", @@ -3131,7 +3131,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAARQQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAAAAAAADAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAMAAAAAAAAACAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAsAAAAAAAAAFwAAAAAAAAAXAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhlbGxv5LiW55WM8J+MjfCfjI7wn4yPY2Fmw6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486" + "expected_hash": "0000029f656d188a338cc277592a06b5710796016037efc7fc7cb5746e65bfadd752b4" }, { "id": "pylit_testnestednullableinnerstruct_test_nested_nullable_inner_struct", @@ -3141,7 +3141,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAQP///xwAAAAMAAAAAAAADfQAAAACAAAAuAAAABgAAADM////EAAUABAADgAPAAQAAAAIABAAAAAgAAAADAAAAAAAAQ1wAAAAAgAAADwAAAAMAAAABAAEAAQAAACc////EAAAABgAAAAAAAACFAAAAIz///8gAAAAAAAAAQAAAAABAAAAcQAAAMj///8QAAAAGAAAAAAAAAIUAAAAuP///yAAAAAAAAABAAAAAAEAAABwAAAABQAAAGlubmVyAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGEAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAADAAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAADAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAUAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820" + "expected_hash": "00000236f16a0a8179aefeb33f440a83a7d32aad8993c022796eab539de2e1d63521b8" }, { "id": "pylit_testlargeschema_test_large_schema_12_fields", @@ -3151,7 +3151,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgDAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAwAAAC4AgAAeAIAADgCAAAIAgAA1AEAAJgBAABsAQAARAEAABwBAADwAAAAYAAAAAQAAADE/f//GAAAAAwAAAAAAAEVQAAAAAEAAAAIAAAAsP7//+T9//8QAAAAGAAAAAAAAQIUAAAAmP3//yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAMAAABmMTIA4P3//xwAAAAMAAAAAAAADXQAAAACAAAAOAAAAAgAAAAM////QP7//xQAAAAMAAAAAAABFAwAAAAAAAAAKP///wgAAABuZXN0ZWRfYgAAAAAw/v//EAAAABgAAAAAAAACFAAAACD+//8gAAAAAAAAAQAAAAAIAAAAbmVzdGVkX2EAAAAAAwAAAGYxMQCo/v//FAAAAAwAAAAAAAEIEAAAAAAAAAAy////AAAAAAMAAABmMTAAlP7//xQAAAAMAAAAAAAAEwwAAAAAAAAAuP///wMAAABmMDkA9P7//xQAAAAMAAAAAAABFAwAAAAAAAAA3P///wMAAABmMDgA3P7//xgAAAAMAAAAAAAABhAAAAAAAAAABAAEAAQAAAADAAAAZjA3AED///8QAAAAFAAAAAAAAQMQAAAAxv///wAAAgAAAAAAAwAAAGYwNgAQABYAEAAAAA8ABAAAAAgAEAAAABgAAAAcAAAAAAAAAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAMAAABmMDUAqP///xAAAAAYAAAAAAABAhQAAABc////QAAAAAAAAAEAAAAAAwAAAGYwNACY////EAAAABgAAAAAAAACFAAAAIj///8gAAAAAAAAAQAAAAADAAAAZjAzABAAFAAQAA4ADwAEAAAACAAQAAAAEAAAABgAAAAAAAECFAAAAMT///8QAAAAAAAAAQAAAAADAAAAZjAyABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAAgAAAAAAAABAAAAAAMAAABmMDEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d" + "expected_hash": "000002a89c186dbf815b7192ed4ac574196d1e0203db10d53dd7d16fbe12fbbdbb651e" }, { "id": "pylit_testmultibatchstruct_test_multi_batch_struct", @@ -3161,7 +3161,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAnP///yAAAAAMAAAAAAAADZgAAAACAAAAXAAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAEAAAABgAAAAAAAECFAAAAMT///8gAAAAAAAAAQAAAAABAAAAeQAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAQAAAHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAIAAAAAAAAAAAAAAAMAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAIAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAQAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAEAAAAAAAAAAAAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2" + "expected_hash": "0000025d4b5b129c220a3171a616f1ff060a00fdb3647a34434f4d83e9d0a68502c334" }, { "id": "pylit_testsingleelementarrays_test_single_int64", @@ -3171,7 +3171,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAQAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/jC1QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770" + "expected_hash": "000002ac6614ba2b81b9238b2888b17d9ccb5eb46a7ea3285c22a1b1ad25997d726e7b" }, { "id": "pylit_teststructwithlistchild_test_struct_with_list_child_batch", @@ -3181,7 +3181,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAbP///xwAAAAMAAAAAAAADcgAAAACAAAAjAAAAAgAAADg////3P///xwAAAAMAAAAAAABDFQAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAQAAAAGAAAAAAAAQIUAAAAtP///yAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAAB0YWdzAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAIAAABpZAAABgAAAHJlY29yZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAMABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAwAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAEAAAAAAAAABAAQAAAAAAAAEAAAAAAAAAgAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAUAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83" + "expected_hash": "0000027699b386e4e56ce34d2a38f748566a75c36c62ca8f5fa36180f0ea8809ac528c" }, { "id": "pylit_testthreelevelstruct_test_three_level_struct_schema", @@ -3191,7 +3191,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAAB6AAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAHkAAAADAAAAbWlkABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAwAAAHRvcAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8" + "expected_hash": "000002613ec04c0f0d49d1eff685ac3ffc3ee80a47ddb2121860f9845ac0d3a33fe7b2" }, { "id": "pylit_testbooleanarrays_test_bool_17_elements", @@ -3201,7 +3201,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQYQAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAARAAAAAAAAAAAAAAABAAAAEQAAAAAAAAADAAAAAAAAAAAAAAACAAAAAAAAAAAAAAADAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvfQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATTUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", - "expected_hash": "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068" + "expected_hash": "000002d8e326d69087a22ebe44e971f2673272ad044e99927c9c4cfcf1cf26f1e7dcf2" }, { "id": "pylit_testmultibatchlist_test_multi_batch_list", @@ -3211,7 +3211,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA3P///xwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABQAAAGl0ZW1zAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAYAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAEAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAEAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", - "expected_hash": "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519" + "expected_hash": "00000248df16aca0c1f681b8b02cd0c859b3073c238101a6893bfa44d9f536a9819870" }, { "id": "pylit_testthreelevelstruct_test_three_level_struct_batch", @@ -3221,7 +3221,7 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAVP///xwAAAAMAAAAAAAADeAAAAACAAAApAAAAAgAAADc////eP///yAAAAAMAAAAAAAADXAAAAACAAAAPAAAAAwAAAAEAAQABAAAAKD///8QAAAAGAAAAAAAAAIUAAAAkP///yAAAAAAAAABAAAAAAEAAAB6AAAAzP///xAAAAAYAAAAAAAAAhQAAAC8////IAAAAAAAAAEAAAAAAQAAAHkAAAADAAAAbWlkABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAAB4AAAAAwAAAHRvcAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAAEAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db" + "expected_hash": "000002207e061a060534d98724ad2beabd1cd5d1350e5614104815a6a6c0ef13d8935c" }, { "id": "pylit_testspecexamples_test_example_a_two_column_table_2", @@ -3231,7 +3231,167 @@ "ordered_columns": false, "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAIAAABUAAAAFAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAAAwAAAAAAAEUEAAAAAAAAAAEAAQABAAAAAQAAABuYW1lAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAMAAABhZ2UA//////gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAgAAAAAAAAAAAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBbGljZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", - "expected_hash": "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" + "expected_hash": "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" + }, + { + "id": "root_int32_no_validity_array_f0", + "description": "hash_array Int32 [1, 2, 3] without a validity buffer (the root is always nullable)", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" + }, + { + "id": "root_int32_all_valid_array_f0", + "description": "hash_array Int32 [1, 2, 3] with an all-valid validity buffer", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" + }, + { + "id": "root_int32_with_null_array_f0", + "description": "hash_array Int32 [1, null, 3]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAQIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAQAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002622d246fecf03065fa22e2115a910dee4cf1c17599ac6ed441fccdc98244ae17" + }, + { + "id": "fsb0_nullable_rb_f0", + "description": "z: FixedSizeBinary(0)? rows [b\"\", null, b\"\"]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ8QAAAAAAAAAAQABAAEAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002eee2a5760bc227eac859b9f0ca81a3f0eb4208a772f1b95b2225c16015b404ce" + }, + { + "id": "fsb0_1row_rb_f0", + "description": "z: FixedSizeBinary(0) one row [b\"\"]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA8QAAAAAAAAAAQABAAEAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000024f8f0a8a6c0d6d94bcd5fe649ab14f15933d926d9506c23ce1ddeef1cc591a9b" + }, + { + "id": "fsb0_5rows_rb_f0", + "description": "z: FixedSizeBinary(0) five rows of b\"\"", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA8QAAAAAAAAAAQABAAEAAAAAQAAAHoAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAAFAAAAAAAAAAAAAAABAAAABQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000022b3b0f320140ec6fd164edc233b87be5936178d0a7b1787f6088476a070cab9c" + }, + { + "id": "fsb0_nullable_array_f0", + "description": "hash_array FixedSizeBinary(0) [b\"\", null, b\"\"]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ8QAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002ec56d1f725cd5736a7946ea8f84954d870c1da557f6d44b1148fa899f42ac817" + }, + { + "id": "fsb0_array_f0", + "description": "hash_array FixedSizeBinary(0) [b\"\", b\"\", b\"\"]", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAADAAAAAAAAA8QAAAAAAAAAAQABAAEAAAABQAAAGFycmF5AAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002517031fc52df84aa1cae91e0e28cdb084b74a26f560a14fd31991faa0c9c7ea8" + }, + { + "id": "dict_of_list_rb_f0", + "description": "c: Dictionary> keys [0, 1, 0] over [[1, 2], [3]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAACwAAAAAAAAMEAAAAHgAAAAIAAgAAAAEAAgAAAAEAAAAwP///wgAAAAAAAABAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAAAEAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAAPAAAABAAAAACAAAAAAAAAAAAAAACAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000242d295007670a84d5b47275de1cbfdbaf82c27760e1693f37313e55381dce8e4" + }, + { + "id": "plain_list_rb_f0", + "description": "c: List [[1, 2], [3], [1, 2]]", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABjAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABQAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAwAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000242d295007670a84d5b47275de1cbfdbaf82c27760e1693f37313e55381dce8e4" + }, + { + "id": "dict_of_list_array_f0", + "description": "hash_array of the dictionary of lists", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAPAAAACwAAAAAAAAMEAAAAHgAAAAIAAgAAAAEAAgAAAAEAAAAwP///wgAAAAAAAABAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAAAEAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAAPAAAABAAAAACAAAAAAAAAAAAAAACAAAAAgAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAwAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002940f70c0349a75d8303a1acfd0886f6ba6d1d39295bc405445b40d4a998c718b" + }, + { + "id": "plain_list_array_f0", + "description": "hash_array of the plain list", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAAAAAPAAQAAAAIABAAAAAcAAAADAAAAAAAAAxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAA4ADwAEAAAACAAQAAAAGAAAACAAAAAAAAECHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAA8AAAAEAAAAAMAAAAAAAAAAAAAAAIAAAADAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAUAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAMAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002940f70c0349a75d8303a1acfd0886f6ba6d1d39295bc405445b40d4a998c718b" + }, + { + "id": "hidden_null_list_rb_f0", + "description": "l: List? rows [[1], null, [4]]; the null row's slot covers a null item", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ed889d3a463ff972ea36d2edefdef90e3262d067eec0c14992a4d19996900dcc" + }, + { + "id": "clean_list_rb_f0", + "description": "l: List? rows [[1], null, [4]]; the null row's slot is empty", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ed889d3a463ff972ea36d2edefdef90e3262d067eec0c14992a4d19996900dcc" + }, + { + "id": "hidden_null_large_list_rb_f0", + "description": "l: LargeList? rows [[1], null, [4]]; the null row's slot covers a null item", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ed889d3a463ff972ea36d2edefdef90e3262d067eec0c14992a4d19996900dcc" + }, + { + "id": "clean_large_list_rb_f0", + "description": "l: LargeList? rows [[1], null, [4]]; the null row's slot is empty", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002ed889d3a463ff972ea36d2edefdef90e3262d067eec0c14992a4d19996900dcc" } ], "relations": [ @@ -3963,6 +4123,64 @@ "ext_uuid_empty_metadata_schema_f0_im1" ], "why": "an absent ARROW:extension:metadata equals an empty one" + }, + { + "kind": "equal", + "ids": [ + "root_int32_no_validity_array_f0", + "root_int32_all_valid_array_f0" + ], + "why": "the hash_array root is always nullable: a validity buffer without nulls changes nothing" + }, + { + "kind": "different", + "ids": [ + "root_int32_no_validity_array_f0", + "root_int32_with_null_array_f0" + ], + "why": "a null in the root array counts" + }, + { + "kind": "different", + "ids": [ + "fsb0_1row_rb_f0", + "fsb0_5rows_rb_f0" + ], + "why": "zero-width values still count rows" + }, + { + "kind": "different", + "ids": [ + "fsb0_nullable_array_f0", + "fsb0_array_f0" + ], + "why": "zero-width values still count nulls" + }, + { + "kind": "equal", + "ids": [ + "dict_of_list_rb_f0", + "plain_list_rb_f0" + ], + "why": "a dictionary of lists is its decoded list" + }, + { + "kind": "equal", + "ids": [ + "dict_of_list_array_f0", + "plain_list_array_f0" + ], + "why": "a dictionary of lists is its decoded list (hash_array)" + }, + { + "kind": "equal", + "ids": [ + "hidden_null_list_rb_f0", + "clean_list_rb_f0", + "hidden_null_large_list_rb_f0", + "clean_large_list_rb_f0" + ], + "why": "items under a null list value are not visited, for List and LargeList alike" } ] } diff --git a/tests/test_arrow_digester.py b/tests/test_arrow_digester.py index bbb9af5..a0b085c 100644 --- a/tests/test_arrow_digester.py +++ b/tests/test_arrow_digester.py @@ -129,22 +129,22 @@ class TestArrayHashing: def test_boolean_array(self): arr = pa.array([True, None, False, True], type=pa.bool_()) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" + assert h == "0000024c5223c9cdc2fe10fb4362890cfc763e1bea4829a30fa6bfedc7bacad05f783a" def test_int32_array(self): arr = pa.array([42, None, -7, 0], type=pa.int32()) h = ArrowDigester.hash_array(arr).hex() - assert h == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" + assert h == "00000264c8fe45cb550e25577276b2af8c1c9c125bc14b8439f5619c1f18c71d4d0078" def test_time32_second_array(self): arr = pa.array([1000, None, 5000, 0], type=pa.time32("s")) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" + assert h == "0000026708f2d0b632bf3f324716cd32c7c41dd8b9bc75d326fb5ec3f3900201f08eb7" def test_time64_microsecond_array(self): arr = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" + assert h == "0000022ddc0ab9c1cfc0fda9353d66612a504cb63d6ee509c4f56b961f33855f1a82a4" def test_time_units_differ(self): a = pa.array([1000, 2000], type=pa.time32("s")) @@ -154,12 +154,12 @@ def test_time_units_differ(self): def test_binary_array(self): arr = pa.array([b"hello", None, b"world", b""], type=pa.binary()) h = ArrowDigester.hash_array(arr).hex() - assert h == "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" + assert h == "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" def test_string_array(self): arr = pa.array(["hello", None, "world", ""], type=pa.utf8()) h = ArrowDigester.hash_array(arr).hex() - assert h == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + assert h == "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" def test_list_array(self): arr = pa.array( @@ -167,7 +167,7 @@ def test_list_array(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) h = ArrowDigester.hash_array(arr).hex() - assert h == "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" + assert h == "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" def test_decimal128_array(self): from decimal import Decimal @@ -181,7 +181,7 @@ def test_decimal128_array(self): type=pa.decimal128(38, 5), ) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" + assert h == "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" # ── Type normalization ──────────────────────────────────────────────── @@ -348,7 +348,7 @@ def test_streaming_golden_value(self): d = ArrowDigester(schema) d.update(batch1) d.update(batch2) - assert d.finalize().hex() == "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" + assert d.finalize().hex() == "0000020ba4ed542e67ebc311d160ab54a11f25630a6b5fdd99e5dfc90917cb1d31e968" def test_nullable_vs_non_nullable_same_data(self): """Array with all valid values should hash same whether nullable or not.""" diff --git a/tests/test_golden_parity.py b/tests/test_golden_parity.py index 205c97a..da387b7 100644 --- a/tests/test_golden_parity.py +++ b/tests/test_golden_parity.py @@ -47,25 +47,25 @@ def test_example_a_two_column_table(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" + assert result == "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" def test_example_b_bool_array_with_nulls(self): """Example B: BooleanArray [true, NULL, false, true].""" array = pa.array([True, None, False, True], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000024100d139820e2b287fee67fbd7624e103a6ab7674b5e0170e933a896cc9ee41d" + assert result == "0000024c5223c9cdc2fe10fb4362890cfc763e1bea4829a30fa6bfedc7bacad05f783a" def test_example_c_non_nullable_int32(self): """Example C: Int32Array [1, 2, 3] — non-nullable.""" array = pa.array([1, 2, 3], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000024c470976f10386fad05c0ef8ac4d3f82c4fd656c3ea6255ef8a21180ce53597a" + assert result == "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" def test_example_d_non_nullable_binary(self): """Example D: BinaryArray [b'hi', b''] — non-nullable; tests Binary→LargeBinary canonicalization.""" array = pa.array([b"hi", b""], type=pa.binary()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002c1577257ed34403943a24dcf25bb9f89a4034cc197e7d6ae03d68d46aacfebb1" + assert result == "0000020ee499da085a532f069ccfe218a9af0f2fa33ab8cc21b79991bdc36f5323f141" def test_example_e_column_order_independence(self): """Example E: columns [x: Int32, y: Boolean nullable] — order must not matter.""" @@ -85,7 +85,7 @@ def test_example_e_column_order_independence(self): {"y": pa.array([True], type=pa.bool_()), "x": pa.array([10], type=pa.int32())}, schema=schema_yx, ) - expected = "00000259305d2093f85b576989659d7bbdb725b33653d8b4cffd65049ba88ac7d1b5ae" + expected = "00000201b7c533b770a31fd7bc0fefa6252c2fa7100305f07f991502437cc1a5ba1d24" assert ArrowDigester.hash_record_batch(batch_xy).hex() == expected assert ArrowDigester.hash_record_batch(batch_yx).hex() == expected @@ -93,7 +93,7 @@ def test_example_f_utf8_equivalence(self): """Example F: Utf8 and LargeUtf8 arrays with the same data must hash identically.""" small = pa.array(["ab"], type=pa.utf8()) large = pa.array(["ab"], type=pa.large_utf8()) - expected = "00000217476a036ab2e8fecbae7ec4587d41fb06aef8bf552cf8f0b368dc41857d4286" + expected = "000002644b2970be7606407afad7635d7f7111c2f668496e938bdff452604bd444065b" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -101,13 +101,13 @@ def test_example_g_nullable_int32(self): """Example G: Int32Array [Some(42), None, Some(-7), Some(0)].""" array = pa.array([42, None, -7, 0], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" + assert result == "00000264c8fe45cb550e25577276b2af8c1c9c125bc14b8439f5619c1f18c71d4d0078" def test_example_h_nullable_string(self): """Example H: StringArray [Some('hello'), None, Some('world'), Some('')].""" array = pa.array(["hello", None, "world", ""], type=pa.utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + assert result == "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" def test_example_i_empty_table(self): """Example I: schema {a: Int32 non-null, b: Boolean nullable} with zero rows.""" @@ -117,7 +117,7 @@ def test_example_i_empty_table(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "0000026bc41a0a4c6ef5d3b5168cac73a2961607896ad6f6801c632390662b48f03b84" + assert result == "0000028aa5ce23c0faa5de71df6c33cb88194f8555ce4c2ddf8398ebd15e7933081798" def test_example_j_multi_batch_streaming(self): """Example J: batch-split independence — two batches == one combined batch.""" @@ -128,7 +128,7 @@ def test_example_j_multi_batch_streaming(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "000002a87ff648c2385327185b77630ffff50ae4470f90542582a783aa6740dcccb68b" + assert result == "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27" def test_example_k_struct_column(self): """Example K: {person: Struct}.""" @@ -143,7 +143,7 @@ def test_example_k_struct_column(self): ) batch = pa.record_batch({"person": person_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002be47c5bd05462dc3c4bbf0f62e5c14c2797f5ac40126e455342b5ff0c24e53d0" + assert result == "000002b9461e7b30083397b2a328415184d53e8c27d315af89e22163aae5a0da91866a" def test_example_n_list_of_struct(self): """Example N: {items: LargeList> nullable}. @@ -167,7 +167,7 @@ def test_example_n_list_of_struct(self): ) batch = pa.record_batch({"items": items_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "00000287065f0798e1fac05078eded05303f6046343a29cd1315c3ae2dd60cffa40361" + assert result == "000002a58f04b6bc45c95e5faa11155031bfb9dc8815187dde82b0f4d833cb8f376056" def test_example_o_nested_struct(self): """Example O: {s: Struct>} — two levels.""" @@ -186,7 +186,7 @@ def test_example_o_nested_struct(self): ) batch = pa.record_batch({"s": s_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "00000260e109b8c08b6265051d1f339801898ab5abc4dd6d874e628ef8bd6219492e0c" + assert result == "000002ecebdb320ae446cd5347ec7cbff5272c36af957666f717c59df85cfd8410d5a4" # --------------------------------------------------------------------------- @@ -198,57 +198,57 @@ class TestPrimitiveTypes: def test_bool(self): array = pa.array([True, False, None, True], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000259cf85678c3695d3ed17046b5a42d629606ab496949b33e9c96f675514a7937f" + assert result == "000002b4fe586ae0a97fcc8ae84e83110f8980bde7c74aed4c66b60321116994982aeb" def test_int8(self): array = pa.array([1, None, -1, 127], type=pa.int8()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000021fa6009005695174467a940479ad60dff4c4c25215b67eb6b9fbce06a39e9d7a" + assert result == "0000024168dcfaf09c69c2fd848090fcff65c6e27c7a8575f419e6b5c011b28633c6ec" def test_int16(self): array = pa.array([1000, None, -1000, 32767], type=pa.int16()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002be4d10e5334ca6eddf6ef2a97068569ee8b4dbac275cfd025716bc845ad7fe73" + assert result == "0000021193e13fb74196a3ba1e2848d8b371cbaec0145408be4c10dce5c7da3d6f0ef8" def test_int32(self): array = pa.array([42, None, -7, 0], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002d1d8a0c525ec9d5b68cd7f3cc7c0ebf465c9159ae35a59010a18044e245e4f61" + assert result == "00000264c8fe45cb550e25577276b2af8c1c9c125bc14b8439f5619c1f18c71d4d0078" def test_int64(self): array = pa.array([1_000_000, None, -1_000_000, 0], type=pa.int64()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000023aab6936af9bf10b02d01c46db095dd95e78d19b61cbdf5719f751f12a6a4d05" + assert result == "00000273f6a64dd00ba1e2749c0ff21c64bb1984989efb7f94e37b188e6f0ea0ee3607" def test_uint8(self): array = pa.array([0, 1, None, 255], type=pa.uint8()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002d4b5b7d8d8cdff6578c2ab3548ac28820d55e4bae62546c06cfb783eb96c7e0d" + assert result == "000002f5401303c3c8609dde1c1162a0a5388183231ae9d7aad98a5165ca6cb949e474" def test_uint16(self): array = pa.array([0, 1000, None, 65535], type=pa.uint16()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000025c7c3b1ecd630160eb0cee63321bd7135b4eef454e147691b3c5877c219781fc" + assert result == "0000023c4a18350b71b2498685b732bf86aafa7edc9b6aea24de50e6a764cb4f0a8ec6" def test_uint32(self): array = pa.array([0, 1_000_000, None, 4_294_967_295], type=pa.uint32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000025b3440e7326d5cf3dc08560b5db09d7c7099ff9578114eedf5e8721cc308c389" + assert result == "000002aa9b7f8fdea28a5651544e73648faa19f22b87912a4b18ec121df884a65e3440" def test_uint64(self): array = pa.array([0, 1_000_000_000, None, 18_446_744_073_709_551_615], type=pa.uint64()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000200b680c62c236f5ff1b973b82177922da1b1de2565c2ab051fe41ac7ada7520a" + assert result == "000002bab5700cfdadfbc1a63b32bbab4c8154ad9696f024e6965266b10714d18ba772" def test_float32(self): array = pa.array([1.5, None, -3.14, 0.0], type=pa.float32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000022b6984cbc7c3f8087433f36e850b77185e90f4b8874d5cdf5b4835fd05ee1fd2" + assert result == "00000279154d63290b405df71342d15c41dd9f288d5bd1dadae43f37950b85dcf74041" def test_float64(self): array = pa.array([1.5, None, -3.14, 0.0], type=pa.float64()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000028e4f1d81093e5dc9803b9ff7ba4272fbef115c7f5b79ce27ba1d607cec28abda" + assert result == "000002f2dd5acce604d642d652fbbbc3bfb16807f36100aff5a84d1f6acb194e4d90e9" # --------------------------------------------------------------------------- @@ -261,37 +261,37 @@ def test_date32(self): """Date32: days since Unix epoch.""" array = pa.array([0, 18993, None, -1], type=pa.date32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000027ee217bff78ba6d2162a3db9a312cda38eab812fa04b2bdae45c44caef53310a" + assert result == "00000248ddc5205e534b4a5dd91fb3ce5b5c4cddff659844e77de731435ab8eda086cc" def test_date64(self): """Date64: ms since Unix epoch.""" array = pa.array([0, 1_640_995_200_000, None, -86_400_000], type=pa.date64()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000243d93d2e644621c13ea350b6ce991e5183713cce06cccc78fa67bd45f28bfec8" + assert result == "00000273f2b0aeedb498d6980083f025b8e0c07c74c57c9130aabfed2af1b31e5ee0af" def test_time32_seconds(self): """Time32(s): seconds since midnight.""" array = pa.array([1000, None, 5000, 0], type=pa.time32("s")) result = ArrowDigester.hash_array(array).hex() - assert result == "0000025ea1da45fe10e3034a18052542883c0c234353fc229ba1ab9423292d557fabe5" + assert result == "0000026708f2d0b632bf3f324716cd32c7c41dd8b9bc75d326fb5ec3f3900201f08eb7" def test_time32_milliseconds(self): """Time32(ms): milliseconds since midnight.""" array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time32("ms")) result = ArrowDigester.hash_array(array).hex() - assert result == "00000246464b1335534e9caa69343551ad1f7eefe77df8a8201468eb1f5f8a469892dd" + assert result == "0000028211097939067b80d7b9d622b88201aedc86254255f02f513e3acbf8da34e04a" def test_time64_microseconds(self): """Time64(us): microseconds since midnight.""" array = pa.array([1_000_000, None, 5_000_000, 0], type=pa.time64("us")) result = ArrowDigester.hash_array(array).hex() - assert result == "0000025360527b27a5170c14a2f6e4493d940d29e27678d80899dd94655a4884a5589b" + assert result == "0000022ddc0ab9c1cfc0fda9353d66612a504cb63d6ee509c4f56b961f33855f1a82a4" def test_time64_nanoseconds(self): """Time64(ns): nanoseconds since midnight.""" array = pa.array([1_000_000_000, None, 5_000_000_000, 0], type=pa.time64("ns")) result = ArrowDigester.hash_array(array).hex() - assert result == "0000025ba5fbd24942a70134a20ba575e71d66d54d3144872745d3239864baf8378aa1" + assert result == "0000020ec4f4365fc43e57f5a229faf87d5e90dbe3ff53f64844c7bae443bb5c35bf07" # --------------------------------------------------------------------------- @@ -304,13 +304,13 @@ def test_binary(self): """Binary array — tests LargeBinary canonicalization.""" array = pa.array([b"hello", None, b"world", b""], type=pa.binary()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" + assert result == "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" def test_large_binary_equals_binary(self): """LargeBinary and Binary arrays with same data must produce the same hash.""" small = pa.array([b"hello", None, b"world", b""], type=pa.binary()) large = pa.array([b"hello", None, b"world", b""], type=pa.large_binary()) - expected = "000002ce0c8cc68b264f3040513d6fb5a94e4ec6b4b53a2baaad3cc0fd4d5a1b5e3f3d" + expected = "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -318,13 +318,13 @@ def test_string(self): """String (Utf8) array — tests LargeUtf8 canonicalization.""" array = pa.array(["hello", None, "world", ""], type=pa.utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + assert result == "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" def test_large_string_equals_string(self): """LargeUtf8 and Utf8 arrays with same data must produce the same hash.""" small = pa.array(["hello", None, "world", ""], type=pa.utf8()) large = pa.array(["hello", None, "world", ""], type=pa.large_utf8()) - expected = "000002445ec6b02f286788f52986673493d9d2c7d2efe4b4870fa780aeec77fbaa0385" + expected = "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -347,7 +347,7 @@ def test_decimal_precision_9_scale_2(self): type=pa.decimal128(9, 2), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002e83147c84038cb72cb3cc8e24e651e0491028c449cfe7f2a9d51ded84391ca40" + assert result == "0000021480fe62da952e0f819540738817488f0da864a59e70604f88f00f6daec3a7fb" def test_decimal_precision_15_scale_3(self): """Decimal128 precision=15 (maps to decimal64 range) scale=3.""" @@ -356,7 +356,7 @@ def test_decimal_precision_15_scale_3(self): type=pa.decimal128(15, 3), ) result = ArrowDigester.hash_array(array).hex() - assert result == "00000226d3b5c66b1fa3b3de097542369f89b2717f3026c778ce17d57817fbf2fec8f0" + assert result == "000002efb97088aa7fc1adc578e6d68d0f2d2dbe5ef25b0999fcd7e7208ede6e7b2a41" def test_decimal_precision_38_scale_5(self): """Decimal128 precision=38 scale=5 — full 16-byte integer path.""" @@ -370,7 +370,7 @@ def test_decimal_precision_38_scale_5(self): type=pa.decimal128(38, 5), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000026193b4a954e812702fc77e319e834483780ac424d0b54fa9bf7163c90a9ab163" + assert result == "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" # --------------------------------------------------------------------------- @@ -391,7 +391,7 @@ def test_list_of_int32(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" + assert result == "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" def test_large_list_equals_list(self): """LargeList with the same data must produce the same hash as List.""" @@ -403,7 +403,7 @@ def test_large_list_equals_list(self): [[1, 2, 3], None, [4, 5], [6]], type=pa.large_list(pa.field("item", pa.int32(), nullable=True)), ) - expected = "000002e3c042074d4a197ca8b2f7e5aeae99b9cc9010a53b6c63120086d4e9688fd533" + expected = "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -427,7 +427,7 @@ def test_struct_with_nullable_children(self): ) batch = pa.record_batch({"s": s_col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002ae1910889fd81f51e1506c4d911e04df5ac428834f4acd3a8e91ae4a65809351" + assert result == "00000223f577c71ad70b36baf8db3ae57304492642edeab6f98560180b624eb7127d40" def test_struct_field_order_independence(self): """Struct fields in different order must hash identically (order-independence).""" @@ -525,7 +525,7 @@ def test_multi_type_record_batch(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002915edae36a72a8337dd20f2536739344a71fb6d12cfbd7e15ba5813d9399f8ce" + assert result == "000002cb129d9295971fe47548a28b3070f18a4a000d449aa6e612446c37e7a104bdb2" def test_multi_type_schema_only(self): """Empty (no-rows) digester over the large multi-type schema.""" @@ -556,7 +556,7 @@ def test_multi_type_schema_only(self): pa.field("decimal128", pa.decimal128(38, 5), nullable=True), ]) result = ArrowDigester(schema).finalize().hex() - assert result == "00000237415d17fd5904b31ed46c94418a47339c656e6270fb1a065479cf153d4641ee" + assert result == "00000221f1240fabe97f742ddb3195193cf785f61e327b7d64ec7363bbbce399df7e50" # --------------------------------------------------------------------------- @@ -589,7 +589,7 @@ def test_streaming_two_batches(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "000002cfdbea6ff7282f0edaf4d7ca6015565dec2c8eb05073aeb6452ff83414cb8a43" + assert result == "0000020ba4ed542e67ebc311d160ab54a11f25630a6b5fdd99e5dfc90917cb1d31e968" def test_batch_split_independence(self): """Splitting a batch into two must not change the hash.""" @@ -627,37 +627,37 @@ class TestTimestampDurationHashing: def test_timestamp_second_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("s", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "00000252859a0dad006bac78dd1ba3fa17fde43bfa2af9cc95bdd08b6611da1691f012" + assert ArrowDigester.hash_array(arr).hex() == "00000255a8e82e6e1862a461c70c393f105522ee7fd6f4ed889fd69d21ace4bb54622e" def test_timestamp_millisecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ms", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "000002f6dcd4d91471e975d86257785c15f0d8e120a84b45f163378e913d10935f1ec9" + assert ArrowDigester.hash_array(arr).hex() == "0000026b928249c5b3e8a99fff770aa7cff273da347a8dd5ee5c1647e7a03b41aeeac5" def test_timestamp_microsecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("us", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "00000209c1c989349caa973563a880521cbcaaa4e62ccc77f380e69f0fc57c639b4bfa" + assert ArrowDigester.hash_array(arr).hex() == "0000023277d54aec4f229bfd0f21e772c332d2d4851c8af07b3f36be29f655b91b6b48" def test_timestamp_nanosecond_utc(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ns", tz="UTC")) - assert ArrowDigester.hash_array(arr).hex() == "0000021d86082dfda0e2f0449320c2acd853756d79dc3080cf1ee14327c7c9f2201480" + assert ArrowDigester.hash_array(arr).hex() == "0000022d542c28b882c3e78bd1758a04c628c829efb9c16e78ad4185cd97e45544e988" # -- Timestamp (tz-naive) ---------------------------------------------- def test_timestamp_second_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("s")) - assert ArrowDigester.hash_array(arr).hex() == "0000028fa5d6fbc775327e0c766cab77a00991dc87cf7ac7d45f875d049559b55cbb3e" + assert ArrowDigester.hash_array(arr).hex() == "00000219b77ac863025bc3a0c519594e873846eaed63ed9d7c16763ad9eb36016623ed" def test_timestamp_millisecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ms")) - assert ArrowDigester.hash_array(arr).hex() == "000002c0d0e86c4e7ff759ad83bf887cf5b20f2b662ceeeba5865ed1f5353b6b7a9445" + assert ArrowDigester.hash_array(arr).hex() == "000002973baeb308b246159206a6072825f4cb786d05ddff11649199c93df22abdaac7" def test_timestamp_microsecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("us")) - assert ArrowDigester.hash_array(arr).hex() == "000002148a265e62ae6878931d8d3316c4aec43f50da2e688d83bfe62901c3703e6b4f" + assert ArrowDigester.hash_array(arr).hex() == "000002fe90da5f713e78f96eed1bf834e6fe2f871aa2c7f28174d8a2dcb3134f5dc4cc" def test_timestamp_nanosecond_naive(self): arr = pa.array([0, None, 1_000], type=pa.timestamp("ns")) - assert ArrowDigester.hash_array(arr).hex() == "00000292c1b50fa17e537e6afb5903cce37b5b28b03088e6ec3e23c346d9adafb071a7" + assert ArrowDigester.hash_array(arr).hex() == "00000275a347fae688071e8d3d94d6ff48800f3dbbd9d8fc629c871eb4e16dd3e59976" # -- Timestamp: unit and tz produce different hashes ------------------- @@ -683,19 +683,19 @@ def test_timestamp_tz_differs(self): def test_duration_second(self): arr = pa.array([0, None, 1_000], type=pa.duration("s")) - assert ArrowDigester.hash_array(arr).hex() == "000002f4db00404adc309eaa3c23518b36b56a44659edc0a4c4dbbddea90449cf90413" + assert ArrowDigester.hash_array(arr).hex() == "000002ac73fa834511e4de143e7f5da1f2b6bef168f25a6d47f7851dd977328eaf20cc" def test_duration_millisecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("ms")) - assert ArrowDigester.hash_array(arr).hex() == "000002767dcb630f550d41da343f63fb308d1e2ce97e68306f988573178da666fb156f" + assert ArrowDigester.hash_array(arr).hex() == "000002cfc3e82b4f82cf9a39f2f86fb495acb6f481b91643bd8f5591a2ed34f794ee9a" def test_duration_microsecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("us")) - assert ArrowDigester.hash_array(arr).hex() == "00000267a46b80b8577b61b24e665edbe71f78d6af7170305cbe0b348ca07a1b2874d9" + assert ArrowDigester.hash_array(arr).hex() == "0000022c8e105be42590d0cd332abcf8330269689cf66767322d1ba799271c6346744d" def test_duration_nanosecond(self): arr = pa.array([0, None, 1_000], type=pa.duration("ns")) - assert ArrowDigester.hash_array(arr).hex() == "00000265d49688aae1ade659148d969f4fd703fa688fd7e3dcbe3c00d5e7ef2ae50720" + assert ArrowDigester.hash_array(arr).hex() == "00000257be9b6546267351273ab5c9bd7858c17b17b093f7f65a599bad8bde37ab5c9e" def test_duration_units_differ(self): values = [1_000, 2_000] diff --git a/tests/test_golden_parity_format2.py b/tests/test_golden_parity_format2.py index 38737db..1704b53 100644 --- a/tests/test_golden_parity_format2.py +++ b/tests/test_golden_parity_format2.py @@ -65,8 +65,8 @@ def _hash(vector: dict[str, Any]) -> str: # Counts of the final golden file; the file is append-only, so they can only grow. -_MIN_VECTORS = 323 -_MIN_RELATIONS = 89 +_MIN_VECTORS = 339 +_MIN_RELATIONS = 96 def test_fixture_is_well_formed() -> None: diff --git a/tests/test_golden_parity_r2.py b/tests/test_golden_parity_r2.py index c22e2c4..c258528 100644 --- a/tests/test_golden_parity_r2.py +++ b/tests/test_golden_parity_r2.py @@ -71,13 +71,13 @@ def test_empty_int32_array(self): """Empty Int32 array (0 elements).""" array = pa.array([], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000023d78a36c387f0a44f74de1ccfde1cf2d8c0fc078b4d1f47d16e5810cffd3be7f" + assert result == "000002b87ccbba66f376281848a40936e3b3697d877c78ec651aa4151939d9f3af2277" def test_empty_bool_array(self): """Empty Boolean array (0 elements).""" array = pa.array([], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "0000020a3aed926ea2ae4c757b1505aa0c887ff47d1af823b1acc601036a4310ede4b4" + assert result == "000002754d4bf287e5b460d403a8468e526e92a738921b2aa8dbab8cc8a3450bcac203" # --------------------------------------------------------------------------- @@ -90,13 +90,13 @@ def test_all_null_int32(self): """Int32 array where every element is null.""" array = pa.array([None, None, None, None], type=pa.int32()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002047d4c739f64e9d20e876901a967f19b17e7c3f749e30342f03f798d51e04d33" + assert result == "000002a51121a9cb745bbcd08ebba07ce33ef64dcb630c241d4112d27d15106e3889d7" def test_all_null_string(self): """LargeString array where every element is null.""" array = pa.array([None, None, None], type=pa.large_utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002879ade9f01775e3d97277fbd1ec3c48e0281c39847f96869d3a94dd3e8d355fc" + assert result == "0000025a88292c68392ec7d5ac54666139cb4836c9267088dfabef093e7981c322df38" # --------------------------------------------------------------------------- @@ -118,7 +118,7 @@ def test_bool_17_elements(self): type=pa.bool_(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002f8e53d6dd8d7337e07b15dc8dc83d0636c3a1007d936ffa058279d614c08b068" + assert result == "000002d8e326d69087a22ebe44e971f2673272ad044e99927c9c4cfcf1cf26f1e7dcf2" # --------------------------------------------------------------------------- @@ -131,19 +131,19 @@ def test_single_int64(self): """Single Int64 value: 9_999_999_999.""" array = pa.array([9_999_999_999], type=pa.int64()) result = ArrowDigester.hash_array(array).hex() - assert result == "000002ae4689b3dd6b1e4371f832a8df5b1aee55482f8fc995866e09adf37e3a80b770" + assert result == "000002ac6614ba2b81b9238b2888b17d9ccb5eb46a7ea3285c22a1b1ad25997d726e7b" def test_single_string(self): """Single LargeString value: 'hello world'.""" array = pa.array(["hello world"], type=pa.large_utf8()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000204f74cfa9c23214afb9bc7a19fd6815b1c87115bbd295fbd47078e1b90814648" + assert result == "00000229b25b121cf4b425c068c2ac17b1952497cf7015668b73a62f925a078fa69d67" def test_single_bool_false(self): """Single Boolean value: false.""" array = pa.array([False], type=pa.bool_()) result = ArrowDigester.hash_array(array).hex() - assert result == "00000240973c422a2b514e91f409638b9caa9b490e84022e4c85cc7ebc438b08603155" + assert result == "0000023753cbe1173b2b0f1b81ce9de03a7c0a1ba1f5431dabbdbeef99172dd357bb29" # --------------------------------------------------------------------------- @@ -171,7 +171,7 @@ def test_nullable_struct_hash_array(self): mask=mask, ) result = ArrowDigester.hash_array(struct_array).hex() - assert result == "0000021cff2f979e54cd49abdd8d43a19929b0e023ea98a78b7c45700c0d4de7fb5d21" + assert result == "000002f5c5e7555a574364d953e7ebeb45dbc9f232e5707133dd088420924300ae3c58" # --------------------------------------------------------------------------- @@ -201,7 +201,7 @@ def test_three_level_struct_batch(self): ) batch = _record_batch({"top": col}, schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002009faf5f41303751117910475f04c0c6685450681ca6f45daf01446040b984db" + assert result == "000002207e061a060534d98724ad2beabd1cd5d1350e5614104815a6a6c0ef13d8935c" def test_three_level_struct_schema(self): """Schema hash for three-level nested struct.""" @@ -215,7 +215,7 @@ def test_three_level_struct_schema(self): ]) schema = pa.schema([pa.field("top", outer_type, nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000024884c452f6c13da2080e1e9213a74a9dab3b12a0f710e9721d74a12881971bb8" + assert result == "000002613ec04c0f0d49d1eff685ac3ffc3ee80a47ddb2121860f9845ac0d3a33fe7b2" def test_three_level_struct_hash_array(self): """Three-level struct via hash_array. @@ -244,7 +244,7 @@ def test_three_level_struct_hash_array(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "000002c390050372191220b574a0f88980a7cdf8a7982c25c3d5c6d2352e744e200b26" + assert result == "000002db3095dc0093c38b3aa668aee0f1805fc815542685d5d065008dc621512a8096" # --------------------------------------------------------------------------- @@ -275,7 +275,7 @@ def test_struct_with_list_child_batch(self): schema = pa.schema([pa.field("record", struct_type, nullable=False)]) batch = _record_batch([struct_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002a8d980079fe57b52e69f297f5614ec02e45fdb53fdabc08cf05caa92c6064a83" + assert result == "0000027699b386e4e56ce34d2a38f748566a75c36c62ca8f5fa36180f0ea8809ac528c" def test_struct_with_list_child_schema(self): """Schema hash for struct with list child.""" @@ -285,7 +285,7 @@ def test_struct_with_list_child_schema(self): ]) schema = pa.schema([pa.field("record", struct_type, nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000025fcffef6ce20bf6df0f21b8943b4b11045662c09d8d0770b8fa842d662a013f2" + assert result == "00000231878b42f48260f2ba82a63298760afe8d214504d3b97a7019ff9a83eba48682" # --------------------------------------------------------------------------- @@ -315,7 +315,7 @@ def test_nullable_struct_batch(self): schema = pa.schema([pa.field("s", struct_type, nullable=True)]) batch = _record_batch([struct_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000022f9448c97edd56a482426bafca4eccd64ccbec8640970e98f0425ffc0dc95a0b" + assert result == "00000201b1aee1103d35dad74cda3c5a1c01e1aa5468beb02cc3cda5c1cb6c317f2d90" # --------------------------------------------------------------------------- @@ -348,7 +348,7 @@ def test_list_of_struct_hash_array(self): offsets = pa.array([0, 2, 4], type=pa.int64()) list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field)) result = ArrowDigester.hash_array(list_array).hex() - assert result == "0000028264b7ca05055fba21aca4d148535baf3012f3d651999744c16a51327d5fada2" + assert result == "000002c1c713c7ee5c139a8799e83aff16049b6a6a935e3e3f8601e04db05c523e2d7b" def test_nullable_list_of_struct_hash_array(self): """Nullable LargeList via hash_array — row 1 is null. @@ -373,7 +373,7 @@ def test_nullable_list_of_struct_hash_array(self): mask = pa.array([False, True, False], type=pa.bool_()) list_array = pa.LargeListArray.from_arrays(offsets, struct_arr, type=pa.large_list(inner_field), mask=mask) result = ArrowDigester.hash_array(list_array).hex() - assert result == "000002fa2beb54d6af22cf565ee84f090ad7b3d097a2381302adb44f6067f56e63a7ca" + assert result == "000002cd3cde5a0df63e3a6889556920e248890a882572450350a03da90f67f37e9f90" # --------------------------------------------------------------------------- @@ -394,7 +394,7 @@ def test_list_non_nullable(self): type=pa.list_(pa.field("item", pa.int32(), nullable=True)), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002153518ab6f2ec6777784fcf99acfd96dbf8d2941929284676875ae5d1bad1b96" + assert result == "000002c60a39367e08f911e8d99db430267db89ca41e4cef6e87ac01520422354684a6" # --------------------------------------------------------------------------- @@ -427,7 +427,7 @@ def test_struct_mixed_types_hash_array(self): fields=struct_fields, ) result = ArrowDigester.hash_array(struct_arr).hex() - assert result == "0000024e525a6930337eb2b8ce95fe8af77f0afd021b3e5513d9d4d0cddae8acc5e590" + assert result == "00000269c3b3a491ea942d3067cfdf07b67a35bd708e4ee05c45cc302190016ab4a9f7" # --------------------------------------------------------------------------- @@ -469,7 +469,7 @@ def test_mixed_struct_list_batch(self): batch = _record_batch([id_arr, meta_arr, tags_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002fb371b308310a0003de7e0175d54abb92e3792573fb3afbd322e35b544ee87b0" + assert result == "00000227eb7540623891a51b93eb1f133f461cd3231bc03f3d5f36957b452a477b912c" def test_mixed_struct_list_schema(self): """Schema hash for mixed struct + list batch.""" @@ -483,7 +483,7 @@ def test_mixed_struct_list_schema(self): pa.field("item", pa.large_utf8(), nullable=True)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000002fb461efa00640c67b76df00f79bc3428908daaba4ac1232368eb43bf96e616da" + assert result == "0000029f1118411cb35c292b7950a626469bd8cb987faa8c114d6509f09f32ec816cb8" # --------------------------------------------------------------------------- @@ -504,7 +504,7 @@ def test_empty_batch_complex_schema(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "000002f6f2c584b8001599fb6a07e4e30663a931be6b269c552f7b98d717536fbcccfd" + assert result == "000002a157d896c73e72632c68cabed99b8351ca116199217e209552f9bfaf70721cff" def test_empty_batch_complex_schema_hash(self): """Schema hash (hash_schema) for same complex schema.""" @@ -517,7 +517,7 @@ def test_empty_batch_complex_schema_hash(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000002985afdc0c320fdd4641d7bb5cb3eebec474dac7c2aa5679eceba6c53e24186fe" + assert result == "00000286ebe427c00dea251c527cc286dc591efea4d6787cb3b40d3330a476b74f6d6c" # --------------------------------------------------------------------------- @@ -543,7 +543,7 @@ def test_batch_all_null_column(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000023f845b906c1a04b464b662ae67a64229b9790930e69de6cc72d395e4ee8b4752" + assert result == "000002dca3ee7298f6495f2263e45eb2c876c9dc78f5b7462357f3be5f5d6579214e94" # --------------------------------------------------------------------------- @@ -559,7 +559,7 @@ def test_unicode_string_array(self): type=pa.large_utf8(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002f996fdd3ff03ad6faefd5ad734dc7c06d8719ec05794db6b5acae5ff694f5486" + assert result == "0000029f656d188a338cc277592a06b5710796016037efc7fc7cb5746e65bfadd752b4" # --------------------------------------------------------------------------- @@ -581,7 +581,7 @@ def test_binary_varied_sizes(self): type=pa.binary(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000002148db3622e92806eff4feafa117c429c052588ccc7b9120b03f02ff7ef26f6a1" + assert result == "0000020885790654a7ce21e6afdfeaa4ad99490e1871149892eda8acf4d2a403566410" # --------------------------------------------------------------------------- @@ -612,7 +612,7 @@ def test_struct_3field_order_independence(self): h1 = ArrowDigester.hash_array(s1).hex() h2 = ArrowDigester.hash_array(s2).hex() assert h1 == h2, "struct field order should not affect hash_array" - assert h1 == "000002df24f48f927ab26711c1db497b5892eae8779a146bdd9eae7784d49f01593283" + assert h1 == "0000025560faf3d3f3ce308ad2c7129f24f42589e7b25f0c6dc70ddd2aa45f7464111a" # --------------------------------------------------------------------------- @@ -651,7 +651,7 @@ def test_nested_nullable_inner_struct(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "000002e046c146668f0f34a7a9d212d17df6dfc55adad063b1e60b0256fb4b2fdec820" + assert result == "00000236f16a0a8179aefeb33f440a83a7d32aad8993c022796eab539de2e1d63521b8" # --------------------------------------------------------------------------- @@ -680,7 +680,7 @@ def test_list_of_list_hash_array(self): type=pa.large_list(outer_field), ) result = ArrowDigester.hash_array(outer_list).hex() - assert result == "00000223c18487aa7dcb5bfb673a0d69dc41ba597febefe1c241ff26ebc4679bbf31fa" + assert result == "000002215978d8171df62a17e8b85524418ac182dc2b1f2132ab95b8a99922dfc9c725" def test_list_of_list_batch(self): """Record batch with LargeList> column.""" @@ -700,7 +700,7 @@ def test_list_of_list_batch(self): schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) batch = _record_batch([outer_list], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002d4a91c629161ff8126db429572a4cd20c19ffa1d1f31db8c6eec0489d668216f" + assert result == "0000024354ac4eb6cef06e975af9b4a9f110e6baf409446897e122849553b159e6dc27" def test_list_of_list_schema(self): """Schema hash for list-of-list column.""" @@ -708,7 +708,7 @@ def test_list_of_list_schema(self): outer_field = pa.field("item", pa.large_list(inner_field), nullable=False) schema = pa.schema([pa.field("col", pa.large_list(outer_field), nullable=False)]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "000002021a0c07c4ba2f2c8c3185b66e0010ca100b17294188249024aee83cdcca6835" + assert result == "0000023014336b70e541ea20913795de44594938a32b325f17b5f03ed6ebf09859a95a" # --------------------------------------------------------------------------- @@ -738,7 +738,7 @@ def test_large_schema_12_fields(self): pa.field("item", pa.int32(), nullable=True)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000021bd0ecec5be7d78beaa0f9af537a44d47b1a7fa9035d0f7fd0050a435b3d277d" + assert result == "000002a89c186dbf815b7192ed4ac574196d1e0203db10d53dd7d16fbe12fbbdbb651e" # --------------------------------------------------------------------------- @@ -760,7 +760,7 @@ def test_schema_list_of_struct_with_list(self): ]), nullable=False)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000029ed92e6613925ec60e34390bae6bf243e8ceac257139e08b62fd7fdd759c85eb" + assert result == "000002a6a3ef288f2975f6a75b0336b2b7d69ffb4a2d129046710b7184d1eb76a45fe2" # --------------------------------------------------------------------------- @@ -783,7 +783,7 @@ def test_schema_4_level_nested_struct(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000023b39cd00c1b1edbe305fcdddaf7e954d288584bfc8e08752098b408920c81162" + assert result == "000002a07f8d13692700d7b2cad515d343a2a1ce4b3dd7deac50316102a43638b496d2" # --------------------------------------------------------------------------- @@ -823,7 +823,7 @@ def test_nullable_list_struct_nullable_children_batch(self): ]) batch = _record_batch([list_array], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002b5fde83bc94e02aa663fe4c1aad59a5280c6f0d487decd0b66801abe35d43104" + assert result == "000002411fa81d41e904d832eceea8e2041fc96bda4e4dc58e72b76380e086d400a008" # --------------------------------------------------------------------------- @@ -843,7 +843,7 @@ def test_struct_empty_batch(self): ]) d = ArrowDigester(schema) result = d.finalize().hex() - assert result == "0000028a33a2eeedd0ab0c78292441615250f4e2dd5d37da6d1bd98ed43ee003ea1f93" + assert result == "000002aaafa89ee39b32668aeb6f65c56501061b7194257ea88f14c3be0eca314f1d0d" # --------------------------------------------------------------------------- @@ -881,7 +881,7 @@ def test_multi_batch_struct(self): d.update(batch1) d.update(batch2) result = d.finalize().hex() - assert result == "0000023aa02f66b4e83360ebc47d3c74f6dd9c3ed9fde617a8218bfaaa48817f3f2da2" + assert result == "0000025d4b5b129c220a3171a616f1ff060a00fdb3647a34434f4d83e9d0a68502c334" # --------------------------------------------------------------------------- @@ -915,7 +915,7 @@ def test_multi_batch_list(self): d.update(batch1) d.update(batch2) result = d.finalize().hex() - assert result == "000002a13b117b286d47ac47a1f53af3dfacb479530fb59152da40b8213429ec310519" + assert result == "00000248df16aca0c1f681b8b02cd0c859b3073c238101a6893bfa44d9f536a9819870" # --------------------------------------------------------------------------- @@ -963,7 +963,7 @@ def test_nullable_inner_field(self): Golden value confirmed against Rust (PLT-1048). """ result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=True)).hex() - assert result == "000002880d5a883711e8de86c09cd3bdc4a2da0390e9ae93947c5de4d42675f1033f5a" + assert result == "0000023e818d98ed740fcd8240f4fdb39e4c53581b071c9ab6200a27924c186414f178" def test_non_nullable_inner_field(self): """LargeList with nullable=False item field. @@ -973,7 +973,7 @@ def test_non_nullable_inner_field(self): Golden value confirmed against Rust (PLT-1048). """ result = ArrowDigester.hash_array(self._make_list_array(inner_nullable=False)).hex() - assert result == "000002d7423b057587e976fe344330d7b29694dd4a709d66cf4217ed8d8e1ccc69a39f" + assert result == "0000021a7aa4df873b7627617a5ce9a234a8849202508afc27eda81af271d8b12bf592" def test_nullable_differs_from_non_nullable(self): """Nullable vs non-nullable inner field must produce different hashes.""" @@ -999,7 +999,7 @@ def test_float64_special_values(self): type=pa.float64(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000027660de0bf00761a94c7aa2c6550cce417d9c14e5476ae787e24d555236a973bc" + assert result == "000002b8e0f66c036e26098ba55673ee856b1b23fb6dcb9acfb63207cf8ad6fadc34dd" # --------------------------------------------------------------------------- @@ -1044,7 +1044,7 @@ def test_realistic_batch(self): batch = _record_batch([name_arr, coords_arr, readings_arr], schema=schema) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000002d334ea76f2a30807791177def39034f19caf4e6bd142c23ec05cc192298893de" + assert result == "000002e86fcf5b5a6b21b9f3f4a5f3eb6608c6e531ecabd95cbf365d01089d2a924619" def test_realistic_schema(self): """Schema hash for realistic batch.""" @@ -1058,4 +1058,4 @@ def test_realistic_schema(self): pa.field("item", pa.float32(), nullable=False)), nullable=True), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "00000254036eae7a3edfdcd5960c95be8600f4db97f52b8100c47c4a92d79f8b444792" + assert result == "000002b4caaae1356e990fdb4b8ed43bf8f67bcdc3ee2f094da6e0f71575dc52ec31c9" diff --git a/tests/test_metadata_hashing.py b/tests/test_metadata_hashing.py index ef5c6b8..070e21d 100644 --- a/tests/test_metadata_hashing.py +++ b/tests/test_metadata_hashing.py @@ -127,7 +127,7 @@ def test_default_matches_pinned_golden_value(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch, include_metadata=False).hex() - assert result == "00000292eeae0418072b559ac1b864e6a7e249749582ab32239ffc9443a00dcc18946f" + assert result == "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" class TestSchemaMetadataChangesHash: From ca5dbb1579e9f1fd16b71121439210a703543228 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:10:42 -0800 Subject: [PATCH 41/49] test: point the dictionary-of-List, FixedSizeBinary(0) and hidden-null tests at their golden vectors (ITL-898) Co-Authored-By: Claude Opus 5.5 --- tests/test_format2.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/tests/test_format2.py b/tests/test_format2.py index 210630c..208e2a2 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -757,7 +757,10 @@ def test_nullable_leaves_hashed_in_bounded_chunks(budget, monkeypatch) -> None: def test_zero_width_fixed_size_binary() -> None: - """FixedSizeBinary(0) values contribute no bytes; nulls are still recorded.""" + """FixedSizeBinary(0) values contribute no bytes; nulls are still recorded. + + Cross-language values: golden vectors fsb0_* (tests/test_golden_parity_format2.py). + """ arr = pa.array([b"", None, b""], type=pa.binary(0)) expected = V + sha(ha(), b'{"FixedSizeBinary":0}', u64(3), u64(3) + b"\x05", sha(b"")) assert f2.hash_array(arr) == expected @@ -770,7 +773,10 @@ def test_zero_width_fixed_size_binary() -> None: def test_dictionary_of_list_equals_plain_list() -> None: - """A dictionary whose values are a List (32-bit offsets) hashes as the plain list.""" + """A dictionary whose values are a List (32-bit offsets) hashes as the plain list. + + Cross-language values: golden vectors dict_of_list_* == plain_list_*. + """ lt = pa.list_(pa.int32()) dict_arr = pa.DictionaryArray.from_arrays(pa.array([0, 1, 0, 2, None], pa.int8()), pa.array([[1, 2], [3], None], lt)) plain = pa.array([[1, 2], [3], [1, 2], None, None], lt) @@ -786,7 +792,10 @@ def test_dictionary_of_list_equals_plain_list() -> None: def test_list_non_nullable_items_with_hidden_child_nulls() -> None: - """Child nulls under a null list slot or outside the offsets are not elements (accepted).""" + """Child nulls under a null list slot or outside the offsets are not elements (accepted). + + Cross-language values: golden vectors hidden_null_{list,large_list}_rb_f0 == clean_*. + """ t = pa.list_(pa.field("item", pa.int32(), nullable=False)) schema = pa.schema([pa.field("l", t)]) child = pa.array([1, None, 2, None], pa.int32()) From 376ef568236bf8c63a74f6de75ee7f8bcf469512 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:13:31 -0800 Subject: [PATCH 42/49] test: pin the spec's printed hashes of Examples 1 and 5 (starfix d145d89) (ITL-898) Co-Authored-By: Claude Opus 5.5 --- tests/test_format2.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_format2.py b/tests/test_format2.py index 208e2a2..ef33791 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -156,6 +156,7 @@ def test_example_1_record_batch() -> None: u64(2) + b"\x01", sha(u64(1) + b"x"), ) + assert (V + final).hex() == "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" # printed assert f2.hash_record_batch(batch) == V + final @@ -235,6 +236,7 @@ def test_example_4_as_printed_with_non_nullable_child() -> None: def test_example_5_hash_array() -> None: expected = V + sha(ha(), b'"Int32"', u64(3), all_valid(3), sha(i32(1, 2, 3))) + assert expected.hex() == "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" # printed assert f2.hash_array(pa.array([1, 2, 3], pa.int32())) == expected boolean = V + sha(ha(), b'"Boolean"', u64(3), u64(3) + b"\x05", sha(b"\x01\x00")) assert f2.hash_array(pa.array([True, None, False])) == boolean From 50aff53fed92b286f6197a3bcb9cb361d0e6ec5f Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:15:07 -0800 Subject: [PATCH 43/49] fix: read exported metadata through __arrow_c_schema__; pin all spec-printed hashes (starfix bcbe74a) (ITL-898) - metadata pairs (duplicate detection, extension keys of pyarrow-native types) are read from the PyCapsule returned by __arrow_c_schema__(), the documented Arrow C data interface route in spec 2.3, instead of the private _export_to_c; the capsule releases the exported schema - Map, FixedSizeList and non-ASCII hash_array printed hashes pinned (all five printed values of spec bcbe74a now pinned) - README extension-type wording aligned with spec 2.3 Co-Authored-By: Claude Opus 5.5 --- README.md | 15 ++++--- src/starfix/_format2.py | 87 +++++++++++++++++++++-------------------- tests/test_format2.py | 3 ++ 3 files changed, 56 insertions(+), 49 deletions(-) diff --git a/README.md b/README.md index 41e0f55..7dec3d8 100644 --- a/README.md +++ b/README.md @@ -99,12 +99,15 @@ rebuilds the type from them, so starfix-python hashes what pyarrow can observe: whether the type is registered in the hashing process. - **pyarrow's built-in canonical extension types** (`arrow.uuid`, `arrow.json`, `arrow.bool8`, `arrow.opaque`, `arrow.fixed_shape_tensor`, `arrow.variable_shape_tensor`, depending on the - pyarrow version): pyarrow re-serializes their metadata and rebuilds their storage type, so - the hash is defined only for the canonical stored form, the one every Arrow implementation - writes. It differs from Rust when the stored data is not canonical, for example: - `arrow.json` stored with metadata `{}` instead of `""`; `arrow.opaque` or tensor metadata - JSON with another key order or whitespace; a fixed-shape tensor stored over a non-nullable - item field. + pyarrow version): they have no `__arrow_ext_serialize__` in Python, so both keys are read + from the field exported through the Arrow C data interface (`field.__arrow_c_schema__()`), + which carries the serialization pyarrow reconstructs from its own definition; pyarrow also + rebuilds their storage type. Their hash is therefore defined only when the stored + `ARROW:extension:metadata` is byte-identical to that serialization and the stored storage + type is the one pyarrow rebuilds (the form every Arrow implementation writes). Known stored + forms that differ from Rust: `arrow.json` stored with `{}` (pyarrow reconstructs `""`); + `arrow.opaque` or tensor metadata JSON with another key order or with whitespace; a + fixed-shape tensor stored over a non-nullable item field. ## Rejected inputs diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 5930643..c76dbe3 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -226,53 +226,54 @@ def _extension_metadata(t: pa.DataType) -> dict[str, str]: def _exported_metadata_pairs(obj) -> list[tuple[bytes, bytes]]: """Key/value pairs of a Field's, Schema's or DataType's metadata as Arrow exports them. - Read through the Arrow C data interface (ArrowSchema.metadata, a fixed, documented ABI: - int32 count, then per pair int32 length + key bytes, int32 length + value bytes). Unlike - pyarrow's ``metadata`` dict this keeps duplicate keys, and for a registered extension - type it carries the ARROW:extension:* keys pyarrow writes for the type. + Read through the Arrow C data interface: ``obj.__arrow_c_schema__()`` returns a PyCapsule + holding an ``ArrowSchema`` (a fixed, documented ABI) whose metadata is int32 count, then + per pair int32 length + key bytes, int32 length + value bytes. Unlike pyarrow's + ``metadata`` dict this keeps duplicate keys, and for a registered extension type it + carries the ARROW:extension:* keys as the type serializes them. The capsule owns the + exported schema and releases it. """ import ctypes class _ArrowSchema(ctypes.Structure): - pass - - _ArrowSchema._fields_ = [ - ("format", ctypes.c_char_p), - ("name", ctypes.c_char_p), - ("metadata", ctypes.c_void_p), - ("flags", ctypes.c_int64), - ("n_children", ctypes.c_int64), - ("children", ctypes.c_void_p), - ("dictionary", ctypes.c_void_p), - ("release", ctypes.CFUNCTYPE(None, ctypes.c_void_p)), - ("private_data", ctypes.c_void_p), - ] - c_schema = _ArrowSchema() - obj._export_to_c(ctypes.addressof(c_schema)) - try: - pairs: list[tuple[bytes, bytes]] = [] - if c_schema.metadata: - pos = c_schema.metadata - - def read_int32() -> int: - nonlocal pos - value = ctypes.c_int32.from_address(pos).value - pos += 4 - return value - - def read_bytes(n: int) -> bytes: - nonlocal pos - value = ctypes.string_at(pos, n) - pos += n - return value - - for _ in range(read_int32()): - key = read_bytes(read_int32()) - pairs.append((key, read_bytes(read_int32()))) - return pairs - finally: - if c_schema.release: - c_schema.release(ctypes.addressof(c_schema)) + _fields_ = [ + ("format", ctypes.c_char_p), + ("name", ctypes.c_char_p), + ("metadata", ctypes.c_void_p), + ("flags", ctypes.c_int64), + ("n_children", ctypes.c_int64), + ("children", ctypes.c_void_p), + ("dictionary", ctypes.c_void_p), + ("release", ctypes.c_void_p), + ("private_data", ctypes.c_void_p), + ] + + get_pointer = ctypes.pythonapi.PyCapsule_GetPointer + get_pointer.restype = ctypes.c_void_p + get_pointer.argtypes = [ctypes.py_object, ctypes.c_char_p] + capsule = obj.__arrow_c_schema__() + c_schema = _ArrowSchema.from_address(get_pointer(capsule, b"arrow_schema")) + pairs: list[tuple[bytes, bytes]] = [] + if c_schema.metadata: + pos = c_schema.metadata + + def read_int32() -> int: + nonlocal pos + value = ctypes.c_int32.from_address(pos).value + pos += 4 + return value + + def read_bytes(n: int) -> bytes: + nonlocal pos + value = ctypes.string_at(pos, n) + pos += n + return value + + for _ in range(read_int32()): + key = read_bytes(read_int32()) + pairs.append((key, read_bytes(read_int32()))) + del c_schema, capsule # the capsule's destructor releases the exported schema + return pairs def _exported_extension_metadata(t: pa.DataType) -> bytes: diff --git a/tests/test_format2.py b/tests/test_format2.py index ef33791..0fdf54a 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -85,6 +85,7 @@ def test_map_example() -> None: b'{"data_type":"Int32","name":"z","nullable":false}]},"nullable":true}}},"nullable":true}}' ) assert f2.hash_schema(schema) == V + sha(hs(), json_) + assert f2.hash_schema(schema).hex() == "000002f772b5bc6bb814d98a3bb68a6148dde15eaa590ad54b289c51f9cc4636a52ba7" # printed def test_fixed_size_list_example() -> None: @@ -92,12 +93,14 @@ def test_fixed_size_list_example() -> None: json_ = b'{"f":{"data_type":{"FixedSizeList":[{"data_type":"Int32","nullable":true},2]},"nullable":false}}' assert f2.hash_schema(schema) == V + sha(hs(), json_) + assert f2.hash_schema(schema).hex() == "0000022fe3f8d8fcba7e393f3c5808894db2f930a8bd8388e9d04b3763d369cc6eae88" # printed def test_hash_array_non_ascii_example() -> None: arr = pa.StructArray.from_arrays([pa.array([1], pa.int32())], fields=[pa.field("é", pa.int32(), nullable=False)]) type_json = '{"Struct":[{"data_type":"Int32","name":"é","nullable":false}]}'.encode() assert f2.hash_array(arr) == V + sha(ha(), type_json, u64(1), all_valid(1), sha(i32(1))) + assert f2.hash_array(arr).hex() == "00000219e467d0280ccc83ad4c67e063997344cedd781f6cb4e449d03d713c989aa12b" # printed def test_json_text_rules() -> None: From c70c4499d80bf60f8065b0355fb1e5ba042c6126 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:19:32 -0800 Subject: [PATCH 44/49] docs: design note describes the legacy 0.4 module and the no-skip golden contract (ITL-898) Copilot review: the Python design note still said no format-1 code is kept and described version-gated golden-test skips that were removed. Co-Authored-By: Claude Opus 5.5 --- .../specs/2026-11-11-format-2-python.md | 23 ++++++++++++++----- 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/docs/metamorphic/specs/2026-11-11-format-2-python.md b/docs/metamorphic/specs/2026-11-11-format-2-python.md index e9da2ef..6f3e0ce 100644 --- a/docs/metamorphic/specs/2026-11-11-format-2-python.md +++ b/docs/metamorphic/specs/2026-11-11-format-2-python.md @@ -15,8 +15,16 @@ This note records only the Python-specific decisions. ## Implementation - `src/starfix/_format2.py` implements the spec, written from the spec text alone. - `ArrowDigester` (`src/starfix/arrow_digester.py`) is a thin public wrapper. No format-1 code - is kept: format-1 hashes are computed with starfix 0.4. + `ArrowDigester` (`src/starfix/arrow_digester.py`) is a thin public wrapper, format 2 only. +- Format 1 stays available through the frozen **legacy 0.4 mode**, `starfix.legacy.v0_4` + (`src/starfix/legacy/v0_4.py`): starfix-python v0.4.0's hasher verbatim except one marked, + performance-only line, for reading or matching data hashed by 0.4.x (developer decision + 2026-11-11; no separate 0.4 installation is needed). It is deliberately kept, not obsolete: + it is physically separate from the format-2 code (no imports either way), its sha256 is + pinned by `tests/test_legacy_v0_4_frozen.py`, its output by the restored v0.4.0 tests + (`tests/test_legacy_v0_4_*.py`, including `include_metadata_v0.3.json`), and its + byte-identity with the released `starfix==0.4.0` by `scripts/legacy_differential.py` (CI job + `legacy-differential`). It is never fixed or extended. - Data is processed per node and per batch on Arrow buffers (`filter`, `flatten`, `value_lengths`, validity bitmaps appended at arbitrary bit offsets, fixed-width values as buffer slices, strings and binary from the offsets and data buffers in bounded chunks). Every @@ -28,8 +36,9 @@ This note records only the Python-specific decisions. `pa.ExtensionType` subclasses, `__arrow_ext_serialize__()`. pyarrow's natively registered canonical types (`arrow.uuid`, `arrow.fixed_shape_tensor`, ...) have no Python serializer, so their metadata is read from the field exported through the Arrow C data interface - (`ArrowSchema.metadata`, a fixed ABI). The spec defines their hash only for the canonical - stored form. + (`field.__arrow_c_schema__()`, `ArrowSchema.metadata`). The spec defines their hash only for + the canonical stored form. The same reader detects duplicate metadata keys, which are + rejected with `include_metadata`. - Validity bits, lengths and values follow the spec's one rule. Effective validity (own AND enclosing struct validity) is computed for every node and written for nullable nodes only. @@ -39,8 +48,10 @@ This note records only the Python-specific decisions. from the literal SHA-256 inputs; primitive forms, JSON text rules, metadata paths, names not hashed, invariants, every rejection, streaming, extension types, dictionary nullability, and slicing at offsets around byte and word boundaries. -- `tests/test_golden_parity_format2.py`: every vector and relation of `format2_v0.5.json`. - The only skips are version-gated (vectors an older installed pyarrow cannot decode). +- `tests/test_golden_parity_format2.py`: every vector and relation of `format2_v0.5.json` + must match, with no skips and no expected failures (pyarrow >= 19, the supported minimum, + decodes every vector; CI also runs the suite on exactly pyarrow 19.0.0). The test asserts + minimum vector and relation counts, and an empty parametrization fails at collection. - The hand-coded literals of the older test files were moved to Rust-produced format-2 values (`format1_to_format2.json`). Literals that file did not cover had their inputs recovered by recording the calls that produced them (`python_literals_format1_inputs.json`), so Rust could From 758a26b10edada7f33b972314a172103872a13dd Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:22:49 -0800 Subject: [PATCH 45/49] fix(format2): refuse big-endian hosts; tests for decoded dictionary validity at depth and the FixedSizeList element path (ITL-898) Spec re-read at starfix 9c9a88c: - Section 13: hashes are defined over little-endian buffers; values are hashed as stored, so every format-2 entry point raises NotImplementedError on a big-endian host (README 'Platforms') - dictionary validity is that of the decoded array at any depth: tested for a column, a struct child and a list element - the FixedSizeList element node f/ claims its path: tested Co-Authored-By: Claude Opus 5.5 --- README.md | 8 ++++++++ src/starfix/_format2.py | 15 +++++++++++++++ tests/test_format2.py | 41 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 64 insertions(+) diff --git a/README.md b/README.md index 7dec3d8..6f3e539 100644 --- a/README.md +++ b/README.md @@ -131,6 +131,14 @@ rebuilds the type from them, so starfix-python hashes what pyarrow can observe: `TypeError` is raised for a wrong container type, for example a `Table` passed to `hash_record_batch` or a `RecordBatch` passed to `hash_table`. +## Platforms + +Hash format 2 is defined over little-endian buffers (all lengths, counts and values are +little-endian). starfix-python hashes Arrow buffers as stored, which is correct on +little-endian hosts (x86-64, ARM64 and nearly all others). On a big-endian host every +format-2 entry point raises `NotImplementedError` instead of producing wrong hashes. The Rust +crate has the same restriction. + ## Performance Hashing takes time linear in the data size and works on Arrow buffers (bounded temporary diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index c76dbe3..67044bb 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -9,6 +9,7 @@ import hashlib import json import struct +import sys from typing import TYPE_CHECKING, Any import pyarrow as pa @@ -30,6 +31,17 @@ KIND_ARRAY = b"A" # hash_array _SCHEMA_MISMATCH = "Record batch schema does not match ArrowDigester schema" + +# Section 13: hashes are defined over little-endian buffers, and values are hashed as stored +# in Arrow's native-endian buffers, so big-endian hosts are refused rather than mis-hashed. +_LITTLE_ENDIAN_HOST = sys.byteorder == "little" + + +def _require_little_endian() -> None: + if not _LITTLE_ENDIAN_HOST: + raise NotImplementedError( + "starfix hash format 2 is defined over little-endian buffers; big-endian hosts are not supported" + ) _U64 = struct.Struct(" None: + _require_little_endian() _require(schema, pa.Schema, "ArrowDigester", "a pyarrow.Schema") self._flags = flags_of(ordered_columns, ordered_struct_fields) self._include_metadata = include_metadata @@ -763,6 +776,7 @@ def _require(obj, cls, entry_point: str, expected: str) -> None: def hash_schema(schema: pa.Schema, *, include_metadata: bool = False, ordered_columns: bool = False, ordered_struct_fields: bool = False) -> bytes: + _require_little_endian() _require(schema, pa.Schema, "hash_schema", "a pyarrow.Schema") return VERSION_BYTES + schema_digest(schema, include_metadata, flags_of(ordered_columns, ordered_struct_fields)) @@ -788,6 +802,7 @@ def hash_array(array: pa.Array, *, ordered_columns: bool = False, ordered_struct Its validity is always written: the logical validity after decoding dictionaries (a valid dictionary key that points at a null dictionary value is a null). """ + _require_little_endian() _require(array, (pa.Array, pa.ChunkedArray), "hash_array", "a pyarrow.Array or pyarrow.ChunkedArray") flags = flags_of(ordered_columns, ordered_struct_fields) root = pa.field("", array.type, nullable=True) diff --git a/tests/test_format2.py b/tests/test_format2.py index 0fdf54a..43c2d06 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -930,3 +930,44 @@ def test_bits_restore_after_partial_appends() -> None: reference = _Bits() reference.append_true(prefix + 2) assert bits._len == reference._len and bytes(bits._bytes) == bytes(reference._bytes), prefix + + +# ── Spec re-read at starfix 9c9a88c ────────────────────────────────────── + + +def test_dictionary_validity_is_decoded_at_any_depth() -> None: + """A valid index pointing at a null value is a null element, below the root too.""" + d = pa.DictionaryArray.from_arrays(pa.array([0, 1, 0], pa.int8()), pa.array(["a", None])) + plain = pa.array(["a", None, "a"]) + s_dict = pa.StructArray.from_arrays([d], names=["c"]) + s_plain = pa.StructArray.from_arrays([plain], names=["c"]) + assert f2.hash_record_batch(pa.record_batch([s_dict], names=["s"])) == f2.hash_record_batch( + pa.record_batch([s_plain], names=["s"]) + ) + l_dict = pa.ListArray.from_arrays(pa.array([0, 2, 3], pa.int32()), d) + l_plain = pa.ListArray.from_arrays(pa.array([0, 2, 3], pa.int32()), plain) + assert f2.hash_record_batch(pa.record_batch([l_dict], names=["l"])) == f2.hash_record_batch( + pa.record_batch([l_plain], names=["l"]) + ) + assert f2.hash_record_batch(pa.record_batch([d], names=["c"])) == f2.hash_record_batch( + pa.record_batch([plain], names=["c"]) + ) + + +def test_fixed_size_list_element_node_claims_its_path() -> None: + with pytest.raises(ValueError, match="Ambiguous node path 'f/'"): + f2.hash_schema(pa.schema([pa.field("f", pa.list_(pa.int8(), 2)), pa.field("f/", pa.int8())])) + + +def test_big_endian_hosts_are_refused(monkeypatch) -> None: + """Section 13: hashes are defined over little-endian buffers; values are hashed as stored.""" + monkeypatch.setattr(f2, "_LITTLE_ENDIAN_HOST", False) + schema = pa.schema([pa.field("a", pa.int32())]) + for call in ( + lambda: f2.hash_schema(schema), + lambda: f2.Digester(schema), + lambda: f2.hash_record_batch(pa.record_batch([pa.array([1], pa.int32())], schema=schema)), + lambda: f2.hash_array(pa.array([1], pa.int32())), + ): + with pytest.raises(NotImplementedError, match="little-endian"): + call() From 98b38b16bf24690b9307b169119f2e783697cc25 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 05:27:38 -0800 Subject: [PATCH 46/49] perf(format2): dictionary validity without scanning a null-free dictionary per batch (ITL-898) Copilot review (needs a closer look): computing dictionary validity took the dictionary's validity per batch, O(batches x dictionary size) for many small batches. When the dictionary has no nulls, validity is the indices' (identical bytes). Regression test: 50 one-row batches over a 10,000-value dictionary make no take() over the dictionary validity. Co-Authored-By: Claude Opus 5.5 --- src/starfix/_format2.py | 4 ++++ tests/test_format2_scaling.py | 23 +++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 67044bb..2245b95 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -467,6 +467,10 @@ def _logical_validity(arr: pa.Array) -> pa.Array | None: """Per-element validity (None: all valid). A dictionary element is valid iff its index is valid and the dictionary value it points to is valid.""" if pa.types.is_dictionary(arr.type): + if arr.dictionary.null_count == 0: + # No null values: validity is the indices' (no work proportional to the + # dictionary, so many small batches over a large dictionary stay linear). + return arr.indices.is_valid() if arr.indices.null_count else None valid = pc.fill_null(pc.take(arr.dictionary.is_valid(), arr.indices), False) return None if pc.all(valid).as_py() is not False else valid return arr.is_valid() if arr.null_count else None diff --git a/tests/test_format2_scaling.py b/tests/test_format2_scaling.py index 6c41068..12ad2cf 100644 --- a/tests/test_format2_scaling.py +++ b/tests/test_format2_scaling.py @@ -107,3 +107,26 @@ def test_dictionary_leaves_are_not_decoded_as_a_whole() -> None: finally: pa.set_memory_pool(default) assert pool.max_memory() < decoded_size // 20, f"Arrow peak {pool.max_memory()} bytes (decoded: {decoded_size})" + + +def test_dictionary_validity_does_not_scan_the_dictionary_per_batch(monkeypatch) -> None: + """With a null-free dictionary, validity comes from the indices alone (no O(D) per batch).""" + calls = 0 + original = f2.pc.take + + def counting_take(*args, **kwargs): + nonlocal calls + calls += 1 + return original(*args, **kwargs) + + monkeypatch.setattr(f2.pc, "take", counting_take) + dictionary = pa.array([f"v{i}" for i in range(10_000)]) + batches = [ + pa.record_batch([pa.DictionaryArray.from_arrays(pa.array([i, None], pa.int32()), dictionary)], names=["d"]) + for i in range(50) + ] + d = f2.Digester(batches[0].schema) + for b in batches: + d.update(b) + d.finalize() + assert calls == 0, f"{calls} take() calls over the dictionary validity" From b90e1965bb8006edb5193a231c467aff3d104b89 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 07:19:34 -0800 Subject: [PATCH 47/49] test(format2): sync golden to starfix e079d56 and pin hidden-null cases Copy tests/golden/format2_v0.5.json byte for byte from starfix e079d56 (sha256 4d5ba202f9fa88e69c94c09947e715c51c5403803b9fa0dfc3ec7dda9582845e; 423 vectors, 114 relations, the previous 339/96 an unchanged prefix) and raise the pinned minimum counts. format1_to_format2.json is unchanged. Add golden-independent tests for the two shapes the Rust review found: a leaf null hidden under a null inner list of a nested list (hash_array, one batch and single-row batches agree with the clean form), and a dictionary of nested structs with a null hidden under a null outer value (dictionary-encoded equals plain), under every option combination. Refs ITL-898 Co-Authored-By: Claude Opus 5.5 --- tests/golden/format2_v0.5.json | 1038 +++++++++++++++++++++++++++ tests/test_format2.py | 69 ++ tests/test_golden_parity_format2.py | 4 +- 3 files changed, 1109 insertions(+), 2 deletions(-) diff --git a/tests/golden/format2_v0.5.json b/tests/golden/format2_v0.5.json index 87b755a..8d7af9e 100644 --- a/tests/golden/format2_v0.5.json +++ b/tests/golden/format2_v0.5.json @@ -3392,6 +3392,846 @@ "ordered_struct_fields": false, "ipc_b64": "/////7gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAEAAABsAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAADwAAAAQAAAAAwAAAAAAAAAAAAAAAgAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", "expected_hash": "000002ed889d3a463ff972ea36d2edefdef90e3262d067eec0c14992a4d19996900dcc" + }, + { + "id": "nested_hidden_list_list_small_rb_f0", + "description": "list_list (small): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_list_list_small_array_f0", + "description": "hash_array: list_list (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_list_list_small_split_f0", + "description": "list_list (small): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_clean_list_list_small_rb_f0", + "description": "list_list (small): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_clean_list_list_small_array_f0", + "description": "hash_array: list_list (small) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_list_list_large_rb_f0", + "description": "list_list (large): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAIAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_list_list_large_array_f0", + "description": "hash_array: list_list (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAIAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_list_list_large_split_f0", + "description": "list_list (large): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_clean_list_list_large_rb_f0", + "description": "list_list (large): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAGAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_clean_list_list_large_array_f0", + "description": "hash_array: list_list (large) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAA4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAGAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_depth3_small_rb_f0", + "description": "depth3 (small): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth3_small_array_f0", + "description": "hash_array: depth3 (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth3_small_split_f0", + "description": "depth3 (small): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAgAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAFwAAAAQAAAAAQAAAAAAAAAAAAAABAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAACAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////84AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAIAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABcAAAAEAAAAAEAAAAAAAAAAAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAACAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_clean_depth3_small_rb_f0", + "description": "depth3 (small): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_clean_depth3_small_array_f0", + "description": "hash_array: depth3 (small) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth3_large_rb_f0", + "description": "depth3 (large): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAACAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth3_large_array_f0", + "description": "hash_array: depth3 (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAACAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth3_large_split_f0", + "description": "depth3 (large): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAABAAAAAAAAAAAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAAAAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAFwAAAAQAAAAAQAAAAAAAAAAAAAABAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAQAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////84AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAIAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABcAAAAEAAAAAEAAAAAAAAAAAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAEAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_clean_depth3_large_rb_f0", + "description": "depth3 (large): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAYAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABgAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_clean_depth3_large_array_f0", + "description": "hash_array: depth3 (large) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAwP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAAACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAYAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABgAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth4_small_rb_f0", + "description": "depth4 (small): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABDPAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEMxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAAQyYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAEAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAQAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_hidden_depth4_small_array_f0", + "description": "hash_array: depth4 (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABDPAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEMxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAAQyYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAEAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAQAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_depth4_small_split_f0", + "description": "depth4 (small): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABDPAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEMxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAAQyYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAQAAAAAAAAAAAAAABQAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAIAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAACAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAIAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////94AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAIAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABsAAAAEAAAAAEAAAAAAAAAAAAAAAUAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAACAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAIAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAgAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAgAAAAAAAAEAAAAAAAAAQAIAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////eAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIACAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAgAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAACAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAIAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAgAAAAAAAAAAAIAAAAAAAABAAAAAAAAAEACAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_clean_depth4_small_rb_f0", + "description": "depth4 (small): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABDPAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEMxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAAQyYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAADAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAMAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_clean_depth4_small_array_f0", + "description": "hash_array: depth4 (small) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABDPAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEMxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAAQyYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAADAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAMAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_depth4_large_rb_f0", + "description": "depth4 (large): hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABFfAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEVxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAARWYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAIAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAgAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_hidden_depth4_large_array_f0", + "description": "hash_array: depth4 (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABFfAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEVxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAARWYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAACAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAIAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAgAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_depth4_large_split_f0", + "description": "depth4 (large): hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_clean_depth4_large_rb_f0", + "description": "depth4 (large): clean null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABFfAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEVxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAARWYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAGAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAYAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_clean_depth4_large_array_f0", + "description": "hash_array: depth4 (large) with clean null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAEAAAAoP///xgAAAAMAAAAAAABFfAAAAABAAAACAAAAJD////A////GAAAAAwAAAAAAAEVxAAAAAEAAAAIAAAAsP///+D///8YAAAADAAAAAAAARWYAAAAAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAgAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAwAAAAAAAAAAAAAABQAAAAMAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABgAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAGAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAYAAAAAAAAAAACAAAAAAAAAQAAAAAAAABAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_struct_depth2_plain_rb_f0", + "description": "Depth 2 plain structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_hidden_struct_depth2_plain_array_f0", + "description": "hash_array: depth 2 plain structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c85f978bfa4c39559b6beb0a09ce850786982344cd662825bf329ec595102ecd" + }, + { + "id": "nested_hidden_struct_depth2_plain_split_f0", + "description": "Depth 2 plain structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_hidden_struct_depth2_dict_rb_f0", + "description": "Depth 2 dict structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAKAAAAAIAAgAAAAEAAgAAAAEAAAAoP///wgAAAAAAAABAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAABAAAAeAAAAP/////4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAAAEAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAATAAAABAAAAADAAAAAAAAAAAAAAADAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_hidden_struct_depth2_dict_array_f0", + "description": "hash_array: depth 2 dict structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAKAAAAAIAAgAAAAEAAgAAAAEAAAAoP///wgAAAAAAAABAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAACAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c85f978bfa4c39559b6beb0a09ce850786982344cd662825bf329ec595102ecd" + }, + { + "id": "nested_hidden_struct_depth2_dict_split_f0", + "description": "Depth 2 dict structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_clean_struct_depth2_plain_rb_f0", + "description": "Depth 2 plain structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAABAAAAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_clean_struct_depth2_plain_array_f0", + "description": "hash_array: depth 2 plain structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2EAAAAAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAAAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABMAAAAEAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c85f978bfa4c39559b6beb0a09ce850786982344cd662825bf329ec595102ecd" + }, + { + "id": "nested_clean_struct_depth2_plain_split_f0", + "description": "Depth 2 plain structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_clean_struct_depth2_dict_rb_f0", + "description": "Depth 2 dict structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAKAAAAAIAAgAAAAEAAgAAAAEAAAAoP///wgAAAAAAAABAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAABAAAAeAAAAP/////4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAAAEAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAATAAAABAAAAADAAAAAAAAAAAAAAADAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_clean_struct_depth2_dict_array_f0", + "description": "hash_array: depth 2 dict structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAKAAAAAIAAgAAAAEAAgAAAAEAAAAoP///wgAAAAAAAABAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002c85f978bfa4c39559b6beb0a09ce850786982344cd662825bf329ec595102ecd" + }, + { + "id": "nested_clean_struct_depth2_dict_split_f0", + "description": "Depth 2 dict structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000026d47158c9da5ab1846508ac32083c71eb94ad3ee0c74ed9bd5209f7ad631bdf8" + }, + { + "id": "nested_hidden_struct_depth3_plain_rb_f0", + "description": "Depth 3 plain structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2sAAAAAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAACAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_hidden_struct_depth3_plain_array_f0", + "description": "hash_array: depth 3 plain structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2sAAAAAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAACAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000020dc6cca0e97491dbf14b20b3eb185bad0b7f563c0bd0a900fa9703fd716e3599" + }, + { + "id": "nested_hidden_struct_depth3_plain_split_f0", + "description": "Depth 3 plain structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_hidden_struct_depth3_dict_rb_f0", + "description": "Depth 3 dict structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAMgAAAAIAAgAAAAEAAgAAAAEAAAAgP///wgAAAAAAAABAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAEABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_hidden_struct_depth3_dict_array_f0", + "description": "hash_array: depth 3 dict structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAMgAAAAIAAgAAAAEAAgAAAAEAAAAgP///wgAAAAAAAABAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAEABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000020dc6cca0e97491dbf14b20b3eb185bad0b7f563c0bd0a900fa9703fd716e3599" + }, + { + "id": "nested_hidden_struct_depth3_dict_split_f0", + "description": "Depth 3 dict structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAMgAAAAIAAgAAAAEAAgAAAAEAAAAgP///wgAAAAAAAABAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAEABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_clean_struct_depth3_plain_rb_f0", + "description": "Depth 3 plain structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2sAAAAAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_clean_struct_depth3_plain_array_f0", + "description": "hash_array: depth 3 plain structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ2sAAAAAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAEABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAXAAAABAAAAADAAAAAAAAAAAAAAAEAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "0000020dc6cca0e97491dbf14b20b3eb185bad0b7f563c0bd0a900fa9703fd716e3599" + }, + { + "id": "nested_clean_struct_depth3_plain_split_f0", + "description": "Depth 3 plain structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_clean_struct_depth3_dict_rb_f0", + "description": "Depth 3 dict structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAMgAAAAIAAgAAAAEAAgAAAAEAAAAgP///wgAAAAAAAABAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAAAQAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAEABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_clean_struct_depth3_dict_array_f0", + "description": "hash_array: depth 3 dict structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAMgAAAAIAAgAAAAEAAgAAAAEAAAAgP///wgAAAAAAAABAQAAAAgAAADA////vP///xgAAAAMAAAAAAAADYAAAAABAAAACAAAAOD////c////HAAAAAwAAAAAAAANWAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAABAAAAaQAAAAEAAABpAAAABQAAAGNoaWxkAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAEABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000020dc6cca0e97491dbf14b20b3eb185bad0b7f563c0bd0a900fa9703fd716e3599" + }, + { + "id": "nested_clean_struct_depth3_dict_split_f0", + "description": "Depth 3 dict structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000286b76a77a45e5c633dedd94d95a2d4aa88f84b106f6c3391b438e5aa810582c9" + }, + { + "id": "nested_hidden_struct_depth4_plain_rb_f0", + "description": "Depth 4 plain structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ3UAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAEAAAB4AAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAADAAAAAAAAAAAAAAAFAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_hidden_struct_depth4_plain_array_f0", + "description": "hash_array: depth 4 plain structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ3UAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAUAAABhcnJheQAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAADAAAAAAAAAAAAAAAFAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAgAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000293bcde8c57c3bbd3aec7e88d4a38f23a763e58e16e8931369d0b64904d0d54f5" + }, + { + "id": "nested_hidden_struct_depth4_plain_split_f0", + "description": "Depth 4 plain structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_hidden_struct_depth4_dict_rb_f0", + "description": "Depth 4 dict structs: hidden non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAPAAAAAIAAgAAAAEAAgAAAAEAAAAYP///wgAAAAAAAABAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAQAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_hidden_struct_depth4_dict_array_f0", + "description": "hash_array: depth 4 dict structs with hidden masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAPAAAAAIAAgAAAAEAAgAAAAEAAAAYP///wgAAAAAAAABAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAQAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000293bcde8c57c3bbd3aec7e88d4a38f23a763e58e16e8931369d0b64904d0d54f5" + }, + { + "id": "nested_hidden_struct_depth4_dict_split_f0", + "description": "Depth 4 dict structs with hidden masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_clean_struct_depth4_plain_rb_f0", + "description": "Depth 4 plain structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ3UAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAEAAAB4AAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAADAAAAAAAAAAAAAAAFAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_clean_struct_depth4_plain_array_f0", + "description": "hash_array: depth 4 plain structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ3UAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAUAAABhcnJheQAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAADAAAAAAAAAAAAAAAFAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000293bcde8c57c3bbd3aec7e88d4a38f23a763e58e16e8931369d0b64904d0d54f5" + }, + { + "id": "nested_clean_struct_depth4_plain_split_f0", + "description": "Depth 4 plain structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_clean_struct_depth4_dict_rb_f0", + "description": "Depth 4 dict structs: clean non-nullable leaf masked by root null", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAPAAAAAIAAgAAAAEAAgAAAAEAAAAYP///wgAAAAAAAABAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAQAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_clean_struct_depth4_dict_array_f0", + "description": "hash_array: depth 4 dict structs with clean masked leaf", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAANEAAAAPAAAAAIAAgAAAAEAAgAAAAEAAAAYP///wgAAAAAAAABAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAQAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAADAAAAAAAAAAAAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8AAAAA", + "expected_hash": "00000293bcde8c57c3bbd3aec7e88d4a38f23a763e58e16e8931369d0b64904d0d54f5" + }, + { + "id": "nested_clean_struct_depth4_dict_split_f0", + "description": "Depth 4 dict structs with clean masked leaf in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "0000028a6cad7c64b3b4d11ebf903cabef8bea293e678ed1b1d7ccbffba98ffa5a599d" + }, + { + "id": "nested_hidden_list_list_small_dict_rb_f0", + "description": "Dictionary of list_list (small) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEMEAAAALQAAAAIAAgAAAAEAAgAAAAEAAAAkP///wgAAAAAAAABAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAIABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_list_list_small_dict_array_f0", + "description": "hash_array: dictionary of list_list (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAAMEAAAALQAAAAIAAgAAAAEAAgAAAAEAAAAkP///wgAAAAAAAABAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAIABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_list_list_small_dict_split_f0", + "description": "Dictionary of list_list (small) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_list_list_large_dict_rb_f0", + "description": "Dictionary of list_list (large) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEVEAAAALQAAAAIAAgAAAAEAAgAAAAEAAAAkP///wgAAAAAAAABAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAIABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_list_list_large_dict_array_f0", + "description": "hash_array: dictionary of list_list (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAAVEAAAALQAAAAIAAgAAAAEAAgAAAAEAAAAkP///wgAAAAAAAABAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAARVcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAUAAABhcnJheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAIABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "000002fb9a473f30e945222a4998331da8b14ca935e9f499ccf8a241d664a0b958e921" + }, + { + "id": "nested_hidden_list_list_large_dict_split_f0", + "description": "Dictionary of list_list (large) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000221105b8b05531348a45cf3152a300a02ad243d2471e5bca16bdf686d106f45ee" + }, + { + "id": "nested_hidden_depth3_small_dict_rb_f0", + "description": "Dictionary of depth3 (small) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEMEAAAAOAAAAAIAAgAAAAEAAgAAAAEAAAAcP///wgAAAAAAAABAQAAAAgAAACw////4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAD/////OAEAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAACAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAQAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth3_small_dict_array_f0", + "description": "hash_array: dictionary of depth3 (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAAMEAAAAOAAAAAIAAgAAAAEAAgAAAAEAAAAcP///wgAAAAAAAABAQAAAAgAAACw////4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABQAAAGFycmF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAAAAAgAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABcAAAAEAAAAAMAAAAAAAAAAAAAAAQAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAABAAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAAEAAAAAAAAACAAQAAAAAAAAEAAAAAAAAAwAEAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth3_small_dict_split_f0", + "description": "Dictionary of depth3 (small) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEMEAAAAOAAAAAIAAgAAAAEAAgAAAAEAAAAcP///wgAAAAAAAABAQAAAAgAAACw////4P///xgAAAAMAAAAAAABDJgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABDFwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAD/////OAEAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAACAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAABAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAEAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAQAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth3_large_dict_rb_f0", + "description": "Dictionary of depth3 (large) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEVEAAAAOAAAAAIAAgAAAAEAAgAAAAEAAAAcP///wgAAAAAAAABAQAAAAgAAACw////4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAD/////OAEAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAACAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAIAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAgAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAwAAAAAAAAAAAAAAAQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth3_large_dict_array_f0", + "description": "hash_array: dictionary of depth3 (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002332110643082930e4b605e601ff31884b8dcc9817372464b47a24b616a16f001" + }, + { + "id": "nested_hidden_depth3_large_dict_split_f0", + "description": "Dictionary of depth3 (large) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "00000265ce5cca517e8f43ef71f166758cd9541860ec3827749fc9055def2ec813dce7" + }, + { + "id": "nested_hidden_depth4_small_dict_rb_f0", + "description": "Dictionary of depth4 (small) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_hidden_depth4_small_dict_array_f0", + "description": "hash_array: dictionary of depth4 (small) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAAMEAAAAAwBAAAIAAgAAAAEAAgAAAAEAAAAUP///wgAAAAAAAABAQAAAAgAAACQ////wP///xgAAAAMAAAAAAABDMQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEMmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEMXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAgAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAABAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAAEAAAAAAAAAAAAgAAAAAAAAEAAAAAAAAAQAIAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_depth4_small_dict_split_f0", + "description": "Dictionary of depth4 (small) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_hidden_depth4_large_dict_rb_f0", + "description": "Dictionary of depth4 (large) with hidden null descendants", + "method": "hash_record_batch", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" + }, + { + "id": "nested_hidden_depth4_large_dict_array_f0", + "description": "hash_array: dictionary of depth4 (large) with hidden null descendants", + "method": "hash_array", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAAAADwAEABAACAAQAAAAOAAAACwAAAAAAAAVEAAAAAwBAAAIAAgAAAAEAAgAAAAEAAAAUP///wgAAAAAAAABAQAAAAgAAACQ////wP///xgAAAAMAAAAAAABFcQAAAABAAAACAAAALD////g////GAAAAAwAAAAAAAEVmAAAAAEAAAAYAAAA0P///xAAFAAQAA4ADwAEAAAACAAQAAAAHAAAAAwAAAAAAAEVXAAAAAEAAAAcAAAABAAEAAQAAAAQABQAEAAAAA8ABAAAAAgAEAAAABgAAAAgAAAAAAAAAhwAAAAIAAwABAALAAgAAAAgAAAAAAAAAQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAEAAAAaXRlbQAAAAAFAAAAYXJyYXkAAAAAAAAAAAAAAAAAAAAAAAAA/////3gBAAAQAAAADAAYABYAFQAEAAgADAAAABwAAACAAgAAAAAAAAAAAAAAAgQACAAKAAAABAAIAAAAEAAAAAAACgAYAAwACAAEAAoAAABsAAAAEAAAAAMAAAAAAAAAAAAAAAUAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAIAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAgAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAACAAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAAIAAAAAAAAAAAAgAAAAAAAAEAAAAAAAAAQAIAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAMAAAAAAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002267da47e37eb3a91e7910f1eeef00dbccf4c9c2c7496f6875fb2a9ef9c0211a9" + }, + { + "id": "nested_hidden_depth4_large_dict_split_f0", + "description": "Dictionary of depth4 (large) with hidden null descendants in singleton batches", + "method": "hash_stream", + "include_metadata": false, + "ordered_columns": false, + "ordered_struct_fields": false, + "ipc_b64": "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", + "expected_hash": "000002372a0e5b060491779a0d6e3405bbfa0326c1484fa0b6ddfd1ccab02915e585dc" } ], "relations": [ @@ -4181,6 +5021,204 @@ "clean_large_list_rb_f0" ], "why": "items under a null list value are not visited, for List and LargeList alike" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_list_list_small_rb_f0", + "nested_hidden_list_list_small_split_f0", + "nested_clean_list_list_small_rb_f0", + "nested_hidden_list_list_large_rb_f0", + "nested_hidden_list_list_large_split_f0", + "nested_clean_list_list_large_rb_f0" + ], + "why": "hidden descendants are not elements; List/LargeList and batch splits preserve the record hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_list_list_small_array_f0", + "nested_clean_list_list_small_array_f0", + "nested_hidden_list_list_large_array_f0", + "nested_clean_list_list_large_array_f0" + ], + "why": "hidden descendants are not elements; List/LargeList preserve the array hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_depth3_small_rb_f0", + "nested_hidden_depth3_small_split_f0", + "nested_clean_depth3_small_rb_f0", + "nested_hidden_depth3_large_rb_f0", + "nested_hidden_depth3_large_split_f0", + "nested_clean_depth3_large_rb_f0" + ], + "why": "hidden descendants are not elements; List/LargeList and batch splits preserve the record hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_depth3_small_array_f0", + "nested_clean_depth3_small_array_f0", + "nested_hidden_depth3_large_array_f0", + "nested_clean_depth3_large_array_f0" + ], + "why": "hidden descendants are not elements; List/LargeList preserve the array hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_depth4_small_rb_f0", + "nested_hidden_depth4_small_split_f0", + "nested_clean_depth4_small_rb_f0", + "nested_hidden_depth4_large_rb_f0", + "nested_hidden_depth4_large_split_f0", + "nested_clean_depth4_large_rb_f0" + ], + "why": "hidden descendants are not elements; List/LargeList and batch splits preserve the record hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_depth4_small_array_f0", + "nested_clean_depth4_small_array_f0", + "nested_hidden_depth4_large_array_f0", + "nested_clean_depth4_large_array_f0" + ], + "why": "hidden descendants are not elements; List/LargeList preserve the array hash" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth2_plain_rb_f0", + "nested_hidden_struct_depth2_plain_split_f0", + "nested_hidden_struct_depth2_dict_rb_f0", + "nested_hidden_struct_depth2_dict_split_f0", + "nested_clean_struct_depth2_plain_rb_f0", + "nested_clean_struct_depth2_plain_split_f0", + "nested_clean_struct_depth2_dict_rb_f0", + "nested_clean_struct_depth2_dict_split_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding and splits preserve record hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth2_plain_array_f0", + "nested_hidden_struct_depth2_dict_array_f0", + "nested_clean_struct_depth2_plain_array_f0", + "nested_clean_struct_depth2_dict_array_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding preserves array hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth3_plain_rb_f0", + "nested_hidden_struct_depth3_plain_split_f0", + "nested_hidden_struct_depth3_dict_rb_f0", + "nested_hidden_struct_depth3_dict_split_f0", + "nested_clean_struct_depth3_plain_rb_f0", + "nested_clean_struct_depth3_plain_split_f0", + "nested_clean_struct_depth3_dict_rb_f0", + "nested_clean_struct_depth3_dict_split_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding and splits preserve record hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth3_plain_array_f0", + "nested_hidden_struct_depth3_dict_array_f0", + "nested_clean_struct_depth3_plain_array_f0", + "nested_clean_struct_depth3_dict_array_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding preserves array hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth4_plain_rb_f0", + "nested_hidden_struct_depth4_plain_split_f0", + "nested_hidden_struct_depth4_dict_rb_f0", + "nested_hidden_struct_depth4_dict_split_f0", + "nested_clean_struct_depth4_plain_rb_f0", + "nested_clean_struct_depth4_plain_split_f0", + "nested_clean_struct_depth4_dict_rb_f0", + "nested_clean_struct_depth4_dict_split_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding and splits preserve record hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_hidden_struct_depth4_plain_array_f0", + "nested_hidden_struct_depth4_dict_array_f0", + "nested_clean_struct_depth4_plain_array_f0", + "nested_clean_struct_depth4_dict_array_f0" + ], + "why": "ancestor struct nulls mask descendant nulls before dictionary decoding; encoding preserves array hashes" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_list_list_small_rb_f0", + "nested_hidden_list_list_small_dict_rb_f0", + "nested_hidden_list_list_small_dict_split_f0", + "nested_hidden_list_list_large_dict_rb_f0", + "nested_hidden_list_list_large_dict_split_f0" + ], + "why": "dictionary encoding, list widths and batch splits preserve hashes when null descendants are hidden" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_list_list_small_array_f0", + "nested_hidden_list_list_small_dict_array_f0", + "nested_hidden_list_list_large_dict_array_f0" + ], + "why": "dictionary encoding and list widths preserve array hashes when null descendants are hidden" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_depth3_small_rb_f0", + "nested_hidden_depth3_small_dict_rb_f0", + "nested_hidden_depth3_small_dict_split_f0", + "nested_hidden_depth3_large_dict_rb_f0", + "nested_hidden_depth3_large_dict_split_f0" + ], + "why": "dictionary encoding, list widths and batch splits preserve hashes when null descendants are hidden" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_depth3_small_array_f0", + "nested_hidden_depth3_small_dict_array_f0", + "nested_hidden_depth3_large_dict_array_f0" + ], + "why": "dictionary encoding and list widths preserve array hashes when null descendants are hidden" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_depth4_small_rb_f0", + "nested_hidden_depth4_small_dict_rb_f0", + "nested_hidden_depth4_small_dict_split_f0", + "nested_hidden_depth4_large_dict_rb_f0", + "nested_hidden_depth4_large_dict_split_f0" + ], + "why": "dictionary encoding, list widths and batch splits preserve hashes when null descendants are hidden" + }, + { + "kind": "equal", + "ids": [ + "nested_clean_depth4_small_array_f0", + "nested_hidden_depth4_small_dict_array_f0", + "nested_hidden_depth4_large_dict_array_f0" + ], + "why": "dictionary encoding and list widths preserve array hashes when null descendants are hidden" } ] } diff --git a/tests/test_format2.py b/tests/test_format2.py index 43c2d06..e943fae 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -971,3 +971,72 @@ def test_big_endian_hosts_are_refused(monkeypatch) -> None: ): with pytest.raises(NotImplementedError, match="little-endian"): call() + + +# ── Hidden nulls the Rust review found (starfix e079d56) ───────────────── + +_RB_OPTIONS = [ + dict(include_metadata=im, ordered_columns=oc, ordered_struct_fields=osf) + for im in (False, True) for oc in (False, True) for osf in (False, True) +] +_ARRAY_OPTIONS = [dict(ordered_columns=oc, ordered_struct_fields=osf) for oc in (False, True) for osf in (False, True)] + + +def test_nested_list_leaf_null_hidden_under_null_inner_list_any_batching() -> None: + """x: List nullable> nullable, rows [[null], null, [[8]]]. + + The leaf under the null inner list is null (hidden). hash_array, one batch and three + single-row batches succeed and equal the clean form, under every option combination. + """ + inner_t = pa.list_(pa.field("item", pa.int32(), nullable=False)) + outer_t = pa.list_(pa.field("item", inner_t, nullable=True)) + schema = pa.schema([pa.field("x", outer_t, nullable=True)]) + + def build(leaf: pa.Array, inner_offsets: list[int]) -> pa.Array: + inner = pa.ListArray.from_arrays(pa.array(inner_offsets, pa.int32()), leaf, type=inner_t, + mask=pa.array([True, False])) + return pa.ListArray.from_arrays(pa.array([0, 1, 1, 2], pa.int32()), inner, type=outer_t, + mask=pa.array([False, True, False])) + + hidden = build(pa.array([None, 8], pa.int32()), [0, 1, 2]) + clean = build(pa.array([8], pa.int32()), [0, 0, 1]) + assert hidden.values.values.null_count == 1 and clean.values.values.null_count == 0 + assert hidden.to_pylist() == clean.to_pylist() == [[None], None, [[8]]] + + for options in _ARRAY_OPTIONS: + assert f2.hash_array(hidden, **options) == f2.hash_array(clean, **options), options + for options in _RB_OPTIONS: + expected = f2.hash_record_batch(pa.record_batch([clean], schema=schema), **options) + assert f2.hash_record_batch(pa.record_batch([hidden], schema=schema), **options) == expected, options + d = f2.Digester(schema, **options) + for row in range(3): + d.update(pa.record_batch([hidden.slice(row, 1)], schema=schema)) + assert d.finalize() == expected, options + + +@pytest.mark.parametrize("child_valid", [True, False], ids=["child_valid", "child_null"]) +def test_dictionary_of_struct_leaf_null_hidden_under_null_outer_struct(child_valid: bool) -> None: + """Dictionary non-null>>, a null outer value. + + The leaf (and optionally the child struct) beneath the null outer struct is null; it is + masked by its ancestor, so the dictionary-encoded column equals the plain one. + """ + i_field = pa.field("i", pa.int32(), nullable=False) + child_t = pa.struct([i_field]) + child_field = pa.field("child", child_t, nullable=False) + outer_t = pa.struct([child_field]) + + child = pa.StructArray.from_arrays([pa.array([1, None], pa.int32())], fields=[i_field], + mask=pa.array([False, not child_valid])) + values = pa.StructArray.from_arrays([child], fields=[child_field], mask=pa.array([False, True])) + assert values.field(0).field(0).null_count == 1 + dict_arr = pa.DictionaryArray.from_arrays(pa.array([0, 1, 0, None, 1], pa.int8()), values) + plain = pa.array([{"child": {"i": 1}}, None, {"child": {"i": 1}}, None, None], outer_t) + assert dict_arr.to_pylist() == plain.to_pylist() + + for options in _ARRAY_OPTIONS: + assert f2.hash_array(dict_arr, **options) == f2.hash_array(plain, **options), options + for options in _RB_OPTIONS: + assert f2.hash_record_batch( + pa.record_batch([dict_arr], schema=pa.schema([pa.field("d", dict_arr.type)])), **options + ) == f2.hash_record_batch(pa.record_batch([plain], schema=pa.schema([pa.field("d", outer_t)])), **options), options diff --git a/tests/test_golden_parity_format2.py b/tests/test_golden_parity_format2.py index 1704b53..cbbe146 100644 --- a/tests/test_golden_parity_format2.py +++ b/tests/test_golden_parity_format2.py @@ -65,8 +65,8 @@ def _hash(vector: dict[str, Any]) -> str: # Counts of the final golden file; the file is append-only, so they can only grow. -_MIN_VECTORS = 339 -_MIN_RELATIONS = 96 +_MIN_VECTORS = 423 +_MIN_RELATIONS = 114 def test_fixture_is_well_formed() -> None: From c440e820c6f7a0175ad0aa00e05819197308d940 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 11:33:13 -0800 Subject: [PATCH 48/49] fix(format2): hash decimal32/decimal64 with nulls on pyarrow 19/20 (ITL-898) pyarrow 19.0.x and 20.0.0 have no `filter` kernel for decimal32/decimal64, so dropping nulls from those arrays (directly, or nested under list/struct/dictionary of list or struct) raised ArrowNotImplementedError on the supported minimum pyarrow. Fixed-width values are now selected on a zero-copy view of their value buffer as an unsigned integer of the same width (or FixedSizeBinary(width) for wider values), so no kernel of the logical type is used. The bytes selected are unchanged: no hash changes (all 423 golden vectors and 114 relations match with no skips). tests/test_format2_type_matrix.py runs every supported leaf type, with and without nulls, sliced, chunked, batched, dictionary-encoded and nested, through hash_array, record batch and stream hashing, against the Rust golden vectors where they exist and across the equivalent forms otherwise. CI runs the suite on pyarrow 19.0.0, 20.0.0 and the latest, and the pytest run asserts the pyarrow it imports. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 42 ++- .../specs/2026-11-11-format-2-python.md | 15 +- src/starfix/_format2.py | 22 +- tests/conftest.py | 8 + tests/test_format2_type_matrix.py | 309 ++++++++++++++++++ 5 files changed, 386 insertions(+), 10 deletions(-) create mode 100644 tests/conftest.py create mode 100644 tests/test_format2_type_matrix.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3fc6cff..5d381b4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,25 +30,51 @@ jobs: - name: Run tests run: uv run --python ${{ matrix.python-version }} pytest tests/ -v - test-min-pyarrow: - # The oldest supported pyarrow (pyproject: pyarrow>=19.0.0) on the oldest Python. + test-pyarrow: + # The oldest supported pyarrow (pyproject: pyarrow>=19.0.0) on the oldest Python, 20.0.0 + # (still lacking some kernels of later versions, e.g. decimal32/64 `filter`), and the + # latest pyarrow on PyPI. The pytest run itself asserts the pyarrow it imports + # (STARFIX_EXPECT_PYARROW) and prints it in the session header. runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: + - pyarrow: "19.0.0" + python-version: "3.10" + - pyarrow: "20.0.0" + python-version: "3.10" + - pyarrow: "latest" + python-version: "3.13" steps: - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 - name: Install uv uses: astral-sh/setup-uv@e58605a9b6da7c637471fab8847a5e5a6b8df081 # v5 - - name: Set up Python 3.10 - run: uv python install 3.10 + - name: Set up Python ${{ matrix.python-version }} + run: uv python install ${{ matrix.python-version }} - name: Install dependencies - run: uv sync --dev --python 3.10 + run: uv sync --dev --python ${{ matrix.python-version }} - - name: Run tests on pyarrow 19.0.0 + - name: Resolve the pyarrow version + id: pyarrow + run: | + if [ "${{ matrix.pyarrow }}" = latest ]; then + version=$(curl -fsSL https://pypi.org/pypi/pyarrow/json | jq -r .info.version) + else + version="${{ matrix.pyarrow }}" + fi + test -n "$version" + echo "version=$version" >> "$GITHUB_OUTPUT" + + - name: Run tests on pyarrow ${{ steps.pyarrow.outputs.version }} + env: + STARFIX_EXPECT_PYARROW: ${{ steps.pyarrow.outputs.version }} run: | - uv run --python 3.10 --with pyarrow==19.0.0 python -c "import pyarrow; assert pyarrow.__version__ == '19.0.0', pyarrow.__version__; print('pyarrow', pyarrow.__version__)" - uv run --python 3.10 --with pyarrow==19.0.0 pytest tests/ -v + uv run --python ${{ matrix.python-version }} --with "pyarrow==$STARFIX_EXPECT_PYARROW" python -c "import pyarrow; assert pyarrow.__version__ == '$STARFIX_EXPECT_PYARROW', pyarrow.__version__; print('pyarrow', pyarrow.__version__)" + uv run --python ${{ matrix.python-version }} --with "pyarrow==$STARFIX_EXPECT_PYARROW" pytest tests/ -v legacy-differential: # starfix.legacy.v0_4 must stay byte-identical to the released starfix-python 0.4.0 (PyPI). diff --git a/docs/metamorphic/specs/2026-11-11-format-2-python.md b/docs/metamorphic/specs/2026-11-11-format-2-python.md index 6f3e0ce..e0d16e8 100644 --- a/docs/metamorphic/specs/2026-11-11-format-2-python.md +++ b/docs/metamorphic/specs/2026-11-11-format-2-python.md @@ -41,6 +41,13 @@ This note records only the Python-specific decisions. rejected with `include_metadata`. - Validity bits, lengths and values follow the spec's one rule. Effective validity (own AND enclosing struct validity) is computed for every node and written for nullable nodes only. +- Fixed-width values are selected (null-dropping `filter`, dictionary `take`) on a zero-copy + view of their value buffer as an unsigned integer of the same width, or as + `FixedSizeBinary(width)`, never with a kernel of the logical type: pyarrow 19 and 20 have no + `filter` kernel for decimal32/decimal64, and kernel coverage differs by version. The other + compute calls (`filter`/`take` on booleans and integer indices or lengths, `cast` of + booleans and lengths, `and`/`or`/`invert`/`all`/`sum`, `is_valid`, `list_parent_indices`, + `dictionary_decode` and `take` of nested values) exist for every supported type from 19.0.0. ## Tests @@ -50,8 +57,14 @@ This note records only the Python-specific decisions. slicing at offsets around byte and word boundaries. - `tests/test_golden_parity_format2.py`: every vector and relation of `format2_v0.5.json` must match, with no skips and no expected failures (pyarrow >= 19, the supported minimum, - decodes every vector; CI also runs the suite on exactly pyarrow 19.0.0). The test asserts + decodes every vector; CI also runs the suite on exactly pyarrow 19.0.0 and 20.0.0). The test asserts minimum vector and relation counts, and an empty parametrization fails at collection. +- `tests/test_format2_type_matrix.py`: every supported leaf type, with and without nulls, + sliced, chunked, split into batches, dictionary-encoded (null keys, keys to null values, + nested dictionaries) and nested under list / large_list / struct / dictionary, through + `hash_array`, `hash_record_batch`/`hash_table` and the streaming digester. Rust golden values + where the golden file has the input; otherwise equality across the equivalent forms. CI runs + it on pyarrow 19.0.0, 20.0.0 and the latest, asserting the version pytest imports. - The hand-coded literals of the older test files were moved to Rust-produced format-2 values (`format1_to_format2.json`). Literals that file did not cover had their inputs recovered by recording the calls that produced them (`python_literals_format1_inputs.json`), so Rust could diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index 2245b95..deebf12 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -496,6 +496,23 @@ def _value_width(t: pa.DataType) -> int | None: return None +_UINT_OF_WIDTH = {1: pa.uint8(), 2: pa.uint16(), 4: pa.uint32(), 8: pa.uint64()} + + +def _as_raw_fixed_width(arr: pa.Array, width: int) -> pa.Array: + """The value buffer of a fixed-width array (validity dropped), viewed zero-copy as an + unsigned integer of the same width, or as FixedSizeBinary(width) for wider values. + + The bytes and their positions are unchanged, so selecting values of the view selects + the same value bytes. Compute kernels are only applied to these views: pyarrow's + kernel coverage varies by type and version (e.g. pyarrow 19/20 have no `filter` + kernel for decimal32/decimal64), but uint and FixedSizeBinary kernels exist in every + supported version. + """ + view_type = _UINT_OF_WIDTH.get(width) or pa.binary(width) + return pa.Array.from_buffers(view_type, len(arr), [None, arr.buffers()[1]], null_count=0, offset=arr.offset) + + def _is_var_length(t: pa.DataType) -> bool: return pa.types.is_string(t) or pa.types.is_large_string(t) or pa.types.is_binary(t) or pa.types.is_large_binary(t) @@ -561,6 +578,8 @@ def _hash_dictionary_values(arr: pa.DictionaryArray, bits: pa.Array | None, dige width = _value_width(t) if width == 0: return + if width is not None: + values = _as_raw_fixed_width(values, width) # see there: no type-specific kernel rows = _CHUNK if width is None else max(1, _BYTE_BUDGET // width) for start in range(0, n, rows): chunk = indices.slice(start, rows) @@ -596,9 +615,10 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: if n: digest.update(memoryview(arr.buffers()[1])[arr.offset * width:(arr.offset + n) * width]) return + raw_values = _as_raw_fixed_width(arr, width) # see there: no type-specific kernel rows = max(1, _BYTE_BUDGET // width) for start in range(0, n, rows): - chunk = arr.slice(start, rows).filter(bits.slice(start, rows)) + chunk = raw_values.slice(start, rows).filter(bits.slice(start, rows)) if len(chunk): raw = memoryview(chunk.buffers()[1]) digest.update(raw[chunk.offset * width:(chunk.offset + len(chunk)) * width]) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..7c017c3 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,8 @@ +from __future__ import annotations + +import pyarrow as pa + + +def pytest_report_header() -> str: + """The pyarrow the tests actually import (CI pins several versions).""" + return f"pyarrow {pa.__version__} ({pa.__file__})" diff --git a/tests/test_format2_type_matrix.py b/tests/test_format2_type_matrix.py new file mode 100644 index 0000000..1c386bc --- /dev/null +++ b/tests/test_format2_type_matrix.py @@ -0,0 +1,309 @@ +"""Every data type the format-2 spec hashes, on the installed pyarrow (ITL-898). + +The supported pyarrow range starts at 19.0.0, whose compute kernels do not cover every +type (for example ``filter`` has no decimal32/decimal64 kernel there). This matrix runs +``hash_array``, ``hash_record_batch`` and the streaming digester for every supported leaf +type, with and without nulls, contiguous, sliced at a non-zero offset, split into chunks / +batches, dictionary-encoded (null keys, valid keys to null values, nested dictionaries), +and nested under list / large_list / struct / dictionary. CI runs it on pyarrow 19.0.0 +and on the latest pyarrow. + +Expected values: + +- where the Rust-generated golden file (``tests/golden/format2_v0.5.json``) has a + ``hash_array`` vector for the same logical values, every variant must hash to it; +- otherwise no hash is invented here: every variant must hash without error and equal the + hash of the plain, contiguous, single-chunk array of the same logical values. The + dictionary-encoded variants are read through ``take`` rather than ``filter``, so a kernel + missing on one path shows up as an error or as a mismatch between the two. + +Inputs without a Rust golden vector are compared that way only; Rust vectors for them +belong in the Rust golden emitter (golden values are never produced on the Python side). + +With ``STARFIX_EXPECT_PYARROW`` set (CI), the installed pyarrow must be that version, so a +job pinned to an old pyarrow cannot silently test another one. +""" + +from __future__ import annotations + +import base64 +import io +import json +import os +from collections.abc import Callable +from functools import cache +from pathlib import Path +from typing import Any + +import pyarrow as pa +import pytest + +from starfix import ArrowDigester +from starfix._format2 import type_json + +_FIXTURE_PATH = Path(__file__).parent / "golden" / "format2_v0.5.json" + +_LEAF_TYPES: list[pa.DataType] = [ + pa.int8(), pa.int16(), pa.int32(), pa.int64(), + pa.uint8(), pa.uint16(), pa.uint32(), pa.uint64(), + pa.float16(), pa.float32(), pa.float64(), + pa.decimal32(7, 2), pa.decimal64(15, 3), pa.decimal128(30, 5), pa.decimal256(60, 10), + pa.date32(), pa.date64(), + pa.time32("s"), pa.time32("ms"), pa.time64("us"), pa.time64("ns"), + pa.timestamp("s"), pa.timestamp("ms"), pa.timestamp("us"), pa.timestamp("ns"), + pa.timestamp("us", "UTC"), pa.timestamp("ns", "America/Los_Angeles"), + pa.duration("s"), pa.duration("ms"), pa.duration("us"), pa.duration("ns"), + pa.bool_(), + pa.binary(), pa.large_binary(), pa.string(), pa.large_string(), + pa.binary(3), pa.binary(0), +] + +_N = 11 # rows of a synthetic base array; not a multiple of 8, so slices are bit-unaligned +_NULLS = (1, 4, 5, 9) + + +# --------------------------------------------------------------------------- +# Base arrays: Rust golden vectors where they exist, synthetic otherwise +# --------------------------------------------------------------------------- + +@cache +def _golden_leaf_arrays() -> dict[str, list[tuple[str, pa.Array, str]]]: + """Plain (non-dictionary, non-nested) hash_array golden inputs, by canonical type JSON.""" + with _FIXTURE_PATH.open(encoding="utf-8") as f: + vectors = json.load(f)["vectors"] + out: dict[str, list[tuple[str, pa.Array, str]]] = {} + for v in vectors: + if v["method"] != "hash_array" or v["ordered_columns"] or v["ordered_struct_fields"]: + continue + batch = next(iter(pa.ipc.open_stream(io.BytesIO(base64.b64decode(v["ipc_b64"]))))) + col = batch.column(0) + t = col.type + if pa.types.is_dictionary(t) or pa.types.is_nested(t) or isinstance(t, pa.BaseExtensionType): + continue + out.setdefault(type_json(t, 0), []).append((v["id"], col, v["expected_hash"])) + return out + + +def _validity(n: int, nulls: tuple[int, ...]) -> pa.Buffer | None: + if not nulls: + return None + bits = bytearray((n + 7) // 8) + for i in range(n): + if i not in nulls: + bits[i // 8] |= 1 << (i % 8) + return pa.py_buffer(bytes(bits)) + + +def _synthetic(t: pa.DataType, nulls: tuple[int, ...]) -> pa.Array: + """_N values of type t; null slots hold non-zero bytes too (they must not be hashed).""" + n = _N + if pa.types.is_boolean(t): + return pa.array([None if i in nulls else i % 3 == 0 for i in range(n)], t) + if pa.types.is_string(t) or pa.types.is_large_string(t): + return pa.array([None if i in nulls else "é" * (i % 4) + str(i) for i in range(n)], t) + if pa.types.is_binary(t) or pa.types.is_large_binary(t): + return pa.array([None if i in nulls else bytes(range(i % 5)) + b"\xff" for i in range(n)], t) + width = t.byte_width if pa.types.is_fixed_size_binary(t) else t.bit_width // 8 + # Small signed integers: valid for every fixed-width type (decimals within precision, + # times within a day), stored as their little-endian bytes. + data = b"".join((i * 11 - 50).to_bytes(width, "little", signed=True) if width else b"" for i in range(n)) + return pa.Array.from_buffers(t, n, [_validity(n, nulls), pa.py_buffer(data)], null_count=len(nulls)) + + +def _bases(t: pa.DataType) -> list[tuple[str, pa.Array, str | None]]: + """(label, array, Rust golden hash_array value or None) for the leaf type t.""" + bases: list[tuple[str, pa.Array, str | None]] = [] + for vid, col, expected in _golden_leaf_arrays().get(type_json(t, 0), []): + bases.append((f"golden:{vid}", col if col.type == t else col.cast(t), expected)) + bases.append(("nulls", _synthetic(t, _NULLS), None)) + bases.append(("no-nulls", _synthetic(t, ()), None)) + return bases + + +# --------------------------------------------------------------------------- +# Equivalent constructions (built without compute kernels: concat, slice, from_arrays) +# --------------------------------------------------------------------------- + +def _offset_by(a: pa.Array, k: int) -> pa.Array: + """The same values at offset min(k, len(a)) of a longer array (a dictionary array is + sliced through its keys: concatenating dictionaries would unify them).""" + if isinstance(a, pa.DictionaryArray): + return pa.DictionaryArray.from_arrays(_offset_by(a.indices, k), a.dictionary) + prefix = a.slice(0, k) + return pa.concat_arrays([prefix, a]).slice(len(prefix), len(a)) + + +def _sliced(a: pa.Array) -> pa.Array: + return _offset_by(a, len(a)) + + +def _dict_null_keys(a: pa.Array) -> pa.DictionaryArray: + """Null keys where a is null; the dictionary is a itself (its nulls are never referenced).""" + keys = pa.array([i if a[i].is_valid else None for i in range(len(a))], pa.int32()) + return pa.DictionaryArray.from_arrays(keys, a) + + +def _dict_hidden_nulls(a: pa.Array) -> pa.DictionaryArray: + """All keys valid; a null of a is a valid key pointing at a null dictionary value.""" + n = len(a) + keys = pa.array([n + i for i in range(n)], pa.int16()) + return pa.DictionaryArray.from_arrays(keys, _sliced(pa.concat_arrays([a, a])) if n else a) + + +def _dict_nested(a: pa.Array) -> pa.DictionaryArray: + """A dictionary whose dictionary is itself a (null-containing) dictionary.""" + inner = _dict_hidden_nulls(a) + keys = pa.array(list(reversed(range(len(a)))), pa.int8()) + return pa.DictionaryArray.from_arrays(keys, _reversed_keys(inner)) + + +def _reversed_keys(a: pa.DictionaryArray) -> pa.DictionaryArray: + """a in reverse row order, by reversing its keys only (no kernel on the values).""" + keys = pa.array([a.indices[i].as_py() for i in reversed(range(len(a)))], a.indices.type) + return pa.DictionaryArray.from_arrays(keys, a.dictionary) + + +def _dict_sliced(a: pa.Array) -> pa.Array: + return _sliced(_dict_hidden_nulls(a)) + + +_LEAF_VARIANTS: dict[str, Callable[[pa.Array], pa.Array]] = { + "sliced": _sliced, + "offset3": lambda a: _offset_by(a, 3), + "dict-null-keys": _dict_null_keys, + "dict-hidden-nulls": _dict_hidden_nulls, + "dict-nested": _dict_nested, + "dict-sliced": _dict_sliced, +} + + +def _list_mask(rows: int) -> pa.Array: + return pa.array([i == 1 for i in range(rows)], pa.bool_()) + + +def _cuts(n: int) -> list[int]: + return sorted({0, n // 3, (2 * n) // 3, n}) + + +def _as_list(large: bool) -> Callable[[pa.Array], pa.Array]: + """Lists over all items; list 1 is null and hides a non-empty item range.""" + cls, idx = (pa.LargeListArray, pa.int64()) if large else (pa.ListArray, pa.int32()) + + def wrap(child: pa.Array) -> pa.Array: + cuts = _cuts(len(child)) + return cls.from_arrays(pa.array(cuts, idx), child, mask=_list_mask(len(cuts) - 1)) + return wrap + + +def _as_struct(child: pa.Array) -> pa.Array: + """struct; struct row 0 is null and hides its child values.""" + n = len(child) + other = pa.array(list(range(n)), pa.int8()) + return pa.StructArray.from_arrays([child, other], names=["a", "b"], mask=pa.array([i == 0 for i in range(n)], pa.bool_())) + + +def _as_dict_of(wrap: Callable[[pa.Array], pa.Array]) -> Callable[[pa.Array], pa.Array]: + """A dictionary whose values are wrap(child), keys in reverse order plus a null key.""" + def outer(child: pa.Array) -> pa.Array: + values = wrap(child) + m = len(values) + keys = pa.array([None, *reversed(range(m))], pa.int32()) + return pa.DictionaryArray.from_arrays(keys, values) + return outer + + +def _plain_dict_of(wrap: Callable[[pa.Array], pa.Array]) -> Callable[[pa.Array], pa.Array]: + """The decoded form of _as_dict_of(wrap)(child), built without a dictionary: the same + rows concatenated from slices (no compute kernel).""" + def outer(child: pa.Array) -> pa.Array: + values = wrap(child) + m = len(values) + rows = [pa.nulls(1, values.type), *(values.slice(i, 1) for i in reversed(range(m)))] + return pa.concat_arrays(rows) + return outer + + +_WRAPPERS: dict[str, tuple[Callable[[pa.Array], pa.Array], Callable[[pa.Array], pa.Array]]] = { + # name: (wrapper, reference wrapper of the plain child) + "leaf": (lambda a: a, lambda a: a), + "list": (_as_list(False), _as_list(False)), + "large_list": (_as_list(True), _as_list(True)), + "struct": (_as_struct, _as_struct), + "list": (lambda a: _as_list(False)(_as_struct(a)),) * 2, + "struct": (lambda a: _as_struct(_as_list(True)(a)),) * 2, + "dict": (_as_dict_of(_as_struct), _plain_dict_of(_as_struct)), + "dict": (_as_dict_of(_as_list(False)), _plain_dict_of(_as_list(False))), + "dict>": ( + _as_dict_of(lambda a: _as_list(True)(_as_struct(a))), + _plain_dict_of(lambda a: _as_list(True)(_as_struct(a))), + ), +} + + +# --------------------------------------------------------------------------- +# Hashing through every entry point +# --------------------------------------------------------------------------- + +def _hashes(arr: pa.Array | pa.ChunkedArray) -> dict[str, str]: + """hash_array, the record hash (one batch, or a table of the chunks) and the record hash + streamed through the digester in two batches per chunk.""" + schema = pa.schema([pa.field("c", arr.type, nullable=True)]) + if isinstance(arr, pa.ChunkedArray): + chunks = arr.chunks + records = ArrowDigester.hash_table(pa.Table.from_arrays([arr], schema=schema)) + else: + chunks = [arr] + records = ArrowDigester.hash_record_batch(pa.record_batch([arr], schema=schema)) + digester = ArrowDigester(schema) + for chunk in chunks: + k = len(chunk) // 2 # the second batch starts at a non-zero offset + for part in (chunk.slice(0, k), chunk.slice(k)): + digester.update(pa.record_batch([part], schema=schema)) + return { + "hash_array": ArrowDigester.hash_array(arr).hex(), + "records": records.hex(), + "stream": digester.finalize().hex(), + } + + +def _cases() -> list[Any]: + cases = [] + for t in _LEAF_TYPES: + for label, base, expected in _bases(t): + for wrapper in _WRAPPERS: + cases.append(pytest.param(t, base, expected if wrapper == "leaf" else None, wrapper, + id=f"{t}-{label}-{wrapper}")) + return cases + + +def test_installed_pyarrow_is_the_expected_one() -> None: + expected = os.environ.get("STARFIX_EXPECT_PYARROW") + if expected: + assert pa.__version__ == expected + + +@pytest.mark.parametrize(("leaf_type", "base", "golden", "wrapper"), _cases()) +def test_type_matrix(leaf_type: pa.DataType, base: pa.Array, golden: str | None, wrapper: str) -> None: + wrap, reference_wrap = _WRAPPERS[wrapper] + reference = reference_wrap(base) + expected = _hashes(reference) + assert expected["stream"] == expected["records"], "streamed batches differ from one batch" + if golden is not None: + assert expected["hash_array"] == golden, "plain array differs from the Rust golden vector" + + variants: dict[str, pa.Array | pa.ChunkedArray] = {"plain": wrap(base)} + for name, make in _LEAF_VARIANTS.items(): + variants[f"child-{name}"] = wrap(make(base)) + wrapped = wrap(base) + variants["outer-sliced"] = _sliced(wrapped) + variants["outer-offset3"] = _offset_by(wrapped, 3) + k = len(wrapped) // 3 + variants["chunked"] = pa.chunked_array([wrapped.slice(0, k), wrapped.slice(k)], type=wrapped.type) + variants["chunked-sliced"] = pa.chunked_array( + [_sliced(wrapped).slice(0, k), _offset_by(wrapped, 5).slice(k)], type=wrapped.type + ) + + for name, arr in variants.items(): + got = _hashes(arr) + for entry_point, value in got.items(): + assert value == expected[entry_point], f"{leaf_type} {wrapper} {name}: {entry_point} differs" From 940887cec94aa13de70105f087e497dc6ac27a24 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Wed, 11 Nov 2026 11:36:44 -0800 Subject: [PATCH 49/49] refactor(format2): field metadata errors get their path from the caller; README memory note (ITL-898) _field_metadata no longer receives the node path only to build error messages: it raises _AmbiguousMetadata (a ValueError) and phase2_json re-raises it as ValueError prefixed with the field path ("Field 's/c': Duplicate metadata key 'a' on the field: ..."). Tests assert the full messages, including the path. README: auxiliary memory is not bounded (validity, lengths and list parent indices per visited element; dictionary-of-struct/list values are materialized with take); only leaf payload feeding is chunked. Also the cheap ruff findings in _format2.py (sorted __slots__, unquoted annotation, itertools.pairwise). No hash changes. Co-Authored-By: Claude Opus 5.5 --- README.md | 7 +++++-- src/starfix/_format2.py | 28 +++++++++++++++++++--------- tests/test_format2.py | 11 ++++++++--- 3 files changed, 32 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 6f3e539..ca17b31 100644 --- a/README.md +++ b/README.md @@ -141,8 +141,11 @@ crate has the same restriction. ## Performance -Hashing takes time linear in the data size and works on Arrow buffers (bounded temporary -memory). Fixed-width, Boolean and list columns hash at tens of millions of rows per second. +Hashing takes time linear in the data size and works on Arrow buffers. Leaf values are fed to +the digest in bounded chunks without copying the payload, but auxiliary memory is not bounded: +it grows with the number of visited elements and list items (validity bitmaps, list lengths, +list parent indices), and the values of a dictionary of struct or list values are materialized +(decoded with `take`) before they are traversed. Fixed-width, Boolean and list columns hash at tens of millions of rows per second. String and binary columns hash at about 3 to 5 million rows per second, because each value is visited in Python. Each `update` call also costs a few microseconds per column, to check the batch's schema. starfix-python is a pure-Python implementation; the Rust crate is faster on diff --git a/src/starfix/_format2.py b/src/starfix/_format2.py index deebf12..e3599be 100644 --- a/src/starfix/_format2.py +++ b/src/starfix/_format2.py @@ -7,6 +7,7 @@ from __future__ import annotations import hashlib +import itertools import json import struct import sys @@ -293,18 +294,24 @@ def _exported_extension_metadata(t: pa.DataType) -> bytes: return dict(_exported_metadata_pairs(pa.field("x", t))).get(b"ARROW:extension:metadata", b"") +class _AmbiguousMetadata(ValueError): + """Section 7: metadata that cannot be hashed unambiguously with include_metadata.""" + + def _unique_metadata(pairs: list[tuple[bytes, bytes]], where: str) -> dict[str, str]: """Decode metadata pairs; Section 7: a duplicate key is ambiguous and rejected.""" out: dict[str, str] = {} for key, value in pairs: k = key.decode("utf-8") if k in out: - raise ValueError(f"Duplicate metadata key {k!r} on {where}: ambiguous, rejected with include_metadata") + raise _AmbiguousMetadata( + f"Duplicate metadata key {k!r} on {where}: ambiguous, rejected with include_metadata" + ) out[k] = value.decode("utf-8") return out -def _field_metadata(field: pa.Field, path: str) -> dict[str, str]: +def _field_metadata(field: pa.Field) -> dict[str, str]: """The field's metadata as stored (Section 2.3), duplicates rejected (Section 7).""" explicit = _decode(field.metadata) # pyarrow's dict view (duplicates collapsed) t = field.type @@ -313,11 +320,11 @@ def _field_metadata(field: pa.Field, path: str) -> dict[str, str]: derived = _extension_metadata(t) for key, value in derived.items(): if key in explicit and explicit[key] != value: - raise ValueError( - f"Field {path!r} carries {key}={explicit[key]!r}, conflicting with its extension type " + raise _AmbiguousMetadata( + f"{key}={explicit[key]!r} is set, conflicting with its extension type " f"({value!r}): ambiguous, rejected with include_metadata" ) - meta = _unique_metadata(_exported_metadata_pairs(field), f"field {path!r}") + meta = _unique_metadata(_exported_metadata_pairs(field), "the field") for key, value in derived.items(): meta.setdefault(key, value) # Section 2.3: an absent ARROW:extension:metadata is hashed as "" (absent == empty). @@ -330,7 +337,10 @@ def phase2_json(schema: pa.Schema) -> str | None: """Section 2.3: metadata keyed by node path; None when there is none.""" fields = {} for path, field in schema_nodes(schema): - meta = _field_metadata(field, path) + try: + meta = _field_metadata(field) + except _AmbiguousMetadata as exc: + raise ValueError(f"Field {path!r}: {exc}") from exc if meta: fields[path] = meta doc: dict[str, Any] = {} @@ -408,7 +418,7 @@ def restore(self, state: tuple[int, int, int | None]) -> None: class _Entry: - __slots__ = ("validity", "lengths", "values", "kind") + __slots__ = ("kind", "lengths", "validity", "values") def __init__(self, field: pa.Field) -> None: t = _logical(field.type) @@ -543,7 +553,7 @@ def flush(self) -> None: self.parts, self.pending = [], 0 -def _feed_var_length(feeder: "_VarLengthFeeder", data: memoryview, pairs) -> None: +def _feed_var_length(feeder: _VarLengthFeeder, data: memoryview, pairs) -> None: pack = _U64.pack for a, b in pairs: size = b - a @@ -632,7 +642,7 @@ def _hash_values(arr: pa.Array, bits: pa.Array | None, digest) -> None: for chunk_start in range(0, n, _CHUNK): chunk_end = min(chunk_start + _CHUNK, n) offs = offsets[arr.offset + chunk_start:arr.offset + chunk_end + 1].tolist() - pairs = zip(offs, offs[1:], strict=False) # consecutive offsets + pairs = itertools.pairwise(offs) # consecutive offsets if bits is not None: flags = bits.slice(chunk_start, chunk_end - chunk_start).to_pylist() pairs = (pair for pair, ok in zip(pairs, flags, strict=True) if ok) diff --git a/tests/test_format2.py b/tests/test_format2.py index e943fae..891a41e 100644 --- a/tests/test_format2.py +++ b/tests/test_format2.py @@ -876,15 +876,20 @@ def test_duplicate_metadata_keys_rejected_with_include_metadata(where) -> None: else: schema = pa.schema([pa.field("s", pa.struct([pa.field("c", pa.int8(), metadata=dup)]))]) f2.hash_schema(schema) # metadata not hashed: accepted - with pytest.raises(ValueError, match="Duplicate metadata key 'a'"): + message = { + "field": "^Field 'x': Duplicate metadata key 'a' on the field", + "schema": "^Duplicate metadata key 'a' on the schema", + "struct_child": "^Field 's/c': Duplicate metadata key 'a' on the field", + }[where] + with pytest.raises(ValueError, match=message): f2.hash_schema(schema, include_metadata=True) - with pytest.raises(ValueError, match="Duplicate metadata key"): + with pytest.raises(ValueError, match=message): f2.Digester(schema, include_metadata=True) def test_explicit_extension_keys_conflicting_with_the_type_rejected(point_type) -> None: conflicting = pa.schema([pa.field("p", point_type("km"), metadata={"ARROW:extension:name": "other"})]) - with pytest.raises(ValueError, match="conflicting with its extension type"): + with pytest.raises(ValueError, match="^Field 'p': ARROW:extension:name='other' is set, conflicting with its extension type"): f2.hash_schema(conflicting, include_metadata=True) agreeing = pa.schema([pa.field("p", point_type("km"), metadata={"ARROW:extension:name": "starfix.test.point"})]) assert f2.hash_schema(agreeing, include_metadata=True) == f2.hash_schema(