diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c69e51a..5d381b4 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 @@ -30,6 +30,70 @@ jobs: - name: Run tests run: uv run --python ${{ matrix.python-version }} pytest tests/ -v + 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 ${{ matrix.python-version }} + run: uv python install ${{ matrix.python-version }} + + - name: Install dependencies + run: uv sync --dev --python ${{ matrix.python-version }} + + - 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 ${{ 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). + 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: @@ -107,3 +171,32 @@ jobs: echo "Copy the updated fixture from the starfix repo and commit it." exit 1 fi + + - 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. + # 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 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" + fi + done + env: + GH_TOKEN: ${{ steps.app-token.outputs.token }} + + - name: Fail on format-2 fixture drift + run: | + 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)" + 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/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..c237135 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,69 @@ +# Changelog + +## 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 +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 + +- **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. +- Extension types are hashed as their storage type; with `include_metadata`, their + `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) + +- **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` + 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 7c098c2..ca17b31 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,23 @@ 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** — reordering columns does not change the hash -- **Batch-split independent** — splitting data across batches does not change the hash -- **Cross-language compatible** — identical hashes to the Rust implementation +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. 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. +- **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 @@ -14,6 +26,8 @@ Produces stable SHA-256 hashes of Arrow tables, record batches, and arrays that pip install starfix ``` +Requires Python >= 3.10 and pyarrow >= 19. + ## Usage ```python @@ -27,39 +41,171 @@ 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() + +# 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())) ``` -## Metadata hashing +## Options -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: +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`). -```python -# One-shot -digest = ArrowDigester.hash_table(table, include_metadata=True) +| 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 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. | -# Streaming -digester = ArrowDigester(schema, include_metadata=True) -for batch in batches: - digester.update(batch) -digest = digester.finalize() +```python +# 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 `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. +- 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 (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): 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 + +`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; +- 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`. + +## 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. 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 +string-heavy data. + +## 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 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 +``` -A schema with no metadata produces the same hash regardless of `include_metadata` -(empty-metadata invariant). +`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 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): + +- 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/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..e0d16e8 --- /dev/null +++ b/docs/metamorphic/specs/2026-11-11-format-2-python.md @@ -0,0 +1,76 @@ +# 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, 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 + 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 + (`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. +- 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 + +- `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` + 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 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 + 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/pyproject.toml b/pyproject.toml index d34f988..fdb0323 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"] @@ -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/scripts/legacy_differential.py b/scripts/legacy_differential.py new file mode 100644 index 0000000..971c3ac --- /dev/null +++ b/scripts/legacy_differential.py @@ -0,0 +1,225 @@ +"""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 + # 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): + 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/_format2.py b/src/starfix/_format2.py new file mode 100644 index 0000000..e3599be --- /dev/null +++ b/src/starfix/_format2.py @@ -0,0 +1,853 @@ +"""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 + +import hashlib +import itertools +import json +import struct +import sys +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 + +# 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" + +# 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(" int: + return (ORDERED_COLUMNS if ordered_columns else 0) | (ORDERED_STRUCT_FIELDS if ordered_struct_fields else 0) + + +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: + """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 _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): + # 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): + # 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). + + 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 {} + 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_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: ``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): + _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: + """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"") + + +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 _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) -> 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 + derived = _extension_metadata(t) + for key, value in derived.items(): + if key in explicit and explicit[key] != value: + 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), "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). + if "ARROW:extension:name" in meta: + meta.setdefault("ARROW:extension:metadata", "") + 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): + 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] = {} + if fields: + doc["fields"] = fields + schema_meta = _unique_metadata(_exported_metadata_pairs(schema), "the schema") + 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(KIND_SCHEMA, 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: + # 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: + 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.""" + 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:] # appends only grow the buffer or rewrite its last byte + if last is not None: + self._bytes[byte_len - 1] = last + self._len = bit_len + + +class _Entry: + __slots__ = ("kind", "lengths", "validity", "values") + + 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 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 feed(self, digest) -> None: + """Section 3.2: [validity][lengths][values], fed without copying the bits.""" + if self.validity is not None: + self.validity.feed(digest) + if self.lengths is not None: + digest.update(self.lengths.digest()) + if self.values is not None: + digest.update(self.values.digest()) + + +def _resolve(arr: pa.Array) -> pa.Array: + """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): + 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): + 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 + + +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 + + +_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) + + +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 + 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) + 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): + for start in range(0, n, _CHUNK): + 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 == 0: + return # FixedSizeBinary(0): no value bytes (validity is recorded by _visit) + if width is not None: + if bits is 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 = 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]) + return + if _is_var_length(t): + if n == 0: + return + 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[arr.offset + chunk_start:arr.offset + chunk_end + 1].tolist() + 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) + _feed_var_length(feeder, data, pairs) + feeder.flush() + return + 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, + 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). 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] + 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). + 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) if select is None else (pc.sum(select).as_py() or 0)) + else: + 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, select) + return + + 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) + 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, present, 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} + + +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) + + +# --------------------------------------------------------------------------- +# 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: + _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 + self._schema_digest = schema_digest(schema, include_metadata, self._flags) + self._key = schema_key(schema, include_metadata, self._flags) + nodes = schema_nodes(schema) + _check_data_supported(nodes) + self._entries = _new_entries(nodes) + 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: + raise ValueError(_SCHEMA_MISMATCH) + # 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: + 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() + + +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_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)) + + +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) + 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 "", always nullable. + + 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) + nodes = _walk([("", root)]) + _check_data_supported(nodes) + entries = _new_entries(nodes) + # 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))) + _feed_entries(entries, final) + return VERSION_BYTES + final.digest() diff --git a/src/starfix/arrow_digester.py b/src/starfix/arrow_digester.py index 5110c17..415ab49 100644 --- a/src/starfix/arrow_digester.py +++ b/src/starfix/arrow_digester.py @@ -1,912 +1,138 @@ """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: ... - - -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 +from starfix import _format2 - 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.""" +if TYPE_CHECKING: 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. + def __init__( + self, + schema: pa.Schema, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> None: + """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). + 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. + + Hashes taken with different order options never coincide. """ - 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())) + self._digester = _format2.Digester( + schema, + include_metadata=include_metadata, + ordered_columns=ordered_columns, + ordered_struct_fields=ordered_struct_fields, + ) 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, - ) + """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).""" - 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(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) + def hash_schema( + schema: pa.Schema, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> bytes: + """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(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() + def hash_record_batch( + record_batch: pa.RecordBatch, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> bytes: + """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, + ) @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() + def hash_table( + table: pa.Table, + *, + include_metadata: bool = False, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> bytes: + """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, + ) @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. + def hash_array( + array: pa.Array, + *, + ordered_columns: bool = False, + ordered_struct_fields: bool = False, + ) -> bytes: + """Hash a single array or ChunkedArray (equal to its chunks combined). + + 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. """ - 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, + 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/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..e0df959 --- /dev/null +++ b/src/starfix/legacy/v0_4.py @@ -0,0 +1,930 @@ +# ===================================================================================== +# 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 EXCEPT ONE performance-only line, marked +# "LEGACY PATCH": in _hash_fixed_size_data, `raw = data_buf.to_pybytes()` became +# `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". +# +# 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() if data_buf is None else memoryview(data_buf) # LEGACY PATCH (see header) + 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/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/golden/README.md b/tests/golden/README.md new file mode 100644 index 0000000..6460044 --- /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` | 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/golden/format1_to_format2.json b/tests/golden/format1_to_format2.json new file mode 100644 index 0000000..7ae5934 --- /dev/null +++ b/tests/golden/format1_to_format2.json @@ -0,0 +1,1555 @@ +{ + "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": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3", + "format2_vector": "no_metadata_include_false" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "schema_level_metadata", + "format1_hash": "00000185971192458c11308853f8647b688810b7efd3afb5e1a3811ebf1c449969b18d", + "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": "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": "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": "00000269fa67810dd0ffea5b7f22d32ba797bf4e1213d935d782046442334f9186ef9b", + "format2_vector": "schema_and_field_metadata" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "unicode_metadata", + "format1_hash": "00000155498f11ff0803127d60f8c6daa18b8c8dbb3411d2962e08ee0dfbce7054706b", + "format2_hash": "0000027a667866945ffee424dec01ad00c7d6661329182b0991c28226f22e7ecf4c641", + "format2_vector": "unicode_metadata" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "key_reorder_canonical", + "format1_hash": "0000016a68d96d5c89d9b5de01d104c7ad1f51f9956bd8758691c9241ecacf32c701bf", + "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": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed", + "format2_vector": "key_reorder_shuffled" + }, + { + "source": "tests/golden/include_metadata_v0.3.json", + "id": "empty_metadata_invariant", + "format1_hash": "00000131f10e388ffb366939a37d877568320d681eb2c6e81793259274afd3b10ae38d", + "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": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd", + "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": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd", + "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": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864", + "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": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864", + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea", + "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": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e", + "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": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e", + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9", + "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": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33", + "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": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33", + "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": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777", + "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": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777", + "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": "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27", + "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": "0000028ff3df6a3c3249959db37063755324949df6b294b624131d395269f8d3f64528", + "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": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f", + "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": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796", + "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": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796", + "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": "00000250cb2fc7aaf1c32b7d195c543876c8333c0b15f85caf96b4ce43fe587f444d07", + "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": "000002d1c4267472a7b0df719325b9fea373625afa4c828dce1f56a106e14c09987068", + "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": "0000026630aa8326714cbd9cb8e539a9dc2aa9e966bc61cc43f4da30bb51a855c9cd06", + "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": "000002517a1bd090b9ddec71fb8656b6a5064b97e18ad760c14116ef1799cba4eb36fe", + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f", + "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": "000002cf2404bcc0218a195c4a262cc022bf7c77f4806d41e8c4431e3cfd5cc97ee9a4", + "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": "0000022a14ec9cc1066b92f435f414832d0948a52d72dccfb2c4f35eea219da00c7c96", + "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": "0000021fae7750bc9e056286f3446edae67e8ad93c540edbd3290f6c4bf2d63882390d", + "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": "000002880943a6023e397289e89fb31d609807d68a56568133935693da686c53199eea", + "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": "00000276aeb72c9e3f36df94c629d354a68c357bf5306d86e2be7244de6c0a9f233c20", + "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": "00000281e68cbc71271d8bd4bd49ca0b4fc06ed9ee14d0a9b89e94c7b4d7f57a765fc2", + "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": "0000026377ee1c5f0cf836051940feae161f2a199af2b37aa1fd0fe74c8c5debca90c5", + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067", + "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": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456", + "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": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456", + "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": "0000026c3a344f7fcda6c51ee4bd97ecf4c3e6dc702ec2045323c52ad911534cff00ed", + "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": "000002c467967f693c01b3bbb0f924e190d94884dc5db908a61185960c78e69843bebb", + "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": "000002dee12b05ca7ae8846ba2ee678edf4c2bebedea94bc4835a0530a76b7107cb2e2", + "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": "00000279d7cb82ab7366f2452bfd63a48e7750a32b174153e5c13fb80f2336adb2dbff", + "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": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92", + "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": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92", + "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": "00000266430e24680d87a4279fd531bb8c02340f72b05682da212f5d525b0f7d3e147d", + "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": "00000219e467d0280ccc83ad4c67e063997344cedd781f6cb4e449d03d713c989aa12b", + "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": "000002360ce1cbd543917fa1444b88470e60303ba415e829d29754bdc20d1f9be2c4a0", + "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": "0000022fe3f8d8fcba7e393f3c5808894db2f930a8bd8388e9d04b3763d369cc6eae88", + "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": "000002fcc4a6000e54c88f15ce378526d2aaeb6257909dcda76889744ad3fe18e3d5e1", + "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": "0000024f30d74a4ecc5859895de78ae95fae3802012a4d6f1bd287c18dda362d11d54a", + "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": "000002ae91ac257762841aed12f8986a96ea10072d2e4573bb2cda0862d002bbe4e3b4", + "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": "000002013cdd44a14ee692b7d98d8909d5e2230a0b0375f03e2f1d64c51518567393d5", + "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": "000002e8fa19e1f3e0f9ab96f3c77cfbe1b8a2eb42f0e41af3f9b61c76fd894636e82a", + "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": "0000028103d67a1b84d9305488727baf6a5f9662278a49cfccda2c441a9f6fca337cfe", + "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": "0000021ce5d36566850439ffb338c1e4c5aae756e8250ffe681803328c75951f55914a", + "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": "000002b4753897cdef0036ac4ae0397dd4de049e0644effb0acad9bd5c57ea606f7c7e", + "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": "000002722f2dbfd37702f6d2b38b5ee134eaa4d8d0c473f26a6fa9c9accdf5ff738bf0", + "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": "000002ac3e91bd728f7101209ba7cda9f99e9ba4bdbdae19a7ec52a945377246041842", + "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": "000002bdf9bea09e68f1e94c2903c635806055578a8e959f674ebb5fcc91d2950299cf", + "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": "0000029d53ed8a06173c17c1d5c3ac7c05e664906f4c38705b6d42531535b85516196a", + "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": "000002fe84148cb5b19a35c8d7f0f74fb999dfbe73b39eb9d175acc56a68496bcae3c9", + "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": "000002cd80a7aa2d0d65df7a9b49fd4553e7810379df991305ec129049e3706dd27490", + "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": "000002603514e8bc5a8e579d7fdb7e06bb05a7eaebaf38f91f474e2844dd34cdaa0747", + "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": "00000202c0525336a81e428a90c726eb51a62bd8753aa055f0aad2df8b472e42f2b5dd", + "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": "000002fedf19b8af467ee7acec8f738218feab196b07826821198b909bc82537e8f924", + "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": "000002fa87e7ebb1972366c69da6e6656c5ae10c89906a9110bfb2764346f0b49c5228", + "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": "000002e83f805720c95bd9f74201cea503c4a2b489dc84dc04dc1826aa81331cc774d1", + "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": "000002d4b6344eb6e36da5864993f7884283fd9d5f81e2b5e2bf2ef7942beb98d41e9b", + "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": "000002c3d16ff0a20bd9e420a4a851018bb2e445ab4ae8973902b331a6312741ed7559", + "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": "000002a0bc2bf04f37e9838f02f8f948619c298300b9a8c0ed90a2d4aaa80627fa6209", + "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": "000002f5a5aaa5002a1db4a752adf89927683d31f2896bd795cbb4385434051f5cc1c7", + "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": "000002a8e4e8a46be0e1eee3876ae9f8996463c26f2020f36bd02dd5d15d063b9517cc", + "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": "00000257560dd4115945bb73829a8b42eb50c91441221b153e8e8af9cc741a98a1a9d2", + "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": "000002e37ba68db00a13fda1269115c93112e82f47e0001954736e0dbac6ec0478529a", + "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": "000002deafca82c59e247745cff3aa1be6df4f079b034bb74688a2941d8bd9a8eb43d1", + "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": "000002da4cfb6ead4c47fb7f40c73df8ba0ccf616d931461f48dadfb5a018772576078", + "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": "0000021140c59d69e5aff07c4c9fb5acede1eb2f93529ed40b42ea04d1fd873764be0d", + "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": "00000244ddd18aa817bdda2931252ba87319aaebce9b5bd9ac1400f3bff958e6bfa92c", + "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": "000002d9e806587afcff2f7bf1e5bad572696f5fbfdb9ebf18813466549327b8d51211", + "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": "000002e8eb312e375f9c65f3b3d0d029b19f0eb41821c5efeca2a59c9e17a287a0d83b", + "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": "00000227ac504a2ceb17222240736fabb8a9bc473adf914921def7d552f85d324326f7", + "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": "0000025307a5443dbf29dde69b92ea0a4cb4dd4edec402ab3f21f3757ca21ffb6f0ef4", + "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": "00000265fcc9e37a235725f68d94bd5a384603416c4893ca8c7e68f1b24cabb2a10f99", + "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": "000002fb41d9fcaf8a1e416d559fa0b0c066e578dbb3ab5056732559faceba7c12d205", + "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": "000002f72c04377c44ba38abf0fc2b04cad73a66d97c290985810b594759b39e0e0751", + "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": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66", + "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": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66", + "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": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8", + "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": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8", + "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": "000002ae4524ad2af645eab4f9c6d0909c9361fd5b25f4381b6ef31aaf1edfcedf9ddf", + "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": "000002f66721c03015a7ef24bb7d084e984c2e4e7e1246e9573dcbf0ef0819f3f0abd8", + "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": "000002e72a6e74a24550cd50f142e754901f4bd7aa2fbaf801ae1d8c1c7dbb49d6b83e", + "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": "0000025e79da0f495b82e17ec4f2a2fdf191a6f92357073a0232f0f55ad7014b1401f6", + "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": "000002e30b27b07b6518a7f089c4564e0bbdf34f6e566e83579764e8fc4873156b34c3", + "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": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a", + "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": "000002f99bf8ec8a139a00a36a06178b72829b3cd4b5200576b48c8a8f7dc1ef5f00f3", + "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": "00000277f78b5887bf2face0b85767b991be1ce3da47b1cc4d1cdc334829087f4f1a8f", + "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": "00000253583e73e2411cdfe9480e8ce880911d8b4d8fd64a190df43e5bcfe05dc31a0f", + "format2_vector": "meta_fsl_element_schema_f0_im1", + "format1_defects": [] + }, + { + "source": "tests/arrow_digester.rs", + "id": "binary_array_hashing", + "format1_hash": "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57", + "format2_hash": "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" + }, + { + "source": "tests/arrow_digester.rs", + "id": "boolean_array_hashing", + "format1_hash": "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b", + "format2_hash": "0000024c5223c9cdc2fe10fb4362890cfc763e1bea4829a30fa6bfedc7bacad05f783a" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing", + "format1_hash": "0000014f015bd5c4b6ce6e939a8c890333f3e110c2c28ef8014aafd352f8373791e547", + "format2_hash": "0000021480fe62da952e0f819540738817488f0da864a59e70604f88f00f6daec3a7fb" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing", + "format1_hash": "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa", + "format2_hash": "000002ac73fa834511e4de143e7f5da1f2b6bef168f25a6d47f7851dd977328eaf20cc" + }, + { + "source": "tests/arrow_digester.rs", + "id": "int32_array_hashing", + "format1_hash": "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138", + "format2_hash": "00000264c8fe45cb550e25577276b2af8c1c9c125bc14b8439f5619c1f18c71d4d0078" + }, + { + "source": "tests/arrow_digester.rs", + "id": "list_array_hashing", + "format1_hash": "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c", + "format2_hash": "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" + }, + { + "source": "tests/arrow_digester.rs", + "id": "record_batch_hashing", + "format1_hash": "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0", + "format2_hash": "0000020ba4ed542e67ebc311d160ab54a11f25630a6b5fdd99e5dfc90917cb1d31e968" + }, + { + "source": "tests/arrow_digester.rs", + "id": "schema", + "format1_hash": "0000012ac1decf89ab7e337d5df56bafd330f7e9a761953c58c39d5a3a8c49f6dfd4ff", + "format2_hash": "000002951008748ed8a893f5ea7b6506d3ea8cb8be815956cbdf5ea330ae6a11f49519" + }, + { + "source": "tests/arrow_digester.rs", + "id": "string_array_hashing", + "format1_hash": "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c", + "format2_hash": "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" + }, + { + "source": "tests/arrow_digester.rs", + "id": "time32_array_hashing", + "format1_hash": "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc", + "format2_hash": "0000026708f2d0b632bf3f324716cd32c7c41dd8b9bc75d326fb5ec3f3900201f08eb7" + }, + { + "source": "tests/arrow_digester.rs", + "id": "time64_array_hashing", + "format1_hash": "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26", + "format2_hash": "0000022ddc0ab9c1cfc0fda9353d66612a504cb63d6ee509c4f56b961f33855f1a82a4" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing", + "format1_hash": "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b", + "format2_hash": "00000255a8e82e6e1862a461c70c393f105522ee7fd6f4ed889fd69d21ace4bb54622e" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing#2", + "format1_hash": "000001dc08c7b9c583edecec36bc5dee21cd2edec9f402a651014fea5f8834d16ad737", + "format2_hash": "000002efb97088aa7fc1adc578e6d68d0f2d2dbe5ef25b0999fcd7e7208ede6e7b2a41" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing#2", + "format1_hash": "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c", + "format2_hash": "000002cfc3e82b4f82cf9a39f2f86fb495acb6f481b91643bd8f5591a2ed34f794ee9a" + }, + { + "source": "tests/arrow_digester.rs", + "id": "schema#2", + "format1_hash": "0000011d2c77a01beb74029cb2a71fe52eac4ac3ef7b31b55df717fc8098dee73735cf", + "format2_hash": "000002808e6baa50d385bb8fc28d1a63b5eab6de57d73929e68f33d6422e2989d0a2a2" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#2", + "format1_hash": "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5", + "format2_hash": "0000026b928249c5b3e8a99fff770aa7cff273da347a8dd5ee5c1647e7a03b41aeeac5" + }, + { + "source": "tests/arrow_digester.rs", + "id": "decimal_array_hashing#3", + "format1_hash": "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e", + "format2_hash": "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing#3", + "format1_hash": "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a", + "format2_hash": "0000022c8e105be42590d0cd332abcf8330269689cf66767322d1ba799271c6346744d" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#3", + "format1_hash": "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e", + "format2_hash": "0000023277d54aec4f229bfd0f21e772c332d2d4851c8af07b3f36be29f655b91b6b48" + }, + { + "source": "tests/arrow_digester.rs", + "id": "duration_array_hashing#4", + "format1_hash": "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b", + "format2_hash": "00000257be9b6546267351273ab5c9bd7858c17b17b093f7f65a599bad8bde37ab5c9e" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#4", + "format1_hash": "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0", + "format2_hash": "0000022d542c28b882c3e78bd1758a04c628c829efb9c16e78ad4185cd97e45544e988" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#5", + "format1_hash": "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30", + "format2_hash": "00000219b77ac863025bc3a0c519594e873846eaed63ed9d7c16763ad9eb36016623ed" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#6", + "format1_hash": "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842", + "format2_hash": "000002973baeb308b246159206a6072825f4cb786d05ddff11649199c93df22abdaac7" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#7", + "format1_hash": "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3", + "format2_hash": "000002fe90da5f713e78f96eed1bf834e6fe2f871aa2c7f28174d8a2dcb3134f5dc4cc" + }, + { + "source": "tests/arrow_digester.rs", + "id": "timestamp_array_hashing#8", + "format1_hash": "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796", + "format2_hash": "00000275a347fae688071e8d3d94d6ff48800f3dbbd9d8fc629c871eb4e16dd3e59976" + }, + { + "source": "src/arrow_digester_core.rs (raw digest, no prefix)", + "id": "nested_fields", + "format1_hash": "9b52ad7430dea81b35f14a04d828b2424080fbc210570081c6e6cb62b6566c42", + "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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": "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#2", + "format1_hash": "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88", + "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 new file mode 100644 index 0000000..8d7af9e --- /dev/null +++ b/tests/golden/format2_v0.5.json @@ -0,0 +1,5224 @@ +{ + "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": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" + }, + { + "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": "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" + }, + { + "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": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864" + }, + { + "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": "00000268dbb8a2d5842f0e3064faf0fc52f687cb0d0706e110aee3d07d6c6a4b3a6864" + }, + { + "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": "000002f46be8acf0132c93a5998ae80c6972a3c91cb5ff5d8ef931b89ff953d172c76e" + }, + { + "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": "00000239bdd5d7e4ab08cc7a4e4e770de964d2b8aa3b75967e13281def353f08ce51d3" + }, + { + "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": "0000028f04578b9165686ed0110acd494b70a0b3d3886cabd745ee33f3fb2846e026af" + }, + { + "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": "0000028f8137c97398d96b8d1a49ac043c68278193a24d8cdc31fc80b9a6be1028dbb0" + }, + { + "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": "00000239bdd5d7e4ab08cc7a4e4e770de964d2b8aa3b75967e13281def353f08ce51d3" + }, + { + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" + }, + { + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" + }, + { + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" + }, + { + "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": "0000028a3ab36cc0b6536ddbd1c89db07eba14f8aec16b5f609d93f15b63e1f28c20ea" + }, + { + "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": "000002cb6c7c28389b3a9806541e5a00327662c35450906fe74fdeb029ef0a04362dfa" + }, + { + "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": "0000028bfe6c9d2d41e7880f83a22d15b23f315276282fa10c952f095fcc14777b157f" + }, + { + "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": "000002cb6c7c28389b3a9806541e5a00327662c35450906fe74fdeb029ef0a04362dfa" + }, + { + "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": "0000028bfe6c9d2d41e7880f83a22d15b23f315276282fa10c952f095fcc14777b157f" + }, + { + "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": "000002420d0566f1ef5d0880b12a4431cca4a0f7ca37ff50fbbc2a580c75d5a0e52618" + }, + { + "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": "000002420d0566f1ef5d0880b12a4431cca4a0f7ca37ff50fbbc2a580c75d5a0e52618" + }, + { + "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": "000002ae016e8ceb41644142fd9370fad2087d49a36b22c1a45696e833b020f4971a5b" + }, + { + "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": "000002ae016e8ceb41644142fd9370fad2087d49a36b22c1a45696e833b020f4971a5b" + }, + { + "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": "000002defaa77ea7f9a96b205c41605c03464fe860ba0437445f3c747a12b6db84f32b" + }, + { + "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": "0000026bfeb3264ccf8ffdaa022dbd7a7273b82e079dfb2b43686c25fd9d267eb81cf9" + }, + { + "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": "0000028a064f5ae16bb17c763e9c2e5ddf63758249350b35ee85ddffaf73a639994809" + }, + { + "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": "0000029b18d33ff5310a20b71324654fabe6bff0c2018e02e2e2a597431a67c300d381" + }, + { + "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": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e" + }, + { + "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": "00000213918ec5e2c0405005fabe4318402d87cfa38b3e14db3b88ba4307bcbbc7451e" + }, + { + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" + }, + { + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" + }, + { + "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": "00000201efd772ff081a74dd5d8d76a367bd6e1c8b5fbbea75cd8297e4d29bb2050ff9" + }, + { + "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": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33" + }, + { + "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": "000002f8585c3990131b7e2c44ce2400e6e7282cbc97a3568eee7ece9390790797bc33" + }, + { + "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": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777" + }, + { + "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": "000002711005dc0113ca2ef82b8b5db8096b53d3e256289b4429583467cbdeee35a777" + }, + { + "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": "0000029f9c29a1e3d9b1c09f0e0a193865a9cf334c90242944583ae7a2da5dd52aa6ac" + }, + { + "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": "00000285b339b70e8d2bc368c0ea6ae56843afa7deaf0d00275ba5e15e2ad62457b804" + }, + { + "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": "000002b8f040dfb0562ccea535a45ca321233ffad27738a54d6bc2e2d092928bfdf07d" + }, + { + "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": "0000029e617bff9390de342ac8df0f255256ed7bcf543f7a834e179ef15f6d478299cc" + }, + { + "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": "000002b8f040dfb0562ccea535a45ca321233ffad27738a54d6bc2e2d092928bfdf07d" + }, + { + "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": "0000021ebf27630271ca9ef53a9153c5310b979d7d53b5c246c8582c693aef78c5ff1e" + }, + { + "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": "000002a14d5ec048cb3ebd9c9e1ba94e56b2096ab6ab4c7aee2e1203254b091e9c3788" + }, + { + "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": "000002e5f3c8a98f577eceaded46c0a9af72fc43376a2b3aa3c98e8661de6d2f432f3d" + }, + { + "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": "000002aeacee15f252f685ca6ffa636d4ed1e1ea2763da0c0e6078a5099fd77dd336e7" + }, + { + "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": "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27" + }, + { + "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": "0000028ff3df6a3c3249959db37063755324949df6b294b624131d395269f8d3f64528" + }, + { + "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": "0000028e4c60ec932ba53b9f514d4f6953091bed36d7295ad1d4cdde10907b83bf550f" + }, + { + "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": "000002c561a8faffd7f221815520f26cbc214640dc54c14a5cfa986e31e6978b53c3d8" + }, + { + "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": "000002f78a226fad9d52501db434f7a0d63d5c8ecf8c8032e508d45739e8be34535bcd" + }, + { + "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": "000002bdec9d15a144f01c0287210e62d82472cf33d5ce6a0351833e9851b6c0269e96" + }, + { + "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": "000002d52e9bcf59ec55166263d52292a7383240c5b6d5ed956b2c7b23a8d7ef96e6a0" + }, + { + "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": "00000282e20df356301b02bb6ac0b359c5264f9fa6907a96b82c87cda1bc0af690928e" + }, + { + "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": "000002b697545027698c19c381e6bdf63663cd01239fa0dfce229da818812227eeb766" + }, + { + "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": "0000028764580f51fc33f448a01a83d66952b7f529f899fb49163dfa51fc992c2be5cf" + }, + { + "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": "0000028311d4a59ed443d04ecee00b977e3055629be729aaf79adfb1f6269a06ada645" + }, + { + "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": "0000028747189dc0ce0fe089a03fbf5f4d5af3d11a75195949daf06f25edc430633a88" + }, + { + "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": "0000020a2732b0de633930e317e0d74b00c92e88cd163907f4fd2de331c9e8895ad390" + }, + { + "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": "0000020a2732b0de633930e317e0d74b00c92e88cd163907f4fd2de331c9e8895ad390" + }, + { + "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": "000002d9e0d412e4a1f9f09707d320f38231738a4a8c932068e953b9dfbcbc58533745" + }, + { + "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": "000002ca1221c5456782dce99f6c3bbe66dd0deab57f8d4fc41fe463ec8233873f3a36" + }, + { + "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": "000002ca1221c5456782dce99f6c3bbe66dd0deab57f8d4fc41fe463ec8233873f3a36" + }, + { + "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": "000002447b4b733d5401aaf7a1441eefbef0f96fec67a0daf19e847a424a1d7896ca1a" + }, + { + "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": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796" + }, + { + "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": "000002ff9ec51dbf46006face1286f2ed8aa844b370c20cdbdc9fbfb12d31f8a87a796" + }, + { + "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": "000002bf55d73c724270acff73eb548a913a4debfd268161ee20fb5c0569baeb1303f3" + }, + { + "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": "000002b61578fa2262cb59cb43bc62ed5178ccea96442fea059332632bfbc644a246a6" + }, + { + "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": "000002f6e55b477db784b8472b1cd7cac8d9af2c5ed4bc435e4463aad68769d08cb69e" + }, + { + "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": "000002f6e55b477db784b8472b1cd7cac8d9af2c5ed4bc435e4463aad68769d08cb69e" + }, + { + "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": "00000250cb2fc7aaf1c32b7d195c543876c8333c0b15f85caf96b4ce43fe587f444d07" + }, + { + "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": "000002d1c4267472a7b0df719325b9fea373625afa4c828dce1f56a106e14c09987068" + }, + { + "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": "0000022b4bc34d58bf66048529ffea97a18505809ea102836c19467516c388092db7ef" + }, + { + "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": "0000029edc93ce2109bb4e931489baddc900e904dacac2cfbba356464f986ce4da3c63" + }, + { + "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": "000002b15be8f2ffc47d7dc2b88d82ea2acd2a35506a7746df85c3a2b2d20ffde439e5" + }, + { + "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": "0000026630aa8326714cbd9cb8e539a9dc2aa9e966bc61cc43f4da30bb51a855c9cd06" + }, + { + "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": "000002517a1bd090b9ddec71fb8656b6a5064b97e18ad760c14116ef1799cba4eb36fe" + }, + { + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" + }, + { + "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": "000002cf2404bcc0218a195c4a262cc022bf7c77f4806d41e8c4431e3cfd5cc97ee9a4" + }, + { + "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": "0000022a14ec9cc1066b92f435f414832d0948a52d72dccfb2c4f35eea219da00c7c96" + }, + { + "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": "0000021fae7750bc9e056286f3446edae67e8ad93c540edbd3290f6c4bf2d63882390d" + }, + { + "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": "000002880943a6023e397289e89fb31d609807d68a56568133935693da686c53199eea" + }, + { + "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": "00000276aeb72c9e3f36df94c629d354a68c357bf5306d86e2be7244de6c0a9f233c20" + }, + { + "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": "0000027e7b9052d16a3bb2a65de3de6b099781626668f023583a6268c411b4c3146a9e" + }, + { + "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": "000002f8d0cad8f2f257bc9754fcc1ba34ee9de2759d377a2985dbcfd5ab821d727f4e" + }, + { + "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": "0000024f8a88ee53d98f07c353289631d09ad5c5df0033b700b7de7684aeaa7ef10c5b" + }, + { + "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": "00000274b9aafeb1cec10353639e0e61accfbbb1504495ae83f08e5cfb7f042da675b6" + }, + { + "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": "00000291782733ce1ef1799c15a2727c9f8792f71714fad00afb19fadaec4927e3c23c" + }, + { + "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": "000002b0ae5216ef5d178e64a98107d83eb1a461c611b17d611e2c779a3f0a8896b6f3" + }, + { + "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": "000002038a10043e3b9955bd29cd1ed8df9e145b620b0084df5c3606e836197d4f4517" + }, + { + "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": "00000217932a02d84ea18735d3535c8d1caf2ede51ce21a1dd5bf9c28ad9766ba40433" + }, + { + "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": "000002c915fc059403168923cb1bca8c577cd50ba76ac3ecb9db2c419cde716f1afea1" + }, + { + "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": "0000026efd81f7599fee7503b0ae97f5a45bca1541a8bd8f3dcb85e4f5e9ee4b828b77" + }, + { + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" + }, + { + "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": "00000281e68cbc71271d8bd4bd49ca0b4fc06ed9ee14d0a9b89e94c7b4d7f57a765fc2" + }, + { + "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": "0000026377ee1c5f0cf836051940feae161f2a199af2b37aa1fd0fe74c8c5debca90c5" + }, + { + "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": "00000273951df95fbecbab7f34e569e023397c1b0890b29c84ebed68f774e1a12092a3" + }, + { + "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": "00000251c6c06562499d5b7cc779fc3c43945e5c26372ac7a500d2c109d7388ddb7811" + }, + { + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" + }, + { + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" + }, + { + "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": "0000023ae70135e4be8727ce6bcca431cd1b5aeae9ae669832af0604af9b3b02968067" + }, + { + "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": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" + }, + { + "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": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" + }, + { + "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": "0000024d1d322fae924180689945b3021cffabde62a8e7e6852dec6e5a0b7234b1cb83" + }, + { + "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": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456" + }, + { + "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": "000002f757edfba8da05b7cb303dc6775504abb3291b4880ae27a5c10ab7e65c41a456" + }, + { + "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": "0000021c7248fb925c72a6f3736d2726d4dabebd21719374e36f719b016bcb41b6913f" + }, + { + "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": "000002357aea0047d56e03b89e5c7cccab769bcbda1e8f5c9b92b59ddcd13364b7d430" + }, + { + "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": "000002e14df9d1686586ed6f4be4c5871badcbd7879b55c2ef94acc61037ed40336981" + }, + { + "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": "000002510338a913e5edf04937368329dea10df409b70f5ffae6f5c9cfd970f9030e84" + }, + { + "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": "0000026e041b5e9234671c85d59a78d96ec1c0349c6932cb7c83aef4c2d083ee916816" + }, + { + "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": "00000225cf7664ca164996e08dc955260f09dd82b229b07bffc6796f7b693bb30824cb" + }, + { + "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": "000002d4ac9219266d2a330085e8a922040b7fe37b31c831be6a497053b39bfffe01ec" + }, + { + "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": "000002d4ac9219266d2a330085e8a922040b7fe37b31c831be6a497053b39bfffe01ec" + }, + { + "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": "0000026c3a344f7fcda6c51ee4bd97ecf4c3e6dc702ec2045323c52ad911534cff00ed" + }, + { + "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": "000002c467967f693c01b3bbb0f924e190d94884dc5db908a61185960c78e69843bebb" + }, + { + "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": "000002dee12b05ca7ae8846ba2ee678edf4c2bebedea94bc4835a0530a76b7107cb2e2" + }, + { + "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": "00000279d7cb82ab7366f2452bfd63a48e7750a32b174153e5c13fb80f2336adb2dbff" + }, + { + "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": "000002603a9d732b4fcfb5c541cc34cf555700eae9bc784f1134ba92f4b9cad77fc891" + }, + { + "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": "000002cd74712d5e98d95dc6483bb7a4b138cab87599aafc4078a56113da4ea2ddf96b" + }, + { + "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": "0000029c417b86f36a682f15febad4cf56d2fab64955343f01947d2fc7f2d85f3c624b" + }, + { + "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": "000002e021597c0c578e92250e14aa209a20f98fea2f771b1f0d432934ebeb2d060246" + }, + { + "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": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92" + }, + { + "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": "0000025e764a1dd23398ed2bd55e5e230faf07f29f017df8f9b6d8a78eced72e838a92" + }, + { + "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": "0000023346eede62527944ffd5add8c56010873cc2cb8b3fe8a10177559ebb7abdb365" + }, + { + "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": "0000023346eede62527944ffd5add8c56010873cc2cb8b3fe8a10177559ebb7abdb365" + }, + { + "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": "00000266430e24680d87a4279fd531bb8c02340f72b05682da212f5d525b0f7d3e147d" + }, + { + "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": "00000219e467d0280ccc83ad4c67e063997344cedd781f6cb4e449d03d713c989aa12b" + }, + { + "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": "00000243e86acd4c8280d660a2d9d195ac84e24cc5b2e32cdb98a149cf96b90fb00cd2" + }, + { + "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": "000002804e03e0e3a2f206695994b8981023659f80f059c3846f7e0129984e825ffefe" + }, + { + "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": "0000022ae8b1738e6d60639997d031f836ff00ad648ae80338ed8842165a7dc6c9e194" + }, + { + "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": "00000239b35cec44b0388712b60c7552f76a70ce9389090c309745cb69ff6d4a70e69f" + }, + { + "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": "000002360ce1cbd543917fa1444b88470e60303ba415e829d29754bdc20d1f9be2c4a0" + }, + { + "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": "0000022fe3f8d8fcba7e393f3c5808894db2f930a8bd8388e9d04b3763d369cc6eae88" + }, + { + "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": "0000021025d6b1094cff9fe38507c3084f946706d87c3ea3e75450eea8f90dda88c1ae" + }, + { + "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": "000002fcc4a6000e54c88f15ce378526d2aaeb6257909dcda76889744ad3fe18e3d5e1" + }, + { + "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": "0000024f30d74a4ecc5859895de78ae95fae3802012a4d6f1bd287c18dda362d11d54a" + }, + { + "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": "000002de72c4fd435d790c5de13417fb3d095234f8dc758c3f5e98f69da140df633991" + }, + { + "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": "000002447bea7a601dfa82970dcbebc6329000e919834962a41b80bf828129833cf1a7" + }, + { + "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": "000002e8507fd72e9443507bebbd5e1f6650a0e761f259fd4d0ebc28de1f0f045ae4c3" + }, + { + "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": "000002f425dc7d65912c647b28863bdb42bdc25d0bfcf5d0bc0c00ad5ea1fdaf64979e" + }, + { + "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": "000002fc56f2b28899780f7ad99a1166f620767b834918ddc5be06ef06a4a03311c1d2" + }, + { + "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": "000002a33d14f20c923bd3083eb2257edb5e89f216a3612d122e6d47adfb29409e2feb" + }, + { + "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": "000002ae91ac257762841aed12f8986a96ea10072d2e4573bb2cda0862d002bbe4e3b4" + }, + { + "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": "000002013cdd44a14ee692b7d98d8909d5e2230a0b0375f03e2f1d64c51518567393d5" + }, + { + "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": "000002e8fa19e1f3e0f9ab96f3c77cfbe1b8a2eb42f0e41af3f9b61c76fd894636e82a" + }, + { + "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": "0000028103d67a1b84d9305488727baf6a5f9662278a49cfccda2c441a9f6fca337cfe" + }, + { + "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": "0000021ce5d36566850439ffb338c1e4c5aae756e8250ffe681803328c75951f55914a" + }, + { + "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": "000002b4753897cdef0036ac4ae0397dd4de049e0644effb0acad9bd5c57ea606f7c7e" + }, + { + "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": "000002722f2dbfd37702f6d2b38b5ee134eaa4d8d0c473f26a6fa9c9accdf5ff738bf0" + }, + { + "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": "000002ac3e91bd728f7101209ba7cda9f99e9ba4bdbdae19a7ec52a945377246041842" + }, + { + "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": "000002bdf9bea09e68f1e94c2903c635806055578a8e959f674ebb5fcc91d2950299cf" + }, + { + "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": "0000029d53ed8a06173c17c1d5c3ac7c05e664906f4c38705b6d42531535b85516196a" + }, + { + "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": "000002fe84148cb5b19a35c8d7f0f74fb999dfbe73b39eb9d175acc56a68496bcae3c9" + }, + { + "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": "000002cd80a7aa2d0d65df7a9b49fd4553e7810379df991305ec129049e3706dd27490" + }, + { + "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": "000002603514e8bc5a8e579d7fdb7e06bb05a7eaebaf38f91f474e2844dd34cdaa0747" + }, + { + "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": "00000202c0525336a81e428a90c726eb51a62bd8753aa055f0aad2df8b472e42f2b5dd" + }, + { + "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": "000002fedf19b8af467ee7acec8f738218feab196b07826821198b909bc82537e8f924" + }, + { + "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": "000002fa87e7ebb1972366c69da6e6656c5ae10c89906a9110bfb2764346f0b49c5228" + }, + { + "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": "000002e83f805720c95bd9f74201cea503c4a2b489dc84dc04dc1826aa81331cc774d1" + }, + { + "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": "000002d4b6344eb6e36da5864993f7884283fd9d5f81e2b5e2bf2ef7942beb98d41e9b" + }, + { + "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": "000002c3d16ff0a20bd9e420a4a851018bb2e445ab4ae8973902b331a6312741ed7559" + }, + { + "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": "000002a0bc2bf04f37e9838f02f8f948619c298300b9a8c0ed90a2d4aaa80627fa6209" + }, + { + "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": "000002f5a5aaa5002a1db4a752adf89927683d31f2896bd795cbb4385434051f5cc1c7" + }, + { + "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": "000002a8e4e8a46be0e1eee3876ae9f8996463c26f2020f36bd02dd5d15d063b9517cc" + }, + { + "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": "00000257560dd4115945bb73829a8b42eb50c91441221b153e8e8af9cc741a98a1a9d2" + }, + { + "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": "000002e37ba68db00a13fda1269115c93112e82f47e0001954736e0dbac6ec0478529a" + }, + { + "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": "000002deafca82c59e247745cff3aa1be6df4f079b034bb74688a2941d8bd9a8eb43d1" + }, + { + "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": "000002da4cfb6ead4c47fb7f40c73df8ba0ccf616d931461f48dadfb5a018772576078" + }, + { + "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": "0000021140c59d69e5aff07c4c9fb5acede1eb2f93529ed40b42ea04d1fd873764be0d" + }, + { + "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": "00000244ddd18aa817bdda2931252ba87319aaebce9b5bd9ac1400f3bff958e6bfa92c" + }, + { + "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": "000002d9e806587afcff2f7bf1e5bad572696f5fbfdb9ebf18813466549327b8d51211" + }, + { + "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": "000002e8eb312e375f9c65f3b3d0d029b19f0eb41821c5efeca2a59c9e17a287a0d83b" + }, + { + "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": "00000227ac504a2ceb17222240736fabb8a9bc473adf914921def7d552f85d324326f7" + }, + { + "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": "0000025307a5443dbf29dde69b92ea0a4cb4dd4edec402ab3f21f3757ca21ffb6f0ef4" + }, + { + "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": "00000265fcc9e37a235725f68d94bd5a384603416c4893ca8c7e68f1b24cabb2a10f99" + }, + { + "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": "000002fb41d9fcaf8a1e416d559fa0b0c066e578dbb3ab5056732559faceba7c12d205" + }, + { + "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": "000002f72c04377c44ba38abf0fc2b04cad73a66d97c290985810b594759b39e0e0751" + }, + { + "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": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66" + }, + { + "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": "00000215e01890e9dfccc493b47ce8370f56ac28e0a1e0c8219c32fc8d67abe1542e66" + }, + { + "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": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8" + }, + { + "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": "000002daf27ff7489226e260129f148f6c415a8d403d6434fe4c30eb70a7b4bf14d0c8" + }, + { + "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": "000002ae4524ad2af645eab4f9c6d0909c9361fd5b25f4381b6ef31aaf1edfcedf9ddf" + }, + { + "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": "000002f66721c03015a7ef24bb7d084e984c2e4e7e1246e9573dcbf0ef0819f3f0abd8" + }, + { + "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": "000002e72a6e74a24550cd50f142e754901f4bd7aa2fbaf801ae1d8c1c7dbb49d6b83e" + }, + { + "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": "0000025e79da0f495b82e17ec4f2a2fdf191a6f92357073a0232f0f55ad7014b1401f6" + }, + { + "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": "000002e30b27b07b6518a7f089c4564e0bbdf34f6e566e83579764e8fc4873156b34c3" + }, + { + "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": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" + }, + { + "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": "000002f99bf8ec8a139a00a36a06178b72829b3cd4b5200576b48c8a8f7dc1ef5f00f3" + }, + { + "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": "00000277f78b5887bf2face0b85767b991be1ce3da47b1cc4d1cdc334829087f4f1a8f" + }, + { + "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": "00000253583e73e2411cdfe9480e8ce880911d8b4d8fd64a190df43e5bcfe05dc31a0f" + }, + { + "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": "00000253e505e95c4ad8f282aa77bcf40b16765a083d12c4c9d53e40ae68a8637312c3" + }, + { + "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": "000002a8f5cf7e6b91be0295d993bcbd390aca1f760f0b372542835fd33e0a4ce90555" + }, + { + "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": "0000025ef8e7c3170ab5e170f2c2b8d7b77387d75ad36f4839a3744abfc65a9e2ea55d" + }, + { + "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": "000002c1c097d82552031e54c21b51c6cf949cf3c06ffb2a97d03fa406b5c6ea362883" + }, + { + "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": "0000020b6be72d5ed5a3e707ed0987da88d5159fad1e49efbd4b65ac54cf6cd8d14ad1" + }, + { + "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": "00000222ad2565aa0ac5b76e6c37fca1dc25079ec5cedadbbfe2839b5371271eff9e4b" + }, + { + "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": "000002b7df9a84f9fc083ba5ea3af2bf52039a3e12aa361b9fa76560df38e958ca8098" + }, + { + "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": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3" + }, + { + "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": "000002947adb029bfa2139d1cf5c2c34c2aeb4798be4154484f01368d3a4b0e9f3cbcc" + }, + { + "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": "000002ae0dd1f0e4e372edb7c1c2e03cad21aaf0fca9e1a8415016218242cc5d83b0ab" + }, + { + "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": "000002557839de98aded74876685e0bee6cf73f79ec9ade25ce0767505720fe453881d" + }, + { + "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": "00000269fa67810dd0ffea5b7f22d32ba797bf4e1213d935d782046442334f9186ef9b" + }, + { + "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": "0000027a667866945ffee424dec01ad00c7d6661329182b0991c28226f22e7ecf4c641" + }, + { + "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": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed" + }, + { + "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": "00000214b3230640f4b409f5f8e74ec4c8d02889c3c02bdf4a6f48013340381c7219ed" + }, + { + "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": "0000024f090f0f6acbddfa47488c84eaf9e5afbf323c3040fed95e0a26200e5aa0fda3" + }, + { + "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": "0000024f19ee8cdd0a37b10f2c6fba59ab8b1d3dee84d1f87a7a6f261c73f74fa010a1" + }, + { + "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": "0000024f19ee8cdd0a37b10f2c6fba59ab8b1d3dee84d1f87a7a6f261c73f74fa010a1" + }, + { + "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": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" + }, + { + "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": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" + }, + { + "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": "000002b0b53567a6810a0b9d17db75277da500237eed72ae05e7da0154ef001072a36a" + }, + { + "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": "000002f219e560a2d1045160dc48a55e11e8887cb74a99b623d7db0865e3b5074980a3" + }, + { + "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": "000002f219e560a2d1045160dc48a55e11e8887cb74a99b623d7db0865e3b5074980a3" + }, + { + "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": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" + }, + { + "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": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" + }, + { + "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": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" + }, + { + "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": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" + }, + { + "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": "000002ca148a2e68b471062c6e7ed9c4c2a3a6ee92fe0d3805f1f92184598253a3e85b" + }, + { + "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": "000002678a08f1a03321dac8b2bbb839c061677eb95bd6d647620fb9826dbcb39c4336" + }, + { + "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": "000002afd27bf348c998c8887f50b0a0cb68b267dd88df01da348ee0b08891379c4957" + }, + { + "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": "0000025e44a8ad8933f8f3fc6a25c23bd1fc1852add2a34b7094c2deac94a3f319c3df" + }, + { + "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": "0000025b9596ac0d5dc5e8a2ae603e04c3b0f5695375b256bdd7095c9b51e0814dcd24" + }, + { + "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": "0000021636f6baaccd50c67dedb2222ec5652222d01e2a892db8970aa408203a7a969b" + }, + { + "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": "0000021e8d72a56f40f4232502b6ddbcb34190230a8becee8b12b80749d1660108724b" + }, + { + "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": "000002032cd8892cf7c5fb1f48fa368fb97f9a4fe5dbae881ea76cc7d3b376c5aa72da" + }, + { + "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": "0000024e70410d1fbcf7125cb5869c2e52f4eb6164a2db360abf56132992baded0ab72" + }, + { + "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": "000002b2c471d31fd1a5aeba30d713a5cfde4248b4bfb9783b405cd87200ca972bcbdc" + }, + { + "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": "000002e1a72384de35cdf6b30c2fcb5c3ce4cbdbd48893fe63a51fc56702cf52d68b16" + }, + { + "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": "00000260d928527fcec14757ec61388ce41a91d63226f0429eaf5970b5b8b483caea5a" + }, + { + "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": "00000260d928527fcec14757ec61388ce41a91d63226f0429eaf5970b5b8b483caea5a" + }, + { + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" + }, + { + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" + }, + { + "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": "0000023e1e7782881c99015db80e75c5022d0e4e173fb75b58f403b37d81cc87c37aad" + }, + { + "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": "0000028fa28d8bd77393a4b5eec8440bb37e7cad92ac780cf9496a16aac487f0536cc2" + }, + { + "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": "00000253ac95a2126faff99f0883443caf8148d98c6c111e687d8f167aeb8cf3edb28e" + }, + { + "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": "00000253ac95a2126faff99f0883443caf8148d98c6c111e687d8f167aeb8cf3edb28e" + }, + { + "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": "000002af97f3ab1aa4341a2515f97de07d7b5859440dccee1a1a0447764a00b0095c4f" + }, + { + "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": "000002951df50c18d2e83009c1084a63f60fcba7082719400aade93421887e2ba782ac" + }, + { + "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": "000002951df50c18d2e83009c1084a63f60fcba7082719400aade93421887e2ba782ac" + }, + { + "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": "000002f73821d0ed4e08eace96e4c3967cb5c4a30e73184360bf3b4e3f17efbd334dd4" + }, + { + "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": "000002f73821d0ed4e08eace96e4c3967cb5c4a30e73184360bf3b4e3f17efbd334dd4" + }, + { + "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": "0000026be3fe52e7473c5427d6631e64214bd791df16f1c2beeb9fc268f36eb40884c5" + }, + { + "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": "0000026be3fe52e7473c5427d6631e64214bd791df16f1c2beeb9fc268f36eb40884c5" + }, + { + "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": "000002ac5c10d1baa87b285918b4e1dbaf94d6116141299d4d1143f04758b6ac51d043" + }, + { + "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": "000002ac5c10d1baa87b285918b4e1dbaf94d6116141299d4d1143f04758b6ac51d043" + }, + { + "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": "0000026954b6975ed1333509d737413df196e9e2cccd1ad1abe5e3727f49a47e719ca1" + }, + { + "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": "0000026954b6975ed1333509d737413df196e9e2cccd1ad1abe5e3727f49a47e719ca1" + }, + { + "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": "000002f3cb9cdcdfe5bf02a007141a4e2c770717536ddae50c30846c8f4ffb5df5a12e" + }, + { + "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": "000002f3cb9cdcdfe5bf02a007141a4e2c770717536ddae50c30846c8f4ffb5df5a12e" + }, + { + "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": "000002c2405711658508f6d05bb7011a4de526b8754e5cc7c1d872fad755a2ddcb88e5" + }, + { + "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": "000002f14382940d07ab355d30c3e52e0e8bd7a9dfba578fed90fd814e2c3a0548aa07" + }, + { + "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": "000002f14382940d07ab355d30c3e52e0e8bd7a9dfba578fed90fd814e2c3a0548aa07" + }, + { + "id": "ext_tensor_canonical_schema_f0_im1", + "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": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgAFAASABMACAAAAAwABAASAAAAeAAAACAAAAAMAAAAAAABEGAAAAABAAAAJAAAAAAABgAIAAQABgAAAAQAAAAQABYAEAAOAA8ABAAAAAgAEAAAABgAAAAcAAAAAAABAxgAAAAAAAYACAAGAAYAAAAAAAEAAAAAAAQAAABpdGVtAAAAAAEAAABlAAAAAgAAAFgAAAAEAAAAuP///wgAAAAkAAAAGAAAAGFycm93LmZpeGVkX3NoYXBlX3RlbnNvcgAAAAAUAAAAQVJST1c6ZXh0ZW5zaW9uOm5hbWUAAAAACAAMAAgABAAIAAAACAAAABgAAAAPAAAAeyJzaGFwZSI6WzIsMl19ABgAAABBUlJPVzpleHRlbnNpb246bWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "expected_hash": "000002b56ac70e07b9d186d9f33fd6533423e31492c541c207e595cc7bd45de6ad57df" + }, + { + "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": "000002f4c4b4f12d9c4c864fc79415620c964ccdb2ed70596c57e0ece56f45cdffd190" + }, + { + "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": "00000235321696f80bfbbdc5aa40e47100ccd1729824b88c52057babcae9c9e0dfac93" + }, + { + "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": "000002da360587b0de86e244cd52b04693787639cadd6c59f11a8d7f688f839463dd4f" + }, + { + "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": "00000273f2b0aeedb498d6980083f025b8e0c07c74c57c9130aabfed2af1b31e5ee0af" + }, + { + "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": "00000221f1240fabe97f742ddb3195193cf785f61e327b7d64ec7363bbbce399df7e50" + }, + { + "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": "000002cb129d9295971fe47548a28b3070f18a4a000d449aa6e612446c37e7a104bdb2" + }, + { + "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": "0000020ee499da085a532f069ccfe218a9af0f2fa33ab8cc21b79991bdc36f5323f141" + }, + { + "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": "00000248ddc5205e534b4a5dd91fb3ce5b5c4cddff659844e77de731435ab8eda086cc" + }, + { + "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": "000002f5401303c3c8609dde1c1162a0a5388183231ae9d7aad98a5165ca6cb949e474" + }, + { + "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": "0000020ec4f4365fc43e57f5a229faf87d5e90dbe3ff53f64844c7bae443bb5c35bf07" + }, + { + "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": "0000023c4a18350b71b2498685b732bf86aafa7edc9b6aea24de50e6a764cb4f0a8ec6" + }, + { + "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": "000002bab5700cfdadfbc1a63b32bbab4c8154ad9696f024e6965266b10714d18ba772" + }, + { + "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": "00000223f577c71ad70b36baf8db3ae57304492642edeab6f98560180b624eb7127d40" + }, + { + "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": "0000021193e13fb74196a3ba1e2848d8b371cbaec0145408be4c10dce5c7da3d6f0ef8" + }, + { + "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": "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" + }, + { + "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": "00000273f6a64dd00ba1e2749c0ff21c64bb1984989efb7f94e37b188e6f0ea0ee3607" + }, + { + "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": "0000024168dcfaf09c69c2fd848090fcff65c6e27c7a8575f419e6b5c011b28633c6ec" + }, + { + "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": "000002a58f04b6bc45c95e5faa11155031bfb9dc8815187dde82b0f4d833cb8f376056" + }, + { + "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": "0000028211097939067b80d7b9d622b88201aedc86254255f02f513e3acbf8da34e04a" + }, + { + "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": "000002f2dd5acce604d642d652fbbbc3bfb16807f36100aff5a84d1f6acb194e4d90e9" + }, + { + "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": "000002aa9b7f8fdea28a5651544e73648faa19f22b87912a4b18ec121df884a65e3440" + }, + { + "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": "0000028aa5ce23c0faa5de71df6c33cb88194f8555ce4c2ddf8398ebd15e7933081798" + }, + { + "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": "000002b9461e7b30083397b2a328415184d53e8c27d315af89e22163aae5a0da91866a" + }, + { + "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": "000002ecebdb320ae446cd5347ec7cbff5272c36af957666f717c59df85cfd8410d5a4" + }, + { + "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": "000002b4fe586ae0a97fcc8ae84e83110f8980bde7c74aed4c66b60321116994982aeb" + }, + { + "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": "000002644b2970be7606407afad7635d7f7111c2f668496e938bdff452604bd444065b" + }, + { + "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": "00000279154d63290b405df71342d15c41dd9f288d5bd1dadae43f37950b85dcf74041" + }, + { + "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": "00000201b7c533b770a31fd7bc0fefa6252c2fa7100305f07f991502437cc1a5ba1d24" + }, + { + "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": "0000020885790654a7ce21e6afdfeaa4ad99490e1871149892eda8acf4d2a403566410" + }, + { + "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": "000002a51121a9cb745bbcd08ebba07ce33ef64dcb630c241d4112d27d15106e3889d7" + }, + { + "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": "000002215978d8171df62a17e8b85524418ac182dc2b1f2132ab95b8a99922dfc9c725" + }, + { + "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": "000002c1c713c7ee5c139a8799e83aff16049b6a6a935e3e3f8601e04db05c523e2d7b" + }, + { + "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": "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", + "expected_hash": "000002e86fcf5b5a6b21b9f3f4a5f3eb6608c6e531ecabd95cbf365d01089d2a924619" + }, + { + "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": "0000025a88292c68392ec7d5ac54666139cb4836c9267088dfabef093e7981c322df38" + }, + { + "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": "0000023753cbe1173b2b0f1b81ce9de03a7c0a1ba1f5431dabbdbeef99172dd357bb29" + }, + { + "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": "000002b4caaae1356e990fdb4b8ed43bf8f67bcdc3ee2f094da6e0f71575dc52ec31c9" + }, + { + "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": "000002db3095dc0093c38b3aa668aee0f1805fc815542685d5d065008dc621512a8096" + }, + { + "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": "000002f5c5e7555a574364d953e7ebeb45dbc9f232e5707133dd088420924300ae3c58" + }, + { + "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": "0000029f1118411cb35c292b7950a626469bd8cb987faa8c114d6509f09f32ec816cb8" + }, + { + "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": "000002aaafa89ee39b32668aeb6f65c56501061b7194257ea88f14c3be0eca314f1d0d" + }, + { + "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": "000002dca3ee7298f6495f2263e45eb2c876c9dc78f5b7462357f3be5f5d6579214e94" + }, + { + "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": "/////3gBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAMAAAAIAQAAXAAAAAQAAACI////GAAAAAwAAAAAAAEVOAAAAAEAAAAIAAAATP///6j///8UAAAADAAAAAAAARQMAAAAAAAAAGj///8EAAAAaXRlbQAAAAAEAAAAdGFncwAAAABo////HAAAAAwAAAAAAAANfAAAAAIAAABMAAAAGAAAAKT///8QABQAEAAOAA8ABAAAAAgAEAAAABAAAAAYAAAAAAABAhQAAACM////IAAAAAAAAAEAAAAABQAAAHZhbHVlAAAAzP///xgAAAAMAAAAAAAAFBAAAAAAAAAABAAEAAQAAAADAAAAa2V5AAQAAABtZXRhAAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAAEAAAAAAAAABAAAAAAIAAABpZAAAAAAAAAAAAAAAAAAA/////7gBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAABAAwAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAHwAAAAQAAAAAgAAAAAAAAAAAAAABgAAAAIAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAGAAAAAAAAABAAQAAAAAAAAQAAAAAAAAAgAEAAAAAAAABAAAAAAAAAMABAAAAAAAACAAAAAAAAAAAAgAAAAAAAAEAAAAAAAAAQAIAAAAAAAAYAAAAAAAAAIACAAAAAAAAAQAAAAAAAADAAgAAAAAAACAAAAAAAAAAAAMAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkAAAAAAAAAMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAazFrMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAQAAAAAAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHQxdDJ0MwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "expected_hash": "00000227eb7540623891a51b93eb1f133f461cd3231bc03f3d5f36957b452a477b912c" + }, + { + "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": "0000023e818d98ed740fcd8240f4fdb39e4c53581b071c9ab6200a27924c186414f178" + }, + { + "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": "00000231878b42f48260f2ba82a63298760afe8d214504d3b97a7019ff9a83eba48682" + }, + { + "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": "00000201b1aee1103d35dad74cda3c5a1c01e1aa5468beb02cc3cda5c1cb6c317f2d90" + }, + { + "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": "0000023014336b70e541ea20913795de44594938a32b325f17b5f03ed6ebf09859a95a" + }, + { + "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": "00000229b25b121cf4b425c068c2ac17b1952497cf7015668b73a62f925a078fa69d67" + }, + { + "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": "000002c60a39367e08f911e8d99db430267db89ca41e4cef6e87ac01520422354684a6" + }, + { + "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": "000002b87ccbba66f376281848a40936e3b3697d877c78ec651aa4151939d9f3af2277" + }, + { + "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": "0000024354ac4eb6cef06e975af9b4a9f110e6baf409446897e122849553b159e6dc27" + }, + { + "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": "0000021a7aa4df873b7627617a5ce9a234a8849202508afc27eda81af271d8b12bf592" + }, + { + "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": "000002a07f8d13692700d7b2cad515d343a2a1ce4b3dd7deac50316102a43638b496d2" + }, + { + "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": "000002a6a3ef288f2975f6a75b0336b2b7d69ffb4a2d129046710b7184d1eb76a45fe2" + }, + { + "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": "000002a157d896c73e72632c68cabed99b8351ca116199217e209552f9bfaf70721cff" + }, + { + "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": "000002411fa81d41e904d832eceea8e2041fc96bda4e4dc58e72b76380e086d400a008" + }, + { + "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": "000002b8e0f66c036e26098ba55673ee856b1b23fb6dcb9acfb63207cf8ad6fadc34dd" + }, + { + "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": "00000286ebe427c00dea251c527cc286dc591efea4d6787cb3b40d3330a476b74f6d6c" + }, + { + "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": "00000269c3b3a491ea942d3067cfdf07b67a35bd708e4ee05c45cc302190016ab4a9f7" + }, + { + "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": "000002754d4bf287e5b460d403a8468e526e92a738921b2aa8dbab8cc8a3450bcac203" + }, + { + "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": "000002cd3cde5a0df63e3a6889556920e248890a882572450350a03da90f67f37e9f90" + }, + { + "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": "0000025560faf3d3f3ce308ad2c7129f24f42589e7b25f0c6dc70ddd2aa45f7464111a" + }, + { + "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": "0000029f656d188a338cc277592a06b5710796016037efc7fc7cb5746e65bfadd752b4" + }, + { + "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": "00000236f16a0a8179aefeb33f440a83a7d32aad8993c022796eab539de2e1d63521b8" + }, + { + "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": "000002a89c186dbf815b7192ed4ac574196d1e0203db10d53dd7d16fbe12fbbdbb651e" + }, + { + "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": "0000025d4b5b129c220a3171a616f1ff060a00fdb3647a34434f4d83e9d0a68502c334" + }, + { + "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": "000002ac6614ba2b81b9238b2888b17d9ccb5eb46a7ea3285c22a1b1ad25997d726e7b" + }, + { + "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": "0000027699b386e4e56ce34d2a38f748566a75c36c62ca8f5fa36180f0ea8809ac528c" + }, + { + "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": "000002613ec04c0f0d49d1eff685ac3ffc3ee80a47ddb2121860f9845ac0d3a33fe7b2" + }, + { + "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": "000002d8e326d69087a22ebe44e971f2673272ad044e99927c9c4cfcf1cf26f1e7dcf2" + }, + { + "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": "00000248df16aca0c1f681b8b02cd0c859b3073c238101a6893bfa44d9f536a9819870" + }, + { + "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": "000002207e061a060534d98724ad2beabd1cd5d1350e5614104815a6a6c0ef13d8935c" + }, + { + "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": "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" + }, + { + "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": "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", + "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": "//////gAAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAENEAAAAKAAAAAIAAgAAAAEAAgAAAAEAAAAoP///wgAAAAAAAABAQAAAAgAAADg////3P///xwAAAAMAAAAAAAADVgAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAAAQAAAGkAAAAFAAAAY2hpbGQAAAABAAAAeAAAAP/////4AAAAEAAAAAwAGAAWABUABAAIAAwAAAAcAAAAAAEAAAAAAAAAAAAAAAIEAAgACgAAAAQACAAAABAAAAAAAAoAGAAMAAgABAAKAAAATAAAABAAAAADAAAAAAAAAAAAAAADAAAAAwAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAIAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "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": "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", + "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": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAABAAAAAAAQQACAAIAAAABAAIAAAABAAAAAEAAAAUAAAAEAAUABAADgAPAAQAAAAIABAAAAAYAAAADAAAAAAAAQ3UAAAAAQAAAAgAAACg////nP///xgAAAAMAAAAAAAADagAAAABAAAACAAAAMD///+8////GAAAAAwAAAAAAAANgAAAAAEAAAAIAAAA4P///9z///8cAAAADAAAAAAAAA1YAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAEAAABpAAAAAQAAAGkAAAABAAAAaQAAAAUAAABjaGlsZAAAAAEAAAB4AAAAAAAAAAAAAAD/////OAEAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIABAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAAbAAAABAAAAABAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////84AQAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAEAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAABsAAAAEAAAAAEAAAAAAAAAAAAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAABAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////zgBAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAQAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAAGwAAAAQAAAAAQAAAAAAAAAAAAAABQAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAIAAAAAAAAAAAQAAAAAAAADAAAAAAAAAAAEAAAAAAAAAAAEAAAAAAAABAAAAAAAAAEABAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AAAAAA==", + "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": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEMEAAAALQAAAAIAAgAAAAEAAgAAAAEAAAAkP///wgAAAAAAAABAQAAABgAAADQ////EAAUABAADgAPAAQAAAAIABAAAAAcAAAADAAAAAAAAQxcAAAAAQAAABwAAAAEAAQABAAAABAAFAAQAAAADwAEAAAACAAQAAAAGAAAACAAAAAAAAACHAAAAAgADAAEAAsACAAAACAAAAAAAAABAAAAAAQAAABpdGVtAAAAAAQAAABpdGVtAAAAAAEAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////+AAAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAIABAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAEwAAAAQAAAAAwAAAAAAAAAAAAAAAwAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAEAAAAAAAAACAAAAAAAAAAAEAAAAAAAAAwAAAAAAAAAAQAAAAAAAAAAABAAAAAAAAAQAAAAAAAABAAQAAAAAAAAwAAAAAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "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": "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", + "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": "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", + "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": "/////zgBAAAQAAAAAAAKAAwACgAJAAQACgAAAAgAAAAAAQQAyP///wQAAAABAAAAFAAAABAAGAAUAA4ADwAEABAACAAQAAAAOAAAACwAAAAAAAEVEAAAAOAAAAAIAAgAAAAEAAgAAAAEAAAAcP///wgAAAAAAAABAQAAAAgAAACw////4P///xgAAAAMAAAAAAABFZgAAAABAAAAGAAAAND///8QABQAEAAOAA8ABAAAAAgAEAAAABwAAAAMAAAAAAABFVwAAAABAAAAHAAAAAQABAAEAAAAEAAUABAAAAAPAAQAAAAIABAAAAAYAAAAIAAAAAAAAAIcAAAACAAMAAQACwAIAAAAIAAAAAAAAAEAAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAABAAAAGl0ZW0AAAAAAQAAAHgAAAD/////OAEAABAAAAAMABgAFgAVAAQACAAMAAAAHAAAAAACAAAAAAAAAAAAAAACBAAIAAoAAAAEAAgAAAAQAAAAAAAKABgADAAIAAQACgAAAFwAAAAQAAAAAwAAAAAAAAAAAAAABAAAAAMAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAABAAAAAAAAAAMAAAAAAAAAAQAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAACAAAAAAAAAAgAAAAAAAAAABAAAAAAAAAMAAAAAAAAAAIAAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAQAEAAAAAAAAgAAAAAAAAAIABAAAAAAAAAQAAAAAAAADAAQAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////7gAAAAQAAAADAAaABgAFwAEAAgADAAAACAAAACAAAAAAAAAAAAAAAAAAAADBAAKABgADAAIAAQACgAAACwAAAAQAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAAAAABAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////uAAAABAAAAAMABoAGAAXAAQACAAMAAAAIAAAAIAAAAAAAAAAAAAAAAAAAAMEAAoAGAAMAAgABAAKAAAALAAAABAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAABAAAAAAAAAEAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////+4AAAAEAAAAAwAGgAYABcABAAIAAwAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAwQACgAYAAwACAAEAAoAAAAsAAAAEAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAEAAAAAAAAAQAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAA=", + "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": "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", + "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": "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", + "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": [ + { + "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" + }, + { + "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" + }, + { + "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/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": "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", + "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_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..a0b085c 100644 --- a/tests/test_arrow_digester.py +++ b/tests/test_arrow_digester.py @@ -1,12 +1,20 @@ """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 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 +116,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 +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 == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + 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 == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + 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 == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + 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 == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + assert h == "0000022ddc0ab9c1cfc0fda9353d66612a504cb63d6ee509c4f56b961f33855f1a82a4" def test_time_units_differ(self): a = pa.array([1000, 2000], type=pa.time32("s")) @@ -146,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 == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + 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 == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert h == "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" def test_list_array(self): arr = pa.array( @@ -159,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 == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + assert h == "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" def test_decimal128_array(self): from decimal import Decimal @@ -173,7 +181,7 @@ def test_decimal128_array(self): type=pa.decimal128(38, 5), ) h = ArrowDigester.hash_array(arr).hex() - assert h == "0000011e3b33d28771b3593fd5dc4b68af8091a1ba9cd493ade374e7368e213bef244e" + assert h == "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" # ── Type normalization ──────────────────────────────────────────────── @@ -340,7 +348,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() == "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_format2.py b/tests/test_format2.py new file mode 100644 index 0000000..891a41e --- /dev/null +++ b/tests/test_format2.py @@ -0,0 +1,1047 @@ +"""Hash format 2 (ITL-898), checked byte for byte against the specification. + +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 + +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, 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 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") + + +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: + 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 + + +# ── 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}}' + ) + assert f2.hash_schema(schema) == V + sha(hs(), json_) + assert f2.hash_schema(schema).hex() == "000002f772b5bc6bb814d98a3bb68a6148dde15eaa590ad54b289c51f9cc4636a52ba7" # printed + + +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)]) + + 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: + 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(hs(), 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(hs(), 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( + 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() == "0000028934d60de8eb8c21ca04b859c02d21015032cb53ee029a4702281f2b0d5822bd" # printed + 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( + hr(), + sd(b'{"c":{"data_type":{"LargeList":{"data_type":"Int32","nullable":true}},"nullable":true}}'), + 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( + hr(), + 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", + 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( + hr(), + 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] + # "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) + 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 + + +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 + + +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(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(hr(), sha(hs(), 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( + hs(), 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"}}' + ) + 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) + + +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 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)], + mask=pa.array([False, True, False]), + ) + schema = pa.schema([pa.field("s", s.type, nullable=True)]) + batch = pa.record_batch([s], schema=schema) + 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 + + +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) + 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()), b'"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(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( + 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(ha(0x01), b'"Int8"', u64(1), all_valid(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: + 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_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(ha(), type_json, u64(1), all_valid(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(ha(), 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 ────────────────────────────────── + + +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 ───────────────────────────────────────── + + +@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 ── + + +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(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. + 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(hs(), 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(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) + 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).""" + 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) + + +# ── 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(ha(), 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) + + +# ── 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)]) + 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 + + +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(ha(), 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])) + + +@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'"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, 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(), type_json, 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. + + 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 + 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. + + 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) + 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). + + 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()) + 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) + + +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"]) + ) + + +# ── 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 + 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=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="^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( + 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 + + +# ── 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() + + +# ── 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_format2_scaling.py b/tests/test_format2_scaling.py new file mode 100644 index 0000000..12ad2cf --- /dev/null +++ b/tests/test_format2_scaling.py @@ -0,0 +1,132 @@ +"""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" + + +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" + + +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})" + + +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" 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" diff --git a/tests/test_golden_parity.py b/tests/test_golden_parity.py index df28334..da387b7 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,25 +47,25 @@ def test_example_a_two_column_table(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + 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 == "00000185a9c99eba7bcfd9b14fd529b9534f2289319779270aa4a072f117cf90a6ac8b" + 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 == "00000109cb203c0cae27346ea2ce37d1245775ac99c8b26634677de56268ba01dc693c" + 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 == "0000010fbc627fc7ad9d5f2e96fec8fa57b56b364a04a8af7e374015a07b26bd1ac80d" + assert result == "0000020ee499da085a532f069ccfe218a9af0f2fa33ab8cc21b79991bdc36f5323f141" 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 = "00000201b7c533b770a31fd7bc0fefa6252c2fa7100305f07f991502437cc1a5ba1d24" 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 = "000002644b2970be7606407afad7635d7f7111c2f668496e938bdff452604bd444065b" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -100,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 == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + 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 == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + assert result == "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" def test_example_i_empty_table(self): """Example I: schema {a: Int32 non-null, b: Boolean nullable} with zero rows.""" @@ -116,7 +117,7 @@ def test_example_i_empty_table(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "000001df8887d2ebb6968ba1dd994b1c663e0539f218f6045996a03dd20209c40d0922" + assert result == "0000028aa5ce23c0faa5de71df6c33cb88194f8555ce4c2ddf8398ebd15e7933081798" def test_example_j_multi_batch_streaming(self): """Example J: batch-split independence — two batches == one combined batch.""" @@ -127,7 +128,7 @@ def test_example_j_multi_batch_streaming(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "000001d4efb209fd319c8b418662caad5922b154003d0425fa722060b44e6d5eb0d857" + assert result == "0000027d2ac950396ddef47becbd1f9625b58f0419b7ec5fe779bd62a6ee046b5d9a27" def test_example_k_struct_column(self): """Example K: {person: Struct}.""" @@ -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 == "000002b9461e7b30083397b2a328415184d53e8c27d315af89e22163aae5a0da91866a" 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 == "000002a58f04b6bc45c95e5faa11155031bfb9dc8815187dde82b0f4d833cb8f376056" 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 == "000002ecebdb320ae446cd5347ec7cbff5272c36af957666f717c59df85cfd8410d5a4" # --------------------------------------------------------------------------- @@ -197,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 == "000001e752bea45ed48352e104fb24919ea68b1af64281231aff3a52b51a5fcabe7fb1" + 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 == "0000019ab12c5c219df0b745b77bb592945dfd5a8d8bf6c20752cb601cc554bde708bc" + 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 == "00000163dac968f9f62a036126abe3e53404b69a40f2cf02872a1fc970c7428c5869b4" + 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 == "0000018330f9b8796b9434cbf7bc028c18c58a2a739b980acf9995ce1e5d60b43b0138" + 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 == "000001950cf62cd41a3cfb936bcaeb2af16e4b9010e72e6201af4755c016b7b9466acf" + 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 == "00000130328e5fa11093ea36a10554afdb07fa718453f41a113dbdbdefc5baf06d1ffd" + 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 == "00000133e15d7b6d806f8c121f9683e1f6b62674b0f48710f7f6dc3155262e0fc84357" + 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 == "000001c3d60c88f4842be618c85a09d604cbc0d87d8ea27c164fc2acb387ca50bbfa2e" + 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 == "00000144997caad273e039ba4919a2f1db91f05b6546271121619bb1fc97d8757f180b" + 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 == "000001f5c04a8a43027a04f68de9f71b99b3075459c9c296f68aecdc92bac8ef506baa" + 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 == "000001b0e2b1cc3668a42dbc98d3b7246f7e8cdf2d5e6a38cc0510e463d36cbeecff0b" + assert result == "000002f2dd5acce604d642d652fbbbc3bfb16807f36100aff5a84d1f6acb194e4d90e9" # --------------------------------------------------------------------------- @@ -260,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 == "000001103053df817a93502fae8bd8d052c57e48acc76fc65db9316c2425805f2f7ef6" + 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 == "00000106dde92a47a5a0db64ce2c83c1de96868b8f55868003fb6e894be0751d10beeb" + 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 == "000001aba70469e596c735ec13c3d60a9db2d0e5515eb864f07ad5d24572b35f23eacc" + 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 == "000001abd6f51bd0ca68584a4ae73f4f9351cfe97fe6f3f85ed315f9b3628650a97564" + 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 == "000001c96d705b1278f9ffe1b31fb307408768f14d961c44028a1d0f778dd61786ee26" + 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 == "0000013236ab3ffd9de453dc2a7613731108b132583249f2d42eb7a102dd430e66175f" + assert result == "0000020ec4f4365fc43e57f5a229faf87d5e90dbe3ff53f64844c7bae443bb5c35bf07" # --------------------------------------------------------------------------- @@ -303,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 == "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + 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 = "0000018dc3a0e479d1335553546c8f23c36d75335cbd34805a6f96c5d5225b347fbc57" + expected = "000002e52c6b710b5c6be2cada5b225f0d43d83f2b0a89f117f9210eff746ebcd3f294" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -317,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 == "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + 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 = "0000016255bde0141ebf26e08c31c96f6112e5e21d101ab8bb90d77f2c3eec02c62d3c" + expected = "0000020580567a1ed9be7b4dbbc36046e635c7021fb1bda241310cd353a3de5a860bc2" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -346,7 +347,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 == "0000021480fe62da952e0f819540738817488f0da864a59e70604f88f00f6daec3a7fb" def test_decimal_precision_15_scale_3(self): """Decimal128 precision=15 (maps to decimal64 range) scale=3.""" @@ -355,7 +356,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 == "000002efb97088aa7fc1adc578e6d68d0f2d2dbe5ef25b0999fcd7e7208ede6e7b2a41" def test_decimal_precision_38_scale_5(self): """Decimal128 precision=38 scale=5 — full 16-byte integer path.""" @@ -369,7 +370,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 == "0000029c8ebfcade372b53f23d669d231eab0dd2dd96805263867e47af72c739e1b455" # --------------------------------------------------------------------------- @@ -390,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 == "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + assert result == "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" def test_large_list_equals_list(self): """LargeList with the same data must produce the same hash as List.""" @@ -402,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 = "000001dc359d563a1ed210eb271b314612ea8343f0a0b0955b9053a9eb47962d27163c" + expected = "000002baac87674321616f3c4b4ad559df2c5b2492a83ba54fa7e865a51ae56d8f498c" assert ArrowDigester.hash_array(small).hex() == expected assert ArrowDigester.hash_array(large).hex() == expected @@ -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 == "00000223f577c71ad70b36baf8db3ae57304492642edeab6f98560180b624eb7127d40" 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 == "000002cb129d9295971fe47548a28b3070f18a4a000d449aa6e612446c37e7a104bdb2" 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 == "00000221f1240fabe97f742ddb3195193cf785f61e327b7d64ec7363bbbce399df7e50" # --------------------------------------------------------------------------- @@ -588,7 +589,7 @@ def test_streaming_two_batches(self): digester.update(batch1) digester.update(batch2) result = digester.finalize().hex() - assert result == "0000019f5fa370d315a4b4f2314be7b7284a0549b70ad4e21e584fdebf441ad02f44f0" + assert result == "0000020ba4ed542e67ebc311d160ab54a11f25630a6b5fdd99e5dfc90917cb1d31e968" def test_batch_split_independence(self): """Splitting a batch into two must not change the hash.""" @@ -626,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() == "0000017cef6166a14741f94906bd3146ffa197d1b5756d594eb46304b678b21e44c40b" + 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() == "000001fd253a835218d5605ce8bb348699f973b93e29fbe21fe6e532468f988ece4ce5" + 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() == "0000013af741ca0fe5bd48d0bd39e1993c60e7c032f23c4cf4be6c11cc4b50ce56013e" + 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() == "000001f5b86904b4b7f2c6a18c7c4febda142bf622e4d01752f42b8f832c0a68a4d9c0" + 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() == "0000016ee5249d352c03cc820af39e98b7043993d467207cb6ca34c8d13cfacf141e30" + 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() == "000001ef46619d2be8259335ed0943f42ea3ced19ff6d75471a64b2f03aea89afa4842" + 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() == "0000017e624eb2847f79f940d7123980b076aea1c1ecd3adaa34bdae24fa00f05afda3" + 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() == "000001f677ef0e42e9e40ea092471f82283212833ab6b4ff9bb45e86e88590f8d15796" + assert ArrowDigester.hash_array(arr).hex() == "00000275a347fae688071e8d3d94d6ff48800f3dbbd9d8fc629c871eb4e16dd3e59976" # -- Timestamp: unit and tz produce different hashes ------------------- @@ -682,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() == "0000013540d23a4abf1dfbc939a9e5514be69e364cec466ef900fa35050dc3cf2994fa" + 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() == "000001564a87e1e07898af07a4a212e3db83f911ac287134f28c772bf5fb4da683402c" + 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() == "0000017904faf3043cf870f0c139cba0282cdaf11c590aeb80f2a0d6b103893ba5da2a" + 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() == "00000189a38c5a7adf4b19b3e0d467f042ab2389fed8ae5f1d2af8555dd6131478a49b" + 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 new file mode 100644 index 0000000..cbbe146 --- /dev/null +++ b/tests/test_golden_parity_format2.py @@ -0,0 +1,109 @@ +"""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, with no skips (pyarrow >= 19 decodes every vector). +""" + +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 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() + + +# Counts of the final golden file; the file is append-only, so they can only grow. +_MIN_VECTORS = 423 +_MIN_RELATIONS = 114 + + +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" + 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: + 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.""" + 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_r2.py b/tests/test_golden_parity_r2.py index b2a1886..c258528 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) @@ -38,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 # --------------------------------------------------------------------------- @@ -48,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 == "0000015b41cb9aa8a4c79da8859ae00ce976d8184bdf5426060292b69717c6f28ed38a" + 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 == "000001b93f053f60f756b3d47a304889daa8011b9d09b4c83efbfe10ca7f073d59d4ea" + assert result == "000002754d4bf287e5b460d403a8468e526e92a738921b2aa8dbab8cc8a3450bcac203" # --------------------------------------------------------------------------- @@ -67,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 == "00000104fd65cf73bc1d8e787a6940b749777eddb28285d7bfc90e832212afb6fdea65" + 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 == "00000115a6af4eb6fdb3419afebadf58a9f184f0a1fffa09ffa56600237f501db71070" + assert result == "0000025a88292c68392ec7d5ac54666139cb4836c9267088dfabef093e7981c322df38" # --------------------------------------------------------------------------- @@ -95,7 +118,7 @@ def test_bool_17_elements(self): type=pa.bool_(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001f8ad377be621fd278f5590c7cab06ca42e2b4ed6867d363f9fbf28f6f3d7582a" + assert result == "000002d8e326d69087a22ebe44e971f2673272ad044e99927c9c4cfcf1cf26f1e7dcf2" # --------------------------------------------------------------------------- @@ -108,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 == "000001e1cb4b7821c4238f0c53befd313280ff45a74b301e7044957b01a701108c5b7f" + 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 == "0000014db35cf6860dda66df959cd2b4882a4cddaa6d17e74cf389e71c5553e4cceadb" + 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 == "00000117655fca3764c8082b61b9de7186594bdcc58b86934176bea4b12d95becc54df" + assert result == "0000023753cbe1173b2b0f1b81ce9de03a7c0a1ba1f5431dabbdbeef99172dd357bb29" # --------------------------------------------------------------------------- @@ -148,7 +171,7 @@ def test_nullable_struct_hash_array(self): mask=mask, ) result = ArrowDigester.hash_array(struct_array).hex() - assert result == "0000011ea07bf87d5b03b132e46a169df25352cb2e3c5a5f8b067138e0bd2a2023e6d5" + assert result == "000002f5c5e7555a574364d953e7ebeb45dbc9f232e5707133dd088420924300ae3c58" # --------------------------------------------------------------------------- @@ -176,9 +199,9 @@ 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 == "000001fdd123a2cceb977b1448eaba26039de58f3a782244bf1cff70a6742e2f6f220a" + assert result == "000002207e061a060534d98724ad2beabd1cd5d1350e5614104815a6a6c0ef13d8935c" def test_three_level_struct_schema(self): """Schema hash for three-level nested struct.""" @@ -192,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 == "000001f5e018be18625769644d2f10aa06d52a50df75ade8872248f7dc4b296ce997f7" + assert result == "000002613ec04c0f0d49d1eff685ac3ffc3ee80a47ddb2121860f9845ac0d3a33fe7b2" def test_three_level_struct_hash_array(self): """Three-level struct via hash_array. @@ -221,7 +244,7 @@ def test_three_level_struct_hash_array(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "0000011dc18344fc9e0c026561c3a38ca128e5afa90d7b66df2cffac51a18bf106d0d0" + assert result == "000002db3095dc0093c38b3aa668aee0f1805fc815542685d5d065008dc621512a8096" # --------------------------------------------------------------------------- @@ -250,9 +273,9 @@ 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 == "000001e4173182e5596f68ac3a1013caea1fc4aa3003ebc5c434bdab8db83c9173635d" + assert result == "0000027699b386e4e56ce34d2a38f748566a75c36c62ca8f5fa36180f0ea8809ac528c" def test_struct_with_list_child_schema(self): """Schema hash for struct with list child.""" @@ -262,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 == "000001310788c527cc1f9b997d616ada011d9c3790a22d17dcc4e4cf0f043539f4c0ed" + assert result == "00000231878b42f48260f2ba82a63298760afe8d214504d3b97a7019ff9a83eba48682" # --------------------------------------------------------------------------- @@ -290,9 +313,9 @@ 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 == "000001374a7e10ae3d1b9b46aa33f43988d5015290286e7236a3acbcd028462016e048" + assert result == "00000201b1aee1103d35dad74cda3c5a1c01e1aa5468beb02cc3cda5c1cb6c317f2d90" # --------------------------------------------------------------------------- @@ -325,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 == "0000010d5f9a58c3122935886c0de076b8a90400dc9a1b3885154c734ab4616c52b626" + assert result == "000002c1c713c7ee5c139a8799e83aff16049b6a6a935e3e3f8601e04db05c523e2d7b" def test_nullable_list_of_struct_hash_array(self): """Nullable LargeList via hash_array — row 1 is null. @@ -350,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 == "000001bb51997ac0fe67d4b08c5ced13b763c0ff5a532c9f9c8932fa2a4dd96fe57ea8" + assert result == "000002cd3cde5a0df63e3a6889556920e248890a882572450350a03da90f67f37e9f90" # --------------------------------------------------------------------------- @@ -371,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 == "00000150f18fb7ba1d34afe3f1b721a1ce10d1466dd55c228119449703ccf5ab771a5b" + assert result == "000002c60a39367e08f911e8d99db430267db89ca41e4cef6e87ac01520422354684a6" # --------------------------------------------------------------------------- @@ -404,7 +427,7 @@ def test_struct_mixed_types_hash_array(self): fields=struct_fields, ) result = ArrowDigester.hash_array(struct_arr).hex() - assert result == "0000019f925992104e467b68e68e7dfa64ac7d39c82b002cb8c06f1c5bec19156107a3" + assert result == "00000269c3b3a491ea942d3067cfdf07b67a35bd708e4ee05c45cc302190016ab4a9f7" # --------------------------------------------------------------------------- @@ -444,9 +467,9 @@ 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 == "00000128fd142d16920be401eb33abf71143977164eb8952a7da20ae6673a8d1d3707a" + assert result == "00000227eb7540623891a51b93eb1f133f461cd3231bc03f3d5f36957b452a477b912c" def test_mixed_struct_list_schema(self): """Schema hash for mixed struct + list batch.""" @@ -460,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 == "0000011eb0482c51f8fb95dfae3c5ae83253a1e695dcf546fe5a3b6d75df172c5c2a45" + assert result == "0000029f1118411cb35c292b7950a626469bd8cb987faa8c114d6509f09f32ec816cb8" # --------------------------------------------------------------------------- @@ -481,7 +504,7 @@ def test_empty_batch_complex_schema(self): ]) digester = ArrowDigester(schema) result = digester.finalize().hex() - assert result == "000001837b0cc525983aca21f8979b3c2ed7c77d22728fb3b9a56df6ed4aee540dfa83" + assert result == "000002a157d896c73e72632c68cabed99b8351ca116199217e209552f9bfaf70721cff" def test_empty_batch_complex_schema_hash(self): """Schema hash (hash_schema) for same complex schema.""" @@ -494,7 +517,7 @@ def test_empty_batch_complex_schema_hash(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "00000194e104ebfea3ba38467c883d05a71884f8a1d0eace1c0dcfb00ab2d1203aa654" + assert result == "00000286ebe427c00dea251c527cc286dc591efea4d6787cb3b40d3330a476b74f6d6c" # --------------------------------------------------------------------------- @@ -512,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()), @@ -520,7 +543,7 @@ def test_batch_all_null_column(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch).hex() - assert result == "000001266d1fd64c44cf1f18ccc395bd2c712459e43807095d78115ff78497cd7ec494" + assert result == "000002dca3ee7298f6495f2263e45eb2c876c9dc78f5b7462357f3be5f5d6579214e94" # --------------------------------------------------------------------------- @@ -536,7 +559,7 @@ def test_unicode_string_array(self): type=pa.large_utf8(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001d3f64ee0c7dac33e00445c2dd3edbb4b14cf61608682e4aae20d034dcaa3af40" + assert result == "0000029f656d188a338cc277592a06b5710796016037efc7fc7cb5746e65bfadd752b4" # --------------------------------------------------------------------------- @@ -558,7 +581,7 @@ def test_binary_varied_sizes(self): type=pa.binary(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "0000010213a24d1014bb90e20f339fccab30ca699f2ca916d190f9a7f50077f5734b05" + assert result == "0000020885790654a7ce21e6afdfeaa4ad99490e1871149892eda8acf4d2a403566410" # --------------------------------------------------------------------------- @@ -589,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 == "000001c3c2f4d6414b062973fa8277701f8e0689f7656405d03cd7fef1e1ef7c05ac25" + assert h1 == "0000025560faf3d3f3ce308ad2c7129f24f42589e7b25f0c6dc70ddd2aa45f7464111a" # --------------------------------------------------------------------------- @@ -628,7 +651,7 @@ def test_nested_nullable_inner_struct(self): fields=outer_fields, ) result = ArrowDigester.hash_array(outer).hex() - assert result == "000001d43e8fb43a96546aa158c8defdcf186e1f15e42cf12fb2439902374d320f503c" + assert result == "00000236f16a0a8179aefeb33f440a83a7d32aad8993c022796eab539de2e1d63521b8" # --------------------------------------------------------------------------- @@ -657,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 == "0000010843e52522d6435df07140b616e2cce64d55fc0dd4ee798a1f8dab86edf7bedc" + assert result == "000002215978d8171df62a17e8b85524418ac182dc2b1f2132ab95b8a99922dfc9c725" def test_list_of_list_batch(self): """Record batch with LargeList> column.""" @@ -675,9 +698,9 @@ 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 == "000001644acff58777778402bb96ee8aa5e8fac1b3ffe7c58fe3a27860d0e93581ed10" + assert result == "0000024354ac4eb6cef06e975af9b4a9f110e6baf409446897e122849553b159e6dc27" def test_list_of_list_schema(self): """Schema hash for list-of-list column.""" @@ -685,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 == "00000141016034ea375b62e02305da3756a08f63bdfa572a285858a15b1d6d0bb66330" + assert result == "0000023014336b70e541ea20913795de44594938a32b325f17b5f03ed6ebf09859a95a" # --------------------------------------------------------------------------- @@ -715,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 == "000001d4b6edc1304b0e981460aefa31813af93631c46558569a5ba8d5613cdbd722bd" + assert result == "000002a89c186dbf815b7192ed4ac574196d1e0203db10d53dd7d16fbe12fbbdbb651e" # --------------------------------------------------------------------------- @@ -737,7 +760,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 == "000002a6a3ef288f2975f6a75b0336b2b7d69ffb4a2d129046710b7184d1eb76a45fe2" # --------------------------------------------------------------------------- @@ -760,7 +783,7 @@ def test_schema_4_level_nested_struct(self): ]), nullable=False), ]) result = ArrowDigester.hash_schema(schema).hex() - assert result == "0000017e33cfc98b4338141e1d5dae0eef992e2c22ff89fbb9be054f7fae96f1b8577e" + assert result == "000002a07f8d13692700d7b2cad515d343a2a1ce4b3dd7deac50316102a43638b496d2" # --------------------------------------------------------------------------- @@ -798,9 +821,9 @@ 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 == "0000018a03ac4fd279a17240cb084cef23b1dbda814a60dba70f2147cb468f9c44af96" + assert result == "000002411fa81d41e904d832eceea8e2041fc96bda4e4dc58e72b76380e086d400a008" # --------------------------------------------------------------------------- @@ -820,7 +843,7 @@ def test_struct_empty_batch(self): ]) d = ArrowDigester(schema) result = d.finalize().hex() - assert result == "00000120a2341ffaf6b2413ebdb36aa062aec7c9468e946cbbba353b1ab5c5f6d1a773" + assert result == "000002aaafa89ee39b32668aeb6f65c56501061b7194257ea88f14c3be0eca314f1d0d" # --------------------------------------------------------------------------- @@ -846,19 +869,19 @@ 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) d.update(batch2) result = d.finalize().hex() - assert result == "000001d6b36c3858d63ed06e99de401b83e6255070da784f2d88c376b15e53bacbe86c" + assert result == "0000025d4b5b129c220a3171a616f1ff060a00fdb3647a34434f4d83e9d0a68502c334" # --------------------------------------------------------------------------- @@ -880,19 +903,19 @@ 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) d.update(batch2) result = d.finalize().hex() - assert result == "000001fcf529d339593cb8537af4c1ed7d02aae69cfbbd2608b02e811035edb6ba4ec3" + assert result == "00000248df16aca0c1f681b8b02cd0c859b3073c238101a6893bfa44d9f536a9819870" # --------------------------------------------------------------------------- @@ -940,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 == "0000012c2b1c1d5b4c3dc46ed5335834dbf0d7386c38e607a398a2897fdaf1df387e1c" + assert result == "0000023e818d98ed740fcd8240f4fdb39e4c53581b071c9ab6200a27924c186414f178" def test_non_nullable_inner_field(self): """LargeList with nullable=False item field. @@ -950,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 == "000001713fa0e500c9aebea61039b30371fd84c0dff8cd3b96b4266978658bf73e4d8c" + assert result == "0000021a7aa4df873b7627617a5ce9a234a8849202508afc27eda81af271d8b12bf592" def test_nullable_differs_from_non_nullable(self): """Nullable vs non-nullable inner field must produce different hashes.""" @@ -976,7 +999,7 @@ def test_float64_special_values(self): type=pa.float64(), ) result = ArrowDigester.hash_array(array).hex() - assert result == "000001947acf002083724864f155cf2857b1c9107749f6c8bfec13ea84c20fa9f20b5a" + assert result == "000002b8e0f66c036e26098ba55673ee856b1b23fb6dcb9acfb63207cf8ad6fadc34dd" # --------------------------------------------------------------------------- @@ -1019,9 +1042,9 @@ 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 == "0000010d6dda2bffa3477ea97d880b38e018f8ae083e3059db77876b48e9a14a8f17ac" + assert result == "000002e86fcf5b5a6b21b9f3f4a5f3eb6608c6e531ecabd95cbf365d01089d2a924619" def test_realistic_schema(self): """Schema hash for realistic batch.""" @@ -1035,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 == "0000011c85d47bb95c90c6aa05b8ab930cfbb369136fffd8e120cee5d94dd84ed3c356" + assert result == "000002b4caaae1356e990fdb4b8ed43bf8f67bcdc3ee2f094da6e0f71575dc52ec31c9" 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..b1fc225 --- /dev/null +++ b/tests/test_legacy_v0_4_frozen.py @@ -0,0 +1,74 @@ +"""[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 = "d7641a8e64b08d3f2698fbc0e461a0cf495cf1c6dc552a9798f9e1343160bb91" + + +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 _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(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): + 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 + + +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 + + +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 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_golden_parity_metadata.py b/tests/test_legacy_v0_4_golden_parity_metadata.py similarity index 94% rename from tests/test_golden_parity_metadata.py rename to tests/test_legacy_v0_4_golden_parity_metadata.py index 008a1d9..4c34d55 100644 --- a/tests/test_golden_parity_metadata.py +++ b/tests/test_legacy_v0_4_golden_parity_metadata.py @@ -1,4 +1,7 @@ -"""Cross-language golden-hash parity tests for include_metadata vectors (PLT-1735). +"""[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 @@ -27,7 +30,7 @@ import pyarrow as pa import pytest -from starfix.arrow_digester import ArrowDigester +from starfix.legacy.v0_4 import ArrowDigester _FIXTURE_PATH = Path(__file__).parent / "golden" / "include_metadata_v0.3.json" 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..5e0809b --- /dev/null +++ b/tests/test_legacy_v0_4_golden_parity_r2.py @@ -0,0 +1,1065 @@ +"""[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. + +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) + ) diff --git a/tests/test_metadata_hashing.py b/tests/test_metadata_hashing.py index 8383fe8..070e21d 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"}), @@ -208,7 +127,7 @@ def test_default_matches_hash_format_001_golden_value(self): schema=schema, ) result = ArrowDigester.hash_record_batch(batch, include_metadata=False).hex() - assert result == "0000018020e47f4462f26b0bc73ad110ea0f9198c2745c04ce23335093d2b78ef51c88" + assert result == "000002d3ab7e2b2ff00fc12767f712e8e3f1e941d4616af2d44b3a5ded0675afd31207" class TestSchemaMetadataChangesHash: