deepdiff-rs 0.12.0__tar.gz → 0.13.0__tar.gz

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/Cargo.lock

@@ -629,7 +629,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "onix-arrow"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -648,7 +648,7 @@ dependencies = [
 
 [[package]]
 name = "onix-cli"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "onix-core",
  "serde_json",
@@ -656,7 +656,7 @@ dependencies = [
 
 [[package]]
 name = "onix-core"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "onix-py"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "arrow-array",
  "arrow-schema",

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/onix-core", "crates/onix-py", "crates/onix-arrow"]
 
 [workspace.package]
-version = "0.12.0"
+version = "0.13.0"
 edition = "2024"
 license = "MIT"
 

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rs
-Version: 0.12.0
+Version: 0.13.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -210,7 +210,7 @@ The engine's own diff-only time and peak resident memory against pinned `deepdif
 | `ignore_order_10k` | 73.475 ms (71.672 ms-73.940 ms) | 12.976 s (12.900 s-13.005 s) | 176.60x | 60.11 MB | 345.19 MB | 5.74x | ✅ |
 | `identical_1m` | 9.254 ms (6.726 ms-9.875 ms) | 15.790 s (15.660 s-15.989 s) | 1706.35x | 315.41 MB | 503.19 MB | 1.60x | ✅ |
 
-Both reports carry their full methodology, fairness rules, and the reproduce command. `perf/RESULTS.md` is an upper bound (JSON parsed straight into the engine, no Python-object conversion); the bindings table is the product-surface number. Regenerate them with `perf/run_bench.sh` and `crates/onix-py/benchmarks/bench_bindings.py` (see [CONTRIBUTING.md](CONTRIBUTING.md)). The Arrow table diff's cost against two hand-rolled baselines — a DuckDB SQL join and a polars anti-join/inner-join diff, on two seeded ~5 GB parquet pairs and their own 1M-row subsets (a five-column narrow fixture, and a wide fixture covering every scalar Arrow type) — is in [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md): the row diff now hashes and classifies across every core, so at the 5 GB size its wall time is a small multiple of the two parallelized baselines' for the narrow fixture (down from the several-fold single-threaded gap); the wide fixture, where nearly every row's 34 columns are compared and rendered, now spills each side's changed rows by key-hash partition and renders them across every core, cutting its 5 GB-per-side wall time 6.14x (149.674 -> 24.375 s; about 3.8x DuckDB and 6.2x polars) and its peak RSS 2.02x (about 67 GB -> 33.1 GB), see the linked results for both; regenerated with `perf/arrow/bench_tables.py`.
+Both reports carry their full methodology, fairness rules, and the reproduce command. `perf/RESULTS.md` is an upper bound (JSON parsed straight into the engine, no Python-object conversion); the bindings table is the product-surface number. Regenerate them with `perf/run_bench.sh` and `crates/onix-py/benchmarks/bench_bindings.py` (see [CONTRIBUTING.md](CONTRIBUTING.md)). The Arrow table diff's cost against two hand-rolled baselines — a DuckDB SQL join and a polars anti-join/inner-join diff, on two seeded ~5 GB parquet pairs and their own 1M-row subsets (a five-column narrow fixture, and a wide fixture covering every scalar Arrow type) — is in [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md): the row diff now hashes and classifies across every core, so at the 5 GB size its wall time is a small multiple of the two parallelized baselines' for the narrow fixture (down from the several-fold single-threaded gap); the wide fixture, where nearly every row's 34 columns are compared and rendered, spills each side's changed rows by key-hash partition and renders them across every core, which took its 5 GB-per-side wall from 149.674 to 24.375 s and its peak RSS from about 67 GB to 33.1 GB; and since 0.13.0 the parallel diff decodes the right input once and the left twice instead of each three times, taking the 5 GB pairs from 5.727 to 3.879 s narrow (1.71x DuckDB, 1.93x polars) and from 21.294 to 14.968 s wide (2.90x DuckDB, 5.47x polars) in a rotated, interleaved run, with the wide pair's peak RSS down from 33.2 GB to 28.8 GB; see the linked results for both; regenerated with `perf/arrow/bench_tables.py`.
 
 ## Reference
 
@@ -243,6 +243,7 @@ crates/onix-core   # the diff engine (library, no I/O)
 crates/onix-cli    # the `onix` binary (thin CLI over the core)
 crates/onix-arrow  # Arrow table diffing (schema diff and keyed row diff)
 crates/onix-py     # PyO3 bindings, published as `deepdiff-rs`
+docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget)
 scripts/           # gen_goldens.py: regenerates tests/golden/ from real DeepDiff
 tests/golden       # DeepDiff-generated expected outputs (the compatibility corpus)
 perf/              # cross-language benchmark harness and RESULTS.md
@@ -260,17 +261,17 @@ perf/              # cross-language benchmark harness and RESULTS.md
 - A `str` (or `dict` key) containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) is compared and reported exactly like any other `str`, matching DeepDiff's plain `==`; `to_json()` renders it with `json.dumps`'s own single-backslash `\uXXXX` escape. The one accepted divergence, always deterministic: hashing one — a `set`/`frozenset` member, or *any* value at all once `ignore_order=True` (`DeepHash` hashes every value there, not just a set's members) — crashes real DeepDiff with an unhandled `UnicodeEncodeError`, where onix hashes by code point and reports normally. See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is escaped exactly as Python's `repr()` escapes it, against Unicode 16.0.0; on a Python older than 3.14 (an older `unicodedata` table), a code point assigned to Unicode after that Python's own version is escaped by DeepDiff and rendered literally by onix. See [`tests/golden/README.md`](tests/golden/README.md)'s "Pinned versions" section.
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).
-- `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).
+- `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth (about 7.5 s and 146 MB at depth 400 on a few-KB input, growing roughly cubically with depth, all under the default `max_depth`); it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`docs/design/ignore-order.md`](docs/design/ignore-order.md)'s "Bounds" section.
 - A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).
 - Ordered sequences (`list` or `tuple`) of scalars (null, bool, number, string, datetime, date, time, timedelta) run a `difflib`-style `O(N*M)` matcher on the default path with its popular-element (autojunk) purge disabled for `DeepDiff` parity, worst for sequences of a few repeated values with dense edits (about 620 s for two 8,000-element lists of two repeated values with every other element changed, growing faster than quadratically), so bound the size of untrusted sequences yourself. See [`crates/onix-core/src/lcs.rs`](crates/onix-core/src/lcs.rs).
 - `diff_tables` inherits some Arrow-interchange quirks: a column name with an embedded NUL byte (`\0`) arrives truncated at the NUL through the C Data Interface (the report shows the truncated name; rare in practice); a list of structs named exactly `key`/`value` with a nullable key is not distinguished from a real map, so a migration between the two is not reported as a type change (polars exports both as the same Arrow type — see `map_entries` in [`crates/onix-arrow/src/schema.rs`](crates/onix-arrow/src/schema.rs)); and a polars all-null (`Null`-typed) column fails at Arrow C import with a `ValueError` (`the datatype "Null" doesn't expect buffer at index 0`), so give such a column a concrete type first (a pyarrow all-`None` column, inferred as `null`, works and compares as all-null).
 - In `diff_tables`, DuckDB labels a `TIMESTAMP WITH TIME ZONE` column with the connection's *session* time zone when it exports to Arrow (a UTC session as `Timestamp(µs, "UTC")`, an `America/New_York` session as `Timestamp(µs, "America/New_York")`), so on a non-UTC machine such a column can be reported as a type change against a UTC column from another library. Run `SET TimeZone='UTC'` on the DuckDB connection first for a deterministic, machine-independent result.
 - `diff_tables` refuses a column whose Arrow type is nested deeper than `MAX_NESTING_DEPTH` (128) with a `MaxDepthError`, because comparing arbitrarily deep nesting would overflow the native stack; 128 is far beyond any real schema. Importing a schema nested many thousands of levels deep is also slow regardless, a cost of the Arrow C Data Interface itself.
-- `diff_tables` row diff: per-row hash (32 B/row/side): 75 MB at 1M, 660 MB at 10M, linear in row count; wall time `N·log N` across workers. Parallel overhead ~10-15 B/row/side: 629/857 MB at 8M (1/18 threads), 2.9/3.6 GB at 37M; `threads=1` sequential. Duplicate-key report (every distinct duplicated key): 37 MB (16 B keys) to 1.05 GB (1 KB keys) at 200k (100k distinct), 165 MB at 1M (500k distinct, 16 B keys). Cell-pass resident (spilled rows-x-column-width, both sides + 2x `cells_changed` output + hash vectors) at 18 threads: 0.92/1.31/4.81 GB at 100k/200k/1M output-dominated (single-threaded 8.30 GB); eight 512 B columns, one differing (150k changed cells, ~160 MB output): 2.09 GB at 150k spill-dominated vs 0.84 GB one column; 0.38 GB at 1M two int64.
-- Temp disk, same call: each input is spooled to an anonymous file (`tempfile`: unlinked at once, mode 0600, no name, nothing left on abnormal exit). The cell pass spills both sides' changed rows to anonymous per-partition files: byte-view columns cast to a large-offset type (buffers can exceed i32's ~2 GB), dictionaries decoded to value type, keeping the spill compact, independent of partition count (~97 GB at 64 threads undecoded vs ~34 GB decoded, wide pair). Spool and spill resident together, whole-process peaks (34-column fixture, 16.875M rows/side): ~33 GB at 18 threads, 45 GB at 2, 34 GB at 64, down from ~67 GB pre-streaming (Linux spill may be a RAM-backed `tmpfs`). A full temp filesystem raises `ValueError` naming `TMPDIR`.
-- The size gate peeks up to 50,000 rows or 64 MB decoded per side, holding one whole producer batch per side beyond it: a 49,999-row/side, 8 KB-cell, 100-row-batch pair peaks ~78 MB at 18 threads, 14 MB single-threaded, ~1.6 GB for one whole-side batch.
-- None of the row-diff memory, temp-disk or size-gate-peek costs above has a built-in cap. Bound: row count; changed fraction; column widths (key-column width, for duplicate-heavy data; for the cell pass, the total width of all common value columns, since every one spills in full per changed row whether it changed or not, plus the rendered changed cells; any column's width for the size-gate peek, which buffers decoded cells whether or not they change); the producer's batch size; thread count, lowest at 18 threads (measured default), higher at 2 threads (two partitions each holding half the rows), slightly higher at 64: spill-dominated 3.03 GB at 2 threads, 2.09 GB at 64; output-dominated at 200k rows, 1.98 GB at 2, 1.49 GB at 64.
-- Figures are the peak resident set of `cargo run -p onix-arrow --release --example row_diff_rss` (worker count from `ROW_DIFF_THREADS`, rows per batch from `ROW_DIFF_BATCH`), single run, macOS on an Apple M-series laptop, 2026-09-06, same method as [Performance](#performance); the single-threaded hash-term figures carry run-to-run slack up to 2.9-4.2 GB at 37M rows/side, and the two spill/output cell-pass shapes are medians over 5 runs. See [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md) for the size-gate peek table and the decode-vs-undecoded partition figures, and [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs) for the implementation.
+- `diff_tables` row diff: 32 B hash per row per side (left only in parallel): 75 MB at 1M, 660 MB at 10M (single-threaded); 600/618 MB at 8M, 2.7/2.5 GB at 37M (1/18 threads); wall time `N·log N` across workers. Duplicate-key report, 18 threads: 39 MB (16 B keys) to 0.83 GB (1 KB keys) at 200k. Cell pass (both sides' spilled rows × column width, plus 2x `cells_changed`), 18 threads: 0.96/4.62 GB at 200k/1M, 1.56 GB spill-dominated (150k rows, eight 512 B columns, one differing). Right-side duplicate keys, 18 threads: +0.95 GB per 500k repeated keys (2 KB of value columns, 1M rows/side); +85 MB per 1M keys the left lacks (8 B `int64` keys; the entry is 32 B at any key width). Kept rows pin their input batch, per side: the whole batch when over half is kept, its view data otherwise (~2.0 GB, 1 and 18 threads, for 100 removed rows over a 1M-row side with two 1 KB `Utf8View` columns). [RESULTS.md, Fused reads](perf/arrow/RESULTS.md#fused-reads-issue-90-1).
+- Temp disk, same call: each input spools to an anonymous file (`tempfile`: unlinked, mode 0600, no name). Changed rows spill to anonymous per-partition files, byte-view columns cast to a large-offset type (i32 caps at ~2 GB) and dictionaries decoded, independent of the partition count (~97 GB at 64 threads undecoded vs ~32 GB, wide pair); in parallel also one row per right key the left holds once that a later batch repeats (1.03 GB per 500k such keys, 2 KB of value columns, 1M rows/side, 2 and 64 threads). All resident until the cell pass ends: ~23.8 GB, wide pair (2/18/64 threads; Linux spill may be a RAM-backed `tmpfs`). Whole-process peaks, wide pair: ~29 GB at 18 threads, 40 GB at 2, 31 GB at 64 (33/46/34 GB on 0.11.2). A full temp filesystem raises `ValueError` naming `TMPDIR`.
+- The size gate peeks up to 50,000 rows or 64 MB decoded per side, holding one whole producer batch per side beyond it: a 49,999-row/side, 8 KB-cell, 100-row-batch pair peaks ~65 MB at 18 threads, 12 MB single-threaded, ~1.6 GB single-threaded (1.2 GB at 18 threads) for one whole-side batch.
+- None of the row-diff memory, temp-disk or size-gate-peek costs above has a built-in cap. Bound: row count; changed fraction; right-side duplicate keys (on the parallel path, one full-width row per repeated key, spilled or held); column widths (key-column width, for duplicate-heavy data; for the cell pass, the total width of all common value columns, since every one spills in full per changed row whether it changed or not, plus the rendered changed cells; any column's width for the size-gate peek, which buffers decoded cells whether or not they change); the producer's batch size; thread count, lowest at 18 threads (measured default), higher at 2 threads (two partitions each holding half the rows), slightly higher at 64: spill-dominated 2.39 GB at 2 threads, 1.96 GB at 64; output-dominated at 200k rows, 1.45 GB at 2, 1.25 GB at 64.
+- Figures are the peak resident set of `cargo run -p onix-arrow --release --example row_diff_rss` (worker count from `ROW_DIFF_THREADS`, rows per batch from `ROW_DIFF_BATCH`), macOS on an Apple M-series laptop, 2026-09-24, same method as [Performance](#performance); the single-threaded hash-term figures carry run-to-run slack up to 2.7-3.8 GB at 37M rows/side, the other cell-pass and thread-count figures are medians over 3 runs, and the two 150k spill/output shapes over 5. See [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md) for the size-gate peek table and the decode-vs-undecoded partition figures, and [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs) for the implementation.
 - `TableDiff.to_json()` is the one member with a built-in cap: it embeds `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` in full, one JSON object per row, so it refuses with `ValueError` — naming the row count and the cap — once those four together hold more than 10,000 rows. The cap bounds row count only, the same way the first row-diff bullet above states its per-cell term as changed cells times cell width, not column count or cell width — so a table under the row cap but with wide or large cells can still be large; use the Arrow-returning accessors instead. See [`crates/onix-arrow/src/json_rows.rs`](crates/onix-arrow/src/json_rows.rs).
 - `diff_tables` compares scalar columns by value (hashed: null, booleans, every integer, float and decimal width, strings and binary in every encoding, timestamps, dates, times, durations, intervals, and dictionaries of these; refused with `ValueError`: run-end encoded columns and any type-and-unit combination Arrow itself cannot build; nested non-key columns skipped, nested key columns refused), with the exact enumeration in the module doc of [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs). It also refuses a key column whose type differs across the two inputs after encoding normalization (the conservative choice: a primary key that changed type is refused rather than guessed, not coerced). A row whose only difference is a lossless type change — an `Int32` widened to `Int64`, a timestamp unit change at the same instant — hashes equal on both sides, so it is in neither `rows_changed` nor `cells_changed`; the column's type change is still reported in `schema`.
 - Output is byte-identical to DeepDiff except for the cases listed above and two path-rendering quirks; [`tests/golden/README.md`](tests/golden/README.md) enumerates every accepted exception, including integers past `2^53` (the limit of exact `f64` representation) inside ordered scalar lists and `ignore_order` pairing among naive datetimes, which DeepDiff ranks using the *process's local timezone* while onix reads a naive value as UTC everywhere.

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/README.md

@@ -192,7 +192,7 @@ The engine's own diff-only time and peak resident memory against pinned `deepdif
 | `ignore_order_10k` | 73.475 ms (71.672 ms-73.940 ms) | 12.976 s (12.900 s-13.005 s) | 176.60x | 60.11 MB | 345.19 MB | 5.74x | ✅ |
 | `identical_1m` | 9.254 ms (6.726 ms-9.875 ms) | 15.790 s (15.660 s-15.989 s) | 1706.35x | 315.41 MB | 503.19 MB | 1.60x | ✅ |
 
-Both reports carry their full methodology, fairness rules, and the reproduce command. `perf/RESULTS.md` is an upper bound (JSON parsed straight into the engine, no Python-object conversion); the bindings table is the product-surface number. Regenerate them with `perf/run_bench.sh` and `crates/onix-py/benchmarks/bench_bindings.py` (see [CONTRIBUTING.md](CONTRIBUTING.md)). The Arrow table diff's cost against two hand-rolled baselines — a DuckDB SQL join and a polars anti-join/inner-join diff, on two seeded ~5 GB parquet pairs and their own 1M-row subsets (a five-column narrow fixture, and a wide fixture covering every scalar Arrow type) — is in [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md): the row diff now hashes and classifies across every core, so at the 5 GB size its wall time is a small multiple of the two parallelized baselines' for the narrow fixture (down from the several-fold single-threaded gap); the wide fixture, where nearly every row's 34 columns are compared and rendered, now spills each side's changed rows by key-hash partition and renders them across every core, cutting its 5 GB-per-side wall time 6.14x (149.674 -> 24.375 s; about 3.8x DuckDB and 6.2x polars) and its peak RSS 2.02x (about 67 GB -> 33.1 GB), see the linked results for both; regenerated with `perf/arrow/bench_tables.py`.
+Both reports carry their full methodology, fairness rules, and the reproduce command. `perf/RESULTS.md` is an upper bound (JSON parsed straight into the engine, no Python-object conversion); the bindings table is the product-surface number. Regenerate them with `perf/run_bench.sh` and `crates/onix-py/benchmarks/bench_bindings.py` (see [CONTRIBUTING.md](CONTRIBUTING.md)). The Arrow table diff's cost against two hand-rolled baselines — a DuckDB SQL join and a polars anti-join/inner-join diff, on two seeded ~5 GB parquet pairs and their own 1M-row subsets (a five-column narrow fixture, and a wide fixture covering every scalar Arrow type) — is in [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md): the row diff now hashes and classifies across every core, so at the 5 GB size its wall time is a small multiple of the two parallelized baselines' for the narrow fixture (down from the several-fold single-threaded gap); the wide fixture, where nearly every row's 34 columns are compared and rendered, spills each side's changed rows by key-hash partition and renders them across every core, which took its 5 GB-per-side wall from 149.674 to 24.375 s and its peak RSS from about 67 GB to 33.1 GB; and since 0.13.0 the parallel diff decodes the right input once and the left twice instead of each three times, taking the 5 GB pairs from 5.727 to 3.879 s narrow (1.71x DuckDB, 1.93x polars) and from 21.294 to 14.968 s wide (2.90x DuckDB, 5.47x polars) in a rotated, interleaved run, with the wide pair's peak RSS down from 33.2 GB to 28.8 GB; see the linked results for both; regenerated with `perf/arrow/bench_tables.py`.
 
 ## Reference
 
@@ -225,6 +225,7 @@ crates/onix-core   # the diff engine (library, no I/O)
 crates/onix-cli    # the `onix` binary (thin CLI over the core)
 crates/onix-arrow  # Arrow table diffing (schema diff and keyed row diff)
 crates/onix-py     # PyO3 bindings, published as `deepdiff-rs`
+docs/design/       # algorithm/invariant reference pages (list-diff, ignore-order, value-model, depth-budget)
 scripts/           # gen_goldens.py: regenerates tests/golden/ from real DeepDiff
 tests/golden       # DeepDiff-generated expected outputs (the compatibility corpus)
 perf/              # cross-language benchmark harness and RESULTS.md
@@ -242,17 +243,17 @@ perf/              # cross-language benchmark harness and RESULTS.md
 - A `str` (or `dict` key) containing a lone (unpaired) surrogate code point (e.g. `'\udc80'`, legal in Python but not encodable as UTF-8) is compared and reported exactly like any other `str`, matching DeepDiff's plain `==`; `to_json()` renders it with `json.dumps`'s own single-backslash `\uXXXX` escape. The one accepted divergence, always deterministic: hashing one — a `set`/`frozenset` member, or *any* value at all once `ignore_order=True` (`DeepHash` hashes every value there, not just a set's members) — crashes real DeepDiff with an unhandled `UnicodeEncodeError`, where onix hashes by code point and reports normally. See [`tests/golden/README.md`](tests/golden/README.md)'s "Known DeepDiff quirks" section.
 - A `str` inside a `tuple` or `frozenset` set item is escaped exactly as Python's `repr()` escapes it, against Unicode 16.0.0; on a Python older than 3.14 (an older `unicodedata` table), a code point assigned to Unicode after that Python's own version is escaped by DeepDiff and rendered literally by onix. See [`tests/golden/README.md`](tests/golden/README.md)'s "Pinned versions" section.
 - Adversarially deep input raises `MaxDepthError` instead of crashing: the default `max_depth` is 512 and the hard ceiling is `MAX_DEPTH_CEILING` (20,000). See [`crates/onix-py/src/guard.rs`](crates/onix-py/src/guard.rs).
-- `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth; it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`crates/onix-core/src/ignore_order/mod.rs`](crates/onix-core/src/ignore_order/mod.rs).
+- `ignore_order` pairing is `O(N^2)` in unpaired elements per side and carries a polynomial cost in both time and memory with input depth (about 7.5 s and 146 MB at depth 400 on a few-KB input, growing roughly cubically with depth, all under the default `max_depth`); it has no `max_passes`/`max_diffs` cutoff, so bound the size and depth of untrusted input yourself. See [`docs/design/ignore-order.md`](docs/design/ignore-order.md)'s "Bounds" section.
 - A `values_changed` between two multi-line strings runs a `difflib`-style `O(N*M)` line diff on the default path with no opt-out, worst when changes are spread evenly through the text (about 35 s for a heavily edited 1 MB string and growing quadratically, so a few megabytes is minutes), so bound the size of untrusted strings yourself. See [`crates/onix-core/src/unified_diff.rs`](crates/onix-core/src/unified_diff.rs).
 - Ordered sequences (`list` or `tuple`) of scalars (null, bool, number, string, datetime, date, time, timedelta) run a `difflib`-style `O(N*M)` matcher on the default path with its popular-element (autojunk) purge disabled for `DeepDiff` parity, worst for sequences of a few repeated values with dense edits (about 620 s for two 8,000-element lists of two repeated values with every other element changed, growing faster than quadratically), so bound the size of untrusted sequences yourself. See [`crates/onix-core/src/lcs.rs`](crates/onix-core/src/lcs.rs).
 - `diff_tables` inherits some Arrow-interchange quirks: a column name with an embedded NUL byte (`\0`) arrives truncated at the NUL through the C Data Interface (the report shows the truncated name; rare in practice); a list of structs named exactly `key`/`value` with a nullable key is not distinguished from a real map, so a migration between the two is not reported as a type change (polars exports both as the same Arrow type — see `map_entries` in [`crates/onix-arrow/src/schema.rs`](crates/onix-arrow/src/schema.rs)); and a polars all-null (`Null`-typed) column fails at Arrow C import with a `ValueError` (`the datatype "Null" doesn't expect buffer at index 0`), so give such a column a concrete type first (a pyarrow all-`None` column, inferred as `null`, works and compares as all-null).
 - In `diff_tables`, DuckDB labels a `TIMESTAMP WITH TIME ZONE` column with the connection's *session* time zone when it exports to Arrow (a UTC session as `Timestamp(µs, "UTC")`, an `America/New_York` session as `Timestamp(µs, "America/New_York")`), so on a non-UTC machine such a column can be reported as a type change against a UTC column from another library. Run `SET TimeZone='UTC'` on the DuckDB connection first for a deterministic, machine-independent result.
 - `diff_tables` refuses a column whose Arrow type is nested deeper than `MAX_NESTING_DEPTH` (128) with a `MaxDepthError`, because comparing arbitrarily deep nesting would overflow the native stack; 128 is far beyond any real schema. Importing a schema nested many thousands of levels deep is also slow regardless, a cost of the Arrow C Data Interface itself.
-- `diff_tables` row diff: per-row hash (32 B/row/side): 75 MB at 1M, 660 MB at 10M, linear in row count; wall time `N·log N` across workers. Parallel overhead ~10-15 B/row/side: 629/857 MB at 8M (1/18 threads), 2.9/3.6 GB at 37M; `threads=1` sequential. Duplicate-key report (every distinct duplicated key): 37 MB (16 B keys) to 1.05 GB (1 KB keys) at 200k (100k distinct), 165 MB at 1M (500k distinct, 16 B keys). Cell-pass resident (spilled rows-x-column-width, both sides + 2x `cells_changed` output + hash vectors) at 18 threads: 0.92/1.31/4.81 GB at 100k/200k/1M output-dominated (single-threaded 8.30 GB); eight 512 B columns, one differing (150k changed cells, ~160 MB output): 2.09 GB at 150k spill-dominated vs 0.84 GB one column; 0.38 GB at 1M two int64.
-- Temp disk, same call: each input is spooled to an anonymous file (`tempfile`: unlinked at once, mode 0600, no name, nothing left on abnormal exit). The cell pass spills both sides' changed rows to anonymous per-partition files: byte-view columns cast to a large-offset type (buffers can exceed i32's ~2 GB), dictionaries decoded to value type, keeping the spill compact, independent of partition count (~97 GB at 64 threads undecoded vs ~34 GB decoded, wide pair). Spool and spill resident together, whole-process peaks (34-column fixture, 16.875M rows/side): ~33 GB at 18 threads, 45 GB at 2, 34 GB at 64, down from ~67 GB pre-streaming (Linux spill may be a RAM-backed `tmpfs`). A full temp filesystem raises `ValueError` naming `TMPDIR`.
-- The size gate peeks up to 50,000 rows or 64 MB decoded per side, holding one whole producer batch per side beyond it: a 49,999-row/side, 8 KB-cell, 100-row-batch pair peaks ~78 MB at 18 threads, 14 MB single-threaded, ~1.6 GB for one whole-side batch.
-- None of the row-diff memory, temp-disk or size-gate-peek costs above has a built-in cap. Bound: row count; changed fraction; column widths (key-column width, for duplicate-heavy data; for the cell pass, the total width of all common value columns, since every one spills in full per changed row whether it changed or not, plus the rendered changed cells; any column's width for the size-gate peek, which buffers decoded cells whether or not they change); the producer's batch size; thread count, lowest at 18 threads (measured default), higher at 2 threads (two partitions each holding half the rows), slightly higher at 64: spill-dominated 3.03 GB at 2 threads, 2.09 GB at 64; output-dominated at 200k rows, 1.98 GB at 2, 1.49 GB at 64.
-- Figures are the peak resident set of `cargo run -p onix-arrow --release --example row_diff_rss` (worker count from `ROW_DIFF_THREADS`, rows per batch from `ROW_DIFF_BATCH`), single run, macOS on an Apple M-series laptop, 2026-09-06, same method as [Performance](#performance); the single-threaded hash-term figures carry run-to-run slack up to 2.9-4.2 GB at 37M rows/side, and the two spill/output cell-pass shapes are medians over 5 runs. See [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md) for the size-gate peek table and the decode-vs-undecoded partition figures, and [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs) for the implementation.
+- `diff_tables` row diff: 32 B hash per row per side (left only in parallel): 75 MB at 1M, 660 MB at 10M (single-threaded); 600/618 MB at 8M, 2.7/2.5 GB at 37M (1/18 threads); wall time `N·log N` across workers. Duplicate-key report, 18 threads: 39 MB (16 B keys) to 0.83 GB (1 KB keys) at 200k. Cell pass (both sides' spilled rows × column width, plus 2x `cells_changed`), 18 threads: 0.96/4.62 GB at 200k/1M, 1.56 GB spill-dominated (150k rows, eight 512 B columns, one differing). Right-side duplicate keys, 18 threads: +0.95 GB per 500k repeated keys (2 KB of value columns, 1M rows/side); +85 MB per 1M keys the left lacks (8 B `int64` keys; the entry is 32 B at any key width). Kept rows pin their input batch, per side: the whole batch when over half is kept, its view data otherwise (~2.0 GB, 1 and 18 threads, for 100 removed rows over a 1M-row side with two 1 KB `Utf8View` columns). [RESULTS.md, Fused reads](perf/arrow/RESULTS.md#fused-reads-issue-90-1).
+- Temp disk, same call: each input spools to an anonymous file (`tempfile`: unlinked, mode 0600, no name). Changed rows spill to anonymous per-partition files, byte-view columns cast to a large-offset type (i32 caps at ~2 GB) and dictionaries decoded, independent of the partition count (~97 GB at 64 threads undecoded vs ~32 GB, wide pair); in parallel also one row per right key the left holds once that a later batch repeats (1.03 GB per 500k such keys, 2 KB of value columns, 1M rows/side, 2 and 64 threads). All resident until the cell pass ends: ~23.8 GB, wide pair (2/18/64 threads; Linux spill may be a RAM-backed `tmpfs`). Whole-process peaks, wide pair: ~29 GB at 18 threads, 40 GB at 2, 31 GB at 64 (33/46/34 GB on 0.11.2). A full temp filesystem raises `ValueError` naming `TMPDIR`.
+- The size gate peeks up to 50,000 rows or 64 MB decoded per side, holding one whole producer batch per side beyond it: a 49,999-row/side, 8 KB-cell, 100-row-batch pair peaks ~65 MB at 18 threads, 12 MB single-threaded, ~1.6 GB single-threaded (1.2 GB at 18 threads) for one whole-side batch.
+- None of the row-diff memory, temp-disk or size-gate-peek costs above has a built-in cap. Bound: row count; changed fraction; right-side duplicate keys (on the parallel path, one full-width row per repeated key, spilled or held); column widths (key-column width, for duplicate-heavy data; for the cell pass, the total width of all common value columns, since every one spills in full per changed row whether it changed or not, plus the rendered changed cells; any column's width for the size-gate peek, which buffers decoded cells whether or not they change); the producer's batch size; thread count, lowest at 18 threads (measured default), higher at 2 threads (two partitions each holding half the rows), slightly higher at 64: spill-dominated 2.39 GB at 2 threads, 1.96 GB at 64; output-dominated at 200k rows, 1.45 GB at 2, 1.25 GB at 64.
+- Figures are the peak resident set of `cargo run -p onix-arrow --release --example row_diff_rss` (worker count from `ROW_DIFF_THREADS`, rows per batch from `ROW_DIFF_BATCH`), macOS on an Apple M-series laptop, 2026-09-24, same method as [Performance](#performance); the single-threaded hash-term figures carry run-to-run slack up to 2.7-3.8 GB at 37M rows/side, the other cell-pass and thread-count figures are medians over 3 runs, and the two 150k spill/output shapes over 5. See [`perf/arrow/RESULTS.md`](perf/arrow/RESULTS.md) for the size-gate peek table and the decode-vs-undecoded partition figures, and [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs) for the implementation.
 - `TableDiff.to_json()` is the one member with a built-in cap: it embeds `rows_added`, `rows_removed`, `cells_changed`, and `duplicate_keys` in full, one JSON object per row, so it refuses with `ValueError` — naming the row count and the cap — once those four together hold more than 10,000 rows. The cap bounds row count only, the same way the first row-diff bullet above states its per-cell term as changed cells times cell width, not column count or cell width — so a table under the row cap but with wide or large cells can still be large; use the Arrow-returning accessors instead. See [`crates/onix-arrow/src/json_rows.rs`](crates/onix-arrow/src/json_rows.rs).
 - `diff_tables` compares scalar columns by value (hashed: null, booleans, every integer, float and decimal width, strings and binary in every encoding, timestamps, dates, times, durations, intervals, and dictionaries of these; refused with `ValueError`: run-end encoded columns and any type-and-unit combination Arrow itself cannot build; nested non-key columns skipped, nested key columns refused), with the exact enumeration in the module doc of [`crates/onix-arrow/src/row_diff.rs`](crates/onix-arrow/src/row_diff.rs). It also refuses a key column whose type differs across the two inputs after encoding normalization (the conservative choice: a primary key that changed type is refused rather than guessed, not coerced). A row whose only difference is a lossless type change — an `Int32` widened to `Int64`, a timestamp unit change at the same instant — hashes equal on both sides, so it is in neither `rows_changed` nor `cells_changed`; the column's type change is still reported in `schema`.
 - Output is byte-identical to DeepDiff except for the cases listed above and two path-rendering quirks; [`tests/golden/README.md`](tests/golden/README.md) enumerates every accepted exception, including integers past `2^53` (the limit of exact `f64` representation) inside ordered scalar lists and `ignore_order` pairing among naive datetimes, which DeepDiff ranks using the *process's local timezone* while onix reads a naive value as UTC everywhere.

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/crates/onix-arrow/examples/row_diff_profile.rs

@@ -9,7 +9,7 @@
 //! over that net wall. Peak RSS is the process's, third diff in the process.
 //!
 //! - **file**: reads each side from an uncompressed Arrow IPC file, re-opened
-//!   and re-decoded by every pass. Convert a parquet fixture once with
+//!   by each pass that reads it. Convert a parquet fixture once with
 //!   `python -c "import pyarrow.parquet as p, pyarrow.feather as f;
 //!   f.write_feather(p.read_table('a.parquet'), 'a.arrow', compression='uncompressed')"`.
 //! - **generated**: spools both sides of a deterministic proxy shape to anonymous

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/crates/onix-arrow/examples/row_diff_rss.rs

@@ -18,6 +18,19 @@
 //! /usr/bin/time -l target/release/examples/row_diff_rss 200000 wide 1024
 //! # wide rows, few changed cells: id + 8 512-byte columns, only one differing
 //! ROW_DIFF_THREADS=18 /usr/bin/time -l target/release/examples/row_diff_rss 150000 manycols 8 512
+//! # two 1 KB `Utf8View` columns: every row removed, every row added, every
+//! # 10,000th row removed; the right repeating left keys, repeating keys the
+//! # left lacks, and repeating one key the left lacks once per 10,000 rows
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 viewremoved 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 viewadded 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 viewaddedbyvalue 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 viewaddedrepeat 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 viewsparse 1024 10000
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 duprightonce 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 duprightabsent 1024
+//! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 repeatabsent 1024 10000
+//! # a right side of keys the left lacks, each batch repeating the last one's
+//! ROW_DIFF_BATCH=16 target/release/examples/row_diff_rss 1000000 chain 64
 //! # duplicate-heavy shape: every key duplicated, wide string key
 //! /usr/bin/time -l target/release/examples/row_diff_rss 1000000 dup 16
 //! /usr/bin/time -l target/release/examples/row_diff_rss 200000 dup 1024
@@ -98,9 +111,26 @@ fn main() {
             )
         }
         "dup" => (Case::Dup(width), format!(" (dup, key_width={width})")),
+        "viewremoved" | "viewadded" | "viewaddedbyvalue" | "viewaddedrepeat" | "viewsparse"
+        | "duprightonce" | "duprightabsent" | "repeatabsent" | "chain" => {
+            let width: usize = args.get(3).and_then(|a| a.parse().ok()).unwrap_or(1024);
+            let every: i64 = args.get(4).and_then(|a| a.parse().ok()).unwrap_or(10_000);
+            let case = match mode {
+                "viewremoved" => Case::ViewRemoved(width),
+                "viewadded" => Case::ViewAdded(width),
+                "viewaddedbyvalue" => Case::ViewAddedByValue(width),
+                "viewaddedrepeat" => Case::ViewAddedRepeat(width),
+                "viewsparse" => Case::ViewSparse { width, every },
+                "duprightonce" => Case::DupRightOnce(width),
+                "duprightabsent" => Case::DupRightAbsent(width),
+                "chain" => Case::Chain(width),
+                _ => Case::RepeatAbsent { width, every },
+            };
+            (case, format!(" ({mode}, width={width}, every={every})"))
+        }
         other => {
             eprintln!(
-                "unknown mode {other:?}; expected linear (the default), nochange, allchange, wide, widesame, manycols or dup"
+                "unknown mode {other:?}; expected linear (the default), nochange, allchange, wide, widesame, manycols, dup, viewremoved, viewadded, viewaddedbyvalue, viewaddedrepeat, viewsparse, duprightonce, duprightabsent, repeatabsent or chain"
             );
             std::process::exit(2);
         }

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/crates/onix-arrow/examples/shared/gen_shapes.rs

@@ -10,7 +10,9 @@
 
 use std::sync::Arc;
 
-use arrow_array::{ArrayRef, Int64Array, RecordBatch, RecordBatchReader, StringArray};
+use arrow_array::{
+    ArrayRef, Int64Array, RecordBatch, RecordBatchReader, StringArray, StringViewArray,
+};
 use arrow_schema::{ArrowError, DataType, Field, Schema, SchemaRef};
 use onix_arrow::{TableDiffError, TableInput};
 
@@ -50,6 +52,60 @@ pub enum Shape {
         width: usize,
         first_fill: u8,
     },
+    /// `(id, v0, v1)`, two `width`-byte `Utf8View` columns starting with `fill`;
+    /// `keys` maps row `i` to its id, or omits it.
+    View {
+        width: usize,
+        fill: u8,
+        keys: ViewKeys,
+    },
+}
+
+/// How a [`Shape::View`] side keys its rows.
+#[derive(Clone, Copy)]
+pub enum ViewKeys {
+    /// Id `i`, omitting every row when `omit_every` is 1, every
+    /// `omit_every`-th row when above 1, and none when 0.
+    Plain { omit_every: i64 },
+    /// Id `offset + i % period`, so each id repeats every `period` rows.
+    Wrap { offset: i64, period: i64 },
+    /// Id `i`, except every `every`-th row, whose id is `-1`.
+    RepeatAbsent { every: i64 },
+    /// In `batch`-row batches, the first half new ids from `offset` up and the
+    /// second half the previous batch's new ids.
+    Chain { offset: i64, batch: i64 },
+    /// Id `i`, except each batch's last row after the first, which repeats the
+    /// previous batch's first id.
+    RepeatPrevFirst { batch: i64 },
+}
+
+impl ViewKeys {
+    fn id(self, i: i64) -> Option<i64> {
+        match self {
+            ViewKeys::Plain { omit_every } => (omit_every == 0 || i % omit_every != 0).then_some(i),
+            ViewKeys::Wrap { offset, period } => Some(offset + i % period),
+            ViewKeys::RepeatAbsent { every } => Some(if i % every == 0 { -1 } else { i }),
+            ViewKeys::RepeatPrevFirst { batch } => {
+                let (b, j) = (i / batch, i % batch);
+                Some(if b > 0 && j == batch - 1 {
+                    (b - 1) * batch
+                } else {
+                    i
+                })
+            }
+            ViewKeys::Chain { offset, batch } => {
+                let (b, j, half) = (i / batch, i % batch, (batch / 2).max(1));
+                Some(
+                    offset
+                        + if j < half {
+                            b * half + j
+                        } else {
+                            (b - 1) * half + j - half
+                        },
+                )
+            }
+        }
+    }
 }
 
 /// A generated two-sided case, with its size parameters already defaulted by
@@ -70,9 +126,98 @@ pub enum Case {
     ManyCols { ncols: usize, width: usize },
     /// Every `key_width`-byte string key appearing twice on each side.
     Dup(usize),
+    /// Two `width`-byte view columns; every left row removed (right empty).
+    ViewRemoved(usize),
+    /// [`Case::ViewRemoved`] mirrored: every right row added (left empty).
+    ViewAdded(usize),
+    /// [`Case::ViewAdded`] keyed on the `width`-byte view column `v0`.
+    ViewAddedByValue(usize),
+    /// [`Case::ViewAdded`] with each right batch's last row repeating the
+    /// previous batch's first key, so every batch keeps a right-only duplicate.
+    ViewAddedRepeat(usize),
+    /// Two `width`-byte view columns, equal sides except every `every`-th left
+    /// row, which the right lacks.
+    ViewSparse { width: usize, every: i64 },
+    /// Left ids once; the right holds the first half of them twice each, half
+    /// a side apart and with different values, so each is a duplicate key.
+    DupRightOnce(usize),
+    /// Left ids once; the right holds ids the left lacks, each twice, half a
+    /// side apart.
+    DupRightAbsent(usize),
+    /// Equal sides except every `every`-th right row, keyed by one id the left
+    /// lacks.
+    RepeatAbsent { width: usize, every: i64 },
+    /// A right side of ids the left lacks, each batch repeating the previous
+    /// batch's new ids.
+    Chain(usize),
 }
 
 impl Case {
+    /// [`Case::build`] for the two-view-column shapes.
+    fn view(self, rows: i64) -> (SchemaRef, Shape, Shape, &'static str) {
+        let (Case::ViewRemoved(width)
+        | Case::ViewAdded(width)
+        | Case::ViewAddedByValue(width)
+        | Case::ViewAddedRepeat(width)
+        | Case::ViewSparse { width, .. }
+        | Case::DupRightOnce(width)
+        | Case::DupRightAbsent(width)
+        | Case::RepeatAbsent { width, .. }
+        | Case::Chain(width)) = self
+        else {
+            unreachable!("only view cases reach this method")
+        };
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int64, false),
+            Field::new("v0", DataType::Utf8View, false),
+            Field::new("v1", DataType::Utf8View, false),
+        ]));
+        let view = |fill, keys| Shape::View { width, fill, keys };
+        let period = (rows / 2).max(1);
+        let all = ViewKeys::Plain { omit_every: 0 };
+        let (left, right) = match self {
+            Case::ViewRemoved(_) => (all, ViewKeys::Plain { omit_every: 1 }),
+            Case::ViewAdded(_) | Case::ViewAddedByValue(_) => {
+                (ViewKeys::Plain { omit_every: 1 }, all)
+            }
+            Case::ViewAddedRepeat(_) => (
+                ViewKeys::Plain { omit_every: 1 },
+                ViewKeys::RepeatPrevFirst {
+                    batch: batch_rows(),
+                },
+            ),
+            Case::ViewSparse { every, .. } => (all, ViewKeys::Plain { omit_every: every }),
+            Case::DupRightOnce(_) => (all, ViewKeys::Wrap { offset: 0, period }),
+            Case::DupRightAbsent(_) => (
+                all,
+                ViewKeys::Wrap {
+                    offset: rows,
+                    period,
+                },
+            ),
+            Case::RepeatAbsent { every, .. } => (all, ViewKeys::RepeatAbsent { every }),
+            Case::Chain(_) => (
+                all,
+                ViewKeys::Chain {
+                    offset: 2 * rows,
+                    batch: batch_rows(),
+                },
+            ),
+            _ => unreachable!("only view cases reach this arm"),
+        };
+        let right_fill = if matches!(self, Case::DupRightOnce(_)) {
+            b'b'
+        } else {
+            b'a'
+        };
+        let key = if matches!(self, Case::ViewAddedByValue(_)) {
+            "v0"
+        } else {
+            "id"
+        };
+        (schema, view(b'a', left), view(right_fill, right), key)
+    }
+
     /// The schema, the left and right shapes, and the key column.
     pub fn build(self, rows: i64) -> (SchemaRef, Shape, Shape, &'static str) {
         let int_schema = || {
@@ -130,6 +275,15 @@ impl Case {
                     "id",
                 )
             }
+            Case::ViewRemoved(_)
+            | Case::ViewAdded(_)
+            | Case::ViewAddedByValue(_)
+            | Case::ViewAddedRepeat(_)
+            | Case::ViewSparse { .. }
+            | Case::DupRightOnce(_)
+            | Case::DupRightAbsent(_)
+            | Case::RepeatAbsent { .. }
+            | Case::Chain(_) => self.view(rows),
             Case::Dup(key_width) => {
                 let schema = Arc::new(Schema::new(vec![
                     Field::new("key", DataType::Utf8, false),
@@ -231,6 +385,22 @@ impl Iterator for GenReader {
                 }
                 columns
             }
+            Shape::View { width, fill, keys } => {
+                let (ids, rows): (Vec<i64>, Vec<i64>) = (self.next..end)
+                    .filter_map(|i| keys.id(i).map(|id| (id, i)))
+                    .unzip();
+                let cell = |column: u8| {
+                    let cells: StringViewArray = rows
+                        .iter()
+                        .map(|&i| {
+                            let pad = width.saturating_sub(2);
+                            Some(format!("{}{column}{i:0>pad$}", char::from(fill)))
+                        })
+                        .collect();
+                    Arc::new(cells) as ArrayRef
+                };
+                vec![Arc::new(Int64Array::from(ids)), cell(0), cell(1)]
+            }
         };
         self.next = end;
 

{deepdiff_rs-0.12.0 → deepdiff_rs-0.13.0}/crates/onix-arrow/src/lib.rs

@@ -3,8 +3,8 @@
 //! [`diff_tables`] compares two tables presented as [`TableInput`]s and
 //! returns a [`TableDiff`] carrying the schema diff, the keyed row diff, and
 //! the per-cell diff. The two tables are matched on a required, non-empty
-//! set of key columns, carried in [`TableDiffOptions`]. The row diff reads
-//! each side more than once, so [`diff_tables`] takes a re-openable
+//! set of key columns, carried in [`TableDiffOptions`]. The row diff may read
+//! a side more than once, so [`diff_tables`] takes a re-openable
 //! [`TableInput`] rather than a single-use `RecordBatchReader`. In-memory
 //! tables use [`MemoryInput`]; a one-shot stream spools to a temporary file
 //! and implements [`TableInput`] over it, as the Python bindings do.