parity-diff 0.2.2__tar.gz → 0.2.3__tar.gz

{parity_diff-0.2.2 → parity_diff-0.2.3}/CONTRIBUTING.md

@@ -97,6 +97,34 @@ MySQL, added after v0.1.0, turned up two more that a warehouse dialect may hit:
    sentinel silently became `N`. Build such bytes from `CHAR`/hex, not a
    literal, and verify by hashing rather than by reading the SQL.
 
+Snowflake, the first warehouse (v0.2.2), added three more — the sort a warehouse
+is especially likely to spring:
+
+9. **Your engine may have neither a bit-cast nor `CONV` to reach 60 bits.**
+   Snowflake had no `bit(60)::bigint` and no `conv(hex,16,10)`. What it did have
+   is `md5_number_upper64(x)`, the top 64 bits of the digest as a number, and
+   `floor(that / 16)` drops the low 4 to land on the same 60-bit prefix - the
+   fourth distinct path to `648541476951500027`. Find your engine's own route;
+   the constant is the contract, not the SQL that reaches it.
+
+10. **Integers and decimals may share one type name.** Snowflake reports both as
+    `NUMBER` and only `numeric_scale` (0 = integer) tells them apart, so its
+    `columns()` reads the scale instead of trusting `data_type`. Trust the type
+    name and an integer key renders as `42.000000` and never matches another
+    engine's `42`. If your engine collapses numeric types like this, override
+    `columns()`.
+
+11. **Identifier case-folding is the engine's, and it is not universal.**
+    Snowflake upper-cases unquoted identifiers where PostgreSQL and DuckDB
+    lower-case them. The engine matches keys and columns case-insensitively for
+    exactly this reason (`_fold_columns`), but the *table* name is looked up in
+    the case the engine stored, so `--a-table orders` against a Snowflake
+    `ORDERS` fails with a near-miss hint. And some warehouses (Snowflake among
+    them) offer only READ COMMITTED, so unlike PostgreSQL the walk cannot be
+    pinned to one snapshot - a real limitation to document, not hide. None of
+    these three showed up in the docs; they surfaced only against a live
+    account, which is why the rule below is not negotiable.
+
 ### Proving it works
 
 A dialect is not done until `tests/test_encoding.py` passes against it. That
@@ -136,6 +164,19 @@ reason next to it rather than being switched off globally.
 PostgreSQL-backed tests read `PARITY_TEST_PG` and skip cleanly when nothing is
 listening, so the suite is useful with only DuckDB installed.
 
+The generative suites hunt for the one failure that matters most — a real
+difference reported as identical. To run that hunt deeper (many more generated
+cases per property, at the cost of time), scale it with `PARITY_DEEP`:
+
+```bash
+PARITY_DEEP=20 pytest tests/test_identical.py tests/test_properties.py
+```
+
+The default of `1` keeps the everyday suite fast; the deep run is the repeatable
+"make sure there is no abnormality" check on the identical guarantee. A dozen
+seeds at `PARITY_DEEP=6` have turned up nothing — but the point is that anyone
+can re-run it.
+
 ## Scope
 
 Before proposing a feature, check it against the question the tool exists to

{parity_diff-0.2.2/src/parity_diff.egg-info → parity_diff-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parity-diff
-Version: 0.2.2
+Version: 0.2.3
 Summary: Prove two tables in two different database engines hold the same data - without moving the data out of either engine.
 Author: Alessio Sorio
 License-Expression: MIT

{parity_diff-0.2.2 → parity_diff-0.2.3}/pyproject.toml

@@ -3,7 +3,7 @@
 # PyPI by an empty project. The import name, the CLI command and the repo are
 # all still `parity`: `pip install parity-diff` gives you `parity ...`.
 name = "parity-diff"
-version = "0.2.2"
+version = "0.2.3"
 description = "Prove two tables in two different database engines hold the same data - without moving the data out of either engine."
 readme = "README.md"
 license = "MIT"

{parity_diff-0.2.2 → parity_diff-0.2.3}/src/parity/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import Any
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 __all__ = ["__version__", "diff", "get_dialect"]
 

{parity_diff-0.2.2 → parity_diff-0.2.3/src/parity_diff.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parity-diff
-Version: 0.2.2
+Version: 0.2.3
 Summary: Prove two tables in two different database engines hold the same data - without moving the data out of either engine.
 Author: Alessio Sorio
 License-Expression: MIT

{parity_diff-0.2.2 → parity_diff-0.2.3}/src/parity_diff.egg-info/SOURCES.txt

@@ -25,8 +25,11 @@ tests/test_cli.py
 tests/test_encoding.py
 tests/test_engine.py
 tests/test_fuzz_encoding.py
+tests/test_identical.py
+tests/test_identical_live.py
 tests/test_integration.py
 tests/test_mysql.py
+tests/test_mysql_postgres.py
 tests/test_properties.py
 tests/test_snowflake.py
 tests/test_snowflake_offline.py

{parity_diff-0.2.2 → parity_diff-0.2.3}/tests/conftest.py

@@ -12,6 +12,16 @@ import pytest
 
 from parity.dialects.base import get_dialect
 
+#: Multiplier for Hypothesis example counts. `PARITY_DEEP=20 pytest` runs the
+#: generative suites twenty times deeper - the repeatable "make sure there is no
+#: abnormality" hunt for the identical check, without changing the fast default.
+DEEP = max(1, int(os.environ.get("PARITY_DEEP", "1")))
+
+
+def deep_examples(n: int) -> int:
+    """Scale a Hypothesis `max_examples` by the PARITY_DEEP factor (default 1)."""
+    return n * DEEP
+
 #: CLAUDE.md section 7 documents a Docker container on port 55432. A native
 #: install on 5432 is equally valid, so the endpoint is configurable.
 PG_URL = os.environ.get(

parity_diff-0.2.3/tests/test_identical.py

@@ -0,0 +1,222 @@
+"""The identical check, stress-tested from every offline angle.
+
+A parity tool that reports a false match is worse than useless (CLAUDE.md 8), so
+the property that identical tables report identical - and that identical-except-
+one-thing never does - deserves its own dedicated hunt. These run against the
+in-memory `FakeDialect`, so they exercise the *bisection, matching and checksum*
+logic at high volume with hostile data; the cross-engine *encoding* side of the
+same promise lives in test_encoding.py and the live suites.
+
+Two deliberate choices about the field separator (0x1f):
+- The "identical stays identical" tests include it in the data on purpose - the
+  same bytes on both sides must compare equal however hostile.
+- The false-identical hunter excludes it, because `concat_ws` smearing on a
+  separator that appears in real data is a documented limitation (CLAUDE.md
+  4.3), not an abnormality, and planting it would test the wrong thing.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("hypothesis")
+
+from conftest import deep_examples
+from fakes import DictTable, FakeDialect, SyntheticTable
+from hypothesis import assume, given, settings
+from hypothesis import strategies as st
+
+from parity.engine import diff
+from parity.types import Column, LogicalType
+
+# Hostile text: full Unicode, control characters, even NUL - the fake is pure
+# Python, so the point is that identical *bytes* stay identical however ugly.
+# Surrogates are excluded only because they have no encoding at all.
+_FULL = st.text(
+    alphabet=st.characters(blacklist_categories=("Cs",)), max_size=18
+)
+# The same, minus the field separator, for tests that plant a difference.
+_SAFE = st.text(
+    alphabet=st.characters(blacklist_characters="\x1f", blacklist_categories=("Cs",)),
+    max_size=18,
+)
+_KEY = st.integers(min_value=-(10**12), max_value=10**12)
+
+
+def _table(text=_SAFE, min_rows=0, max_cols=6):
+    """A strategy for (columns, rows): 1..max_cols string columns, sparse keys."""
+
+    @st.composite
+    def build(draw):
+        """Draw one (columns, rows) pair for the strategy above."""
+        ncols = draw(st.integers(min_value=1, max_value=max_cols))
+        cols = [Column(f"c{i}", LogicalType.STRING, "varchar") for i in range(ncols)]
+        keys = draw(
+            st.lists(_KEY, unique=True, min_size=min_rows, max_size=30)
+        )
+        rows = {k: tuple(draw(text) for _ in range(ncols)) for k in keys}
+        return cols, rows
+
+    return build()
+
+
+def _oracle(rows_a: dict, rows_b: dict) -> list[tuple[int, str]]:
+    """The truth, computed the dumb way, for the change hunter."""
+    out = []
+    for k in set(rows_a) | set(rows_b):
+        a, b = rows_a.get(k), rows_b.get(k)
+        if a is None:
+            out.append((k, "only_in_b"))
+        elif b is None:
+            out.append((k, "only_in_a"))
+        elif a != b:
+            out.append((k, "different"))
+    return sorted(out)
+
+
+def _run(cols_a, rows_a, cols_b, rows_b, **kwargs):
+    """Diff two explicit (columns, rows) sides through the engine."""
+    a = FakeDialect(DictTable(cols_a, rows_a), side="A")
+    b = FakeDialect(DictTable(cols_b, rows_b), side="B")
+    return diff(a, b, "a.t", "b.t", "id", **kwargs)
+
+
+def _kinds(result) -> list[tuple[int, str]]:
+    """Result as a sorted (key, kind) list."""
+    return sorted((d.key, d.kind) for d in result.diffs)
+
+
+# ---------------------------------------------------------------------------
+# Identical stays identical - however hostile the data, whatever the knobs.
+# ---------------------------------------------------------------------------
+
+
+@settings(max_examples=deep_examples(500))
+@given(
+    data=_table(text=_FULL),
+    bisection_factor=st.integers(min_value=2, max_value=64),
+    threshold=st.integers(min_value=1, max_value=100),
+)
+def test_identical_tables_are_identical_under_every_knob(data, bisection_factor, threshold):
+    """A table against itself: identical, no diffs, zero rows moved - for any
+    fan-out and threshold, and even with separators and NULs in the data."""
+    cols, rows = data
+    result = _run(
+        cols, rows, cols, dict(rows),
+        bisection_factor=bisection_factor, threshold=threshold,
+    )
+    assert result.identical
+    assert result.diffs == []
+    assert result.stats.rows_downloaded == 0
+
+
+@settings(max_examples=300)
+@given(data=_table(text=_FULL, min_rows=1))
+def test_identical_downloads_zero_and_costs_four_queries(data):
+    """The headline efficiency claim on any non-empty table: 4 queries
+    (2 key_stats + 2 first-level checksums) and nothing downloaded."""
+    cols, rows = data
+    result = _run(cols, rows, cols, dict(rows))
+    assert result.identical
+    assert result.stats.rows_downloaded == 0
+    assert result.stats.queries == 4
+
+
+@settings(max_examples=300)
+@given(data=_table(text=_FULL, min_rows=1), perm=st.randoms(use_true_random=False))
+def test_identical_is_independent_of_column_order(data, perm):
+    """Columns are matched by name, so the same data with columns in a different
+    order on side B still compares identical - order is not content."""
+    cols, rows = data
+    order = list(range(len(cols)))
+    perm.shuffle(order)
+    cols_b = [cols[i] for i in order]
+    rows_b = {k: tuple(v[i] for i in order) for k, v in rows.items()}
+    result = _run(cols, rows, cols_b, rows_b)
+    assert result.identical
+    assert result.stats.rows_downloaded == 0
+
+
+@settings(max_examples=100, deadline=None)  # large-table walks are legitimately slow
+@given(n=st.integers(min_value=1, max_value=200_000), bf=st.integers(min_value=2, max_value=64))
+def test_identical_at_scale_downloads_nothing(n, bf):
+    """Two identical generated tables of up to 200k rows: still zero download,
+    and the query count stays tiny (a logarithmic walk that never recurses)."""
+    a = FakeDialect(SyntheticTable(n), side="A")
+    b = FakeDialect(SyntheticTable(n), side="B")
+    result = diff(a, b, "t", "t", "id", bisection_factor=bf)
+    assert result.identical
+    assert result.stats.rows_downloaded == 0
+    assert result.stats.queries == 4
+
+
+@settings(max_examples=200)
+@given(data=_table(text=_FULL))
+def test_the_identical_check_is_deterministic(data):
+    """Running the identical check twice gives the same verdict and counts -
+    no dependence on dict ordering, threads, or hash seeding."""
+    cols, rows = data
+    first = _run(cols, rows, cols, dict(rows))
+    second = _run(cols, rows, cols, dict(rows))
+    assert first.identical == second.identical
+    assert _kinds(first) == _kinds(second)
+    assert first.stats.rows_downloaded == second.stats.rows_downloaded
+    assert first.stats.queries == second.stats.queries
+
+
+# ---------------------------------------------------------------------------
+# The false-identical hunter: one minimal change must never read as identical.
+# ---------------------------------------------------------------------------
+
+
+@settings(max_examples=deep_examples(600))
+@given(data=_table(text=_SAFE, min_rows=1), seed=st.randoms(use_true_random=False), newval=_SAFE)
+def test_a_single_planted_change_is_never_called_identical(data, seed, newval):
+    """Take an identical pair, apply exactly one change - alter a cell, delete a
+    row, or insert a row - and assert the walk never reports identical and finds
+    exactly what a brute-force comparison would. This is the failure the whole
+    tool exists to prevent, concentrated onto the hardest case: one difference.
+    """
+    cols, rows = data
+    rows_b = dict(rows)
+    keys = sorted(rows)
+    kind = seed.choice(["change", "delete", "insert"])
+    if kind == "change":
+        k = seed.choice(keys)
+        col = seed.randrange(len(cols))
+        v = list(rows_b[k])
+        v[col] = newval
+        rows_b[k] = tuple(v)
+    elif kind == "delete":
+        del rows_b[seed.choice(keys)]
+    else:  # insert a key not already present
+        newk = seed.randint(-(10**12), 10**12)
+        assume(newk not in rows_b)
+        rows_b[newk] = tuple(newval for _ in cols)
+
+    assume(rows_b != rows)  # a change that changed nothing is not a test
+
+    result = _run(cols, rows, cols, rows_b)
+    assert not result.identical, "a real difference was reported as identical"
+    assert _kinds(result) == _oracle(rows, rows_b)
+    assert result.stats.rows_downloaded > 0
+
+
+@settings(max_examples=300)
+@given(data=_table(text=_SAFE, min_rows=1), seed=st.randoms(use_true_random=False))
+def test_null_versus_value_on_one_cell_is_found(data, seed):
+    """The migration bug class: a value on one side, absent (a different value)
+    on the other, in a single cell, must be caught - never smoothed to a match.
+    """
+    cols, rows = data
+    k = seed.choice(sorted(rows))
+    col = seed.randrange(len(cols))
+    v = list(rows[k])
+    # Flip the cell to something guaranteed different from what is there.
+    v[col] = v[col] + "␀" if v[col] != "␀" else "x"
+    rows_b = dict(rows)
+    rows_b[k] = tuple(v)
+    result = _run(cols, rows, cols, rows_b)
+    assert not result.identical
+    assert _kinds(result) == [(k, "different")]
+    assert result.diffs[0].columns == [f"c{col}"]

parity_diff-0.2.3/tests/test_identical_live.py

@@ -0,0 +1,382 @@
+"""The identical check across engines, over key types and values the core
+integration suite does not reach.
+
+`test_integration.py` proves identical tables match across PostgreSQL and DuckDB
+with an *integer* key. This file widens the identical check where a cross-engine
+abnormality would actually hide: the *hashed* key paths (text, composite, uuid),
+which bucket by a hash of the key's rendered text, and edge-case values
+(bigint extremes, non-finite floats, high-precision decimals, astral-plane
+Unicode, an all-NULL row). Every table is built by a deterministic expression
+spelled identically on both engines, so any reported difference is the tool
+rendering the same value two ways - the exact false-positive the identical check
+must never produce.
+
+Skips cleanly without PostgreSQL.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+import pytest
+from conftest import PG_SCHEMA, duckdb_write, open_duckdb, open_pg
+
+from parity.engine import diff
+
+pytestmark = pytest.mark.postgres
+
+N = 5_000
+
+# md5(i) agrees across engines, giving a deterministic text/uuid key. Each SELECT
+# is portable SQL that produces byte-identical data on PostgreSQL and DuckDB.
+TABLES = {
+    "text_key": (
+        "uid",
+        f"""
+        select md5(i::varchar)                            as uid,
+               (i % 97)::integer                          as customer_id,
+               ((i * 7 % 100000) / 100.0)::decimal(12,2)  as amount,
+               case when i % 13 = 0 then null
+                    else 'n' || i::varchar end            as note
+        from generate_series(1, {N}) as s(i)
+        """,
+    ),
+    "composite_key": (
+        "grp,id",
+        f"""
+        select (i % 100)::integer                         as grp,
+               i::bigint                                  as id,
+               ((i * 3 % 50000) / 100.0)::decimal(12,2)   as amount,
+               (i % 7 = 0)                                as flag
+        from generate_series(1, {N}) as s(i)
+        """,
+    ),
+    "uuid_key": (
+        "uid",
+        f"""
+        select cast(
+                 substr(md5(i::varchar), 1, 8) || '-' ||
+                 substr(md5(i::varchar), 9, 4) || '-' ||
+                 substr(md5(i::varchar), 13, 4) || '-' ||
+                 substr(md5(i::varchar), 17, 4) || '-' ||
+                 substr(md5(i::varchar), 21, 12) as uuid)  as uid,
+               (i % 97)::integer                           as customer_id
+        from generate_series(1, {N}) as s(i)
+        """,
+    ),
+    # One row per hostile value: bigint extremes, a non-finite float, a
+    # high-precision decimal, an astral-plane emoji, an empty string, and an
+    # all-NULL row. `{{f}}` is the engine's double type, filled at build time.
+    "edge_values": (
+        "id",
+        """
+        select cast(1 as bigint)                          as id,
+               cast('9223372036854775807' as bigint)      as big,
+               cast(123456789012.345678 as decimal(38,6)) as dec,
+               cast('Infinity' as {f})                    as flt,
+               timestamp '2024-02-29 13:04:05.123456'     as ts,
+               'añ日\U0001f600'                  as txt
+        union all select cast(2 as bigint), cast('-9223372036854775808' as bigint),
+               cast(-0.000001 as decimal(38,6)), cast('-Infinity' as {f}),
+               timestamp '2000-01-01 00:00:00', ''
+        union all select cast(3 as bigint), cast(0 as bigint),
+               cast(0 as decimal(38,6)), cast('NaN' as {f}),
+               timestamp '2099-12-31 23:59:59.999999', null
+        union all select cast(4 as bigint), null,
+               null, cast(1.5 as {f}), null, 'plain'
+        """,
+    ),
+}
+
+
+def _build(cursor_exec, table_sql, float_type: str) -> None:
+    """Create every table via the given execute callable (one engine).
+
+    `float_type` is that engine's double spelling - PostgreSQL wants
+    ``double precision`` where DuckDB wants ``double`` - filled into the edge
+    table's non-finite-float columns.
+    """
+    for name, (_key, select) in TABLES.items():
+        cursor_exec(f"create table {table_sql(name)} as {select.format(f=float_type)}")
+
+
+@pytest.fixture(scope="module")
+def duck(tmp_path_factory):
+    """Side B: all tables in one DuckDB file, opened read-only."""
+    path = str(tmp_path_factory.mktemp("ident_live") / "b.duckdb")
+    con = duckdb_write(path)
+    try:
+        _build(con.execute, lambda n: f"main.{n}", "double")
+    finally:
+        con.close()
+    d = open_duckdb(path, side="B")
+    yield d
+    d.close()
+
+
+SCHEMA = f"{PG_SCHEMA}_identlive"
+
+
+@pytest.fixture(scope="module")
+def pg(pg_url):
+    """Side A: all tables in a schema the test owns, opened read-only."""
+    import psycopg
+
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {SCHEMA} cascade")
+        con.execute(f"create schema {SCHEMA}")
+        _build(con.execute, lambda n: f"{SCHEMA}.{n}", "double precision")
+    finally:
+        con.close()
+    d = open_pg(pg_url, side="A")
+    yield d
+    d.close()
+
+
+@pytest.mark.parametrize("name", list(TABLES))
+def test_identical_across_engines_by_key_type(pg, duck, name):
+    """The same table, same data, one hashed key type at a time: identical,
+    and not one row moved across the network."""
+    key = TABLES[name][0].split(",")  # a list, so composite keys resolve
+    result = diff(pg, duck, f"{SCHEMA}.{name}", f"main.{name}", key)
+    assert result.identical, (
+        f"{name}: identical data reported {len(result.diffs)} diffs "
+        f"{[(d.key, d.kind, d.columns) for d in result.diffs[:3]]}"
+    )
+    assert result.stats.rows_downloaded == 0
+
+
+def test_a_representation_change_across_engines_reads_identical(pg_url, tmp_path):
+    """The migration scenario: the same values stored with *different declared
+    types* on each engine - integer vs bigint, numeric(12,2) vs double,
+    varchar vs text - must still read identical end to end. Storing a value a
+    different way is not changing it; the diff must not mistake it for one.
+    """
+    import psycopg
+
+    n = 2_000
+    schema = f"{PG_SCHEMA}_repr"
+    pg_sql = f"""
+        create table {schema}.repr as
+        select i::bigint                                      as id,
+               (i / 100.0)::numeric(12,2)                     as amount,
+               ('r' || i::text)::varchar(50)                  as name,
+               (timestamp '2024-01-01 00:00:00'
+                    + (i % 86400) * interval '1 second')      as ts
+        from generate_series(1, {n}) as s(i)
+    """
+    duck_sql = f"""
+        create table repr as
+        select i::integer                                    as id,
+               (i / 100.0)::double                           as amount,
+               ('r' || i::varchar)                           as name,
+               (timestamp '2024-01-01 00:00:00'
+                    + (i % 86400) * interval '1 second')      as ts
+        from generate_series(1, {n}) as s(i)
+    """
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {schema} cascade")
+        con.execute(f"create schema {schema}")
+        con.execute(pg_sql)
+    finally:
+        con.close()
+    path = str(tmp_path / "repr.duckdb")
+    dcon = duckdb_write(path)
+    try:
+        dcon.execute(duck_sql)
+    finally:
+        dcon.close()
+
+    a = open_pg(pg_url, side="A")
+    b = open_duckdb(path, side="B")
+    try:
+        result = diff(a, b, f"{schema}.repr", "main.repr", "id")
+    finally:
+        a.close()
+        b.close()
+        con = psycopg.connect(pg_url, autocommit=True)
+        try:
+            con.execute(f"drop schema if exists {schema} cascade")
+        finally:
+            con.close()
+
+    assert result.identical, (
+        "a pure representation change was reported as a data difference: "
+        f"{[(d.key, d.columns) for d in result.diffs[:5]]}"
+    )
+    assert result.stats.rows_downloaded == 0
+
+
+def test_a_hashed_key_table_still_finds_a_planted_difference(pg, tmp_path):
+    """The other half of the promise: the identical check on a hashed key must
+    never MISS a real difference either. Plant one changed row in a text-keyed
+    copy and confirm the walk reports exactly it, keyed by the real text
+    identity - never by the 60-bit bucket hash, which could collide.
+    """
+    path = str(tmp_path / "text_key_perturbed.duckdb")
+    con = duckdb_write(path)
+    try:
+        con.execute(f"create table text_key as {TABLES['text_key'][1]}")
+        # md5('1234') is the uid of the row generated for i = 1234.
+        con.execute("update text_key set amount = amount + 0.01 where uid = md5('1234')")
+    finally:
+        con.close()
+
+    b = open_duckdb(path, side="B")
+    try:
+        result = diff(pg, b, f"{SCHEMA}.text_key", "main.text_key", "uid")
+    finally:
+        b.close()
+
+    # The same md5 the engines compute, for cross-engine agreement not security.
+    uid = hashlib.md5(b"1234", usedforsecurity=False).hexdigest()
+    assert [(d.key, d.kind) for d in result.diffs] == [(uid, "different")]
+    assert result.diffs[0].columns == ["amount"]
+
+
+def test_a_very_wide_table_reads_identical_across_engines(pg_url, tmp_path):
+    """A table with more columns than PostgreSQL's 100-argument `concat_ws`
+    limit forces `row_text` to build a nested tree of `concat_ws` calls. The two
+    engines must build the *same* tree over the same values, or an identical
+    wide table - an ordinary denormalised fact table - would report every row as
+    different. Also plants one change to prove the wide path finds a real one.
+    """
+    import psycopg
+
+    ncols = 120  # over PostgreSQL's 99-argument concat_ws limit
+    cols = ", ".join(f"('v' || (i + {n})::varchar) as c{n}" for n in range(ncols))
+    select = f"select i::bigint as id, {cols} from generate_series(1, 500) as s(i)"
+    schema = f"{PG_SCHEMA}_wide"
+
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {schema} cascade")
+        con.execute(f"create schema {schema}")
+        con.execute(f"create table {schema}.wide as {select}")
+    finally:
+        con.close()
+    path = str(tmp_path / "wide.duckdb")
+    dcon = duckdb_write(path)
+    try:
+        dcon.execute(f"create table wide as {select}")
+        dcon.execute("create table wide_p as select * from wide")
+        dcon.execute("update wide_p set c50 = 'CHANGED' where id = 321")
+    finally:
+        dcon.close()
+
+    a = open_pg(pg_url, side="A")
+    b = open_duckdb(path, side="B")
+    try:
+        same = diff(a, b, f"{schema}.wide", "main.wide", "id")
+        changed = diff(a, b, f"{schema}.wide", "main.wide_p", "id")
+    finally:
+        a.close()
+        b.close()
+        con = psycopg.connect(pg_url, autocommit=True)
+        try:
+            con.execute(f"drop schema if exists {schema} cascade")
+        finally:
+            con.close()
+
+    assert same.identical, (
+        "a 120-column identical table reported differences - the nested "
+        f"concat_ws trees disagree: {[(d.key, d.columns) for d in same.diffs[:3]]}"
+    )
+    assert same.stats.rows_downloaded == 0
+    assert [(d.key, d.kind) for d in changed.diffs] == [(321, "different")]
+    assert changed.diffs[0].columns == ["c50"]
+
+
+def test_a_same_content_swap_in_one_bucket_is_caught_live(pg_url, tmp_path):
+    """The exact 0.2.1 bug, reproduced across two real engines.
+
+    Every row carries identical non-key content, and one side holds key 2500
+    while the other holds the adjacent key 2501 - a delete and an insert of the
+    same content in the same bucket. Before the key was folded into each
+    bucket's checksum the counts balanced and the content sums matched, so both
+    rows vanished: a false "identical". They must both be found.
+    """
+    import psycopg
+
+    # Shared keys are 1..5000 except {2500, 2501}; PostgreSQL adds 2500, DuckDB
+    # adds 2501. Identical content everywhere, so only the key distinguishes them.
+    body = "1.00::decimal(12,2) as amount, 'x' as status"
+    pg_select = f"select i::bigint as id, {body} from generate_series(1,5000) as s(i) where i <> 2501"
+    duck_select = f"select i::bigint as id, {body} from generate_series(1,5000) as s(i) where i <> 2500"
+    schema = f"{PG_SCHEMA}_swap"
+
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {schema} cascade")
+        con.execute(f"create schema {schema}")
+        con.execute(f"create table {schema}.swap as {pg_select}")
+    finally:
+        con.close()
+    path = str(tmp_path / "swap.duckdb")
+    dcon = duckdb_write(path)
+    try:
+        dcon.execute(f"create table swap as {duck_select}")
+    finally:
+        dcon.close()
+
+    a = open_pg(pg_url, side="A")
+    b = open_duckdb(path, side="B")
+    try:
+        result = diff(a, b, f"{schema}.swap", "main.swap", "id")
+    finally:
+        a.close()
+        b.close()
+        con = psycopg.connect(pg_url, autocommit=True)
+        try:
+            con.execute(f"drop schema if exists {schema} cascade")
+        finally:
+            con.close()
+
+    assert not result.identical, "a same-content insert+delete cancelled to a false match"
+    assert [(d.key, d.kind) for d in result.diffs] == [
+        (2500, "only_in_a"),
+        (2501, "only_in_b"),
+    ]
+
+
+@pytest.mark.parametrize("rows,queries", [(0, 2), (1, 4)])
+def test_degenerate_identical_tables_across_engines(pg_url, tmp_path, rows, queries):
+    """The degenerate sizes where off-by-ones hide: an empty table costs two
+    queries (key_stats only, nothing to bisect) and a one-row table costs four
+    (2 key_stats + 2 checksums), both identical and both moving zero rows."""
+    import psycopg
+
+    select = f"select i::bigint as id, ('v' || i::text) as note from generate_series(1, {rows}) as s(i)"
+    schema = f"{PG_SCHEMA}_degen"
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {schema} cascade")
+        con.execute(f"create schema {schema}")
+        con.execute(f"create table {schema}.t as {select}")
+    finally:
+        con.close()
+    path = str(tmp_path / "degen.duckdb")
+    dcon = duckdb_write(path)
+    try:
+        dcon.execute(f"create table t as {select}")
+    finally:
+        dcon.close()
+
+    a = open_pg(pg_url, side="A")
+    b = open_duckdb(path, side="B")
+    try:
+        result = diff(a, b, f"{schema}.t", "main.t", "id")
+    finally:
+        a.close()
+        b.close()
+        con = psycopg.connect(pg_url, autocommit=True)
+        try:
+            con.execute(f"drop schema if exists {schema} cascade")
+        finally:
+            con.close()
+
+    assert result.identical
+    assert result.stats.rows_downloaded == 0
+    assert result.stats.queries == queries

parity_diff-0.2.3/tests/test_mysql_postgres.py

@@ -0,0 +1,106 @@
+"""The identical check between the two most common migration endpoints.
+
+MySQL and PostgreSQL are each verified against DuckDB elsewhere, so byte-equal
+canonical text makes them agree with each other by transitivity - but a
+MySQL -> PostgreSQL migration is common enough that the pair deserves a direct
+test, with neither side being the reference engine. Identical data built by
+each engine's own dialect must read identical; a single planted change must be
+found exactly.
+
+Skips unless both a MySQL and a PostgreSQL server are reachable.
+"""
+
+from __future__ import annotations
+
+import pytest
+from conftest import PG_SCHEMA, open_mysql, open_pg
+
+from parity.engine import diff
+
+pytestmark = [pytest.mark.postgres, pytest.mark.mysql]
+
+N = 2_000
+SCHEMA = f"{PG_SCHEMA}_mypg"
+
+# The same rows, spelled in each engine's own SQL. `flag` is a plain int on both
+# (not a boolean) so this tests data agreement, not the boolean-vs-int trap.
+PG_BUILD = f"""
+create table {SCHEMA}.xeng as
+select i::bigint                                            as id,
+       ((i * 7 % 100000) / 100.0)::decimal(12,2)            as amount,
+       (case when i % 3 = 0 then 'paid'
+             when i % 3 = 1 then 'open' else 'void' end)::varchar(10) as status,
+       (i % 11 = 0)::int                                    as flag,
+       (case when i % 13 = 0 then null
+             else 'n' || i::text end)::varchar(20)          as note
+from generate_series(1, {N}) as s(i)
+"""
+
+MYSQL_BUILD = f"""
+create table xeng as
+with recursive seq(i) as (
+    select 1 union all select i + 1 from seq where i < {N}
+)
+select cast(i as signed)                                   as id,
+       cast((i * 7 mod 100000) / 100.0 as decimal(12,2))   as amount,
+       (case when i mod 3 = 0 then 'paid'
+             when i mod 3 = 1 then 'open' else 'void' end)  as status,
+       cast(i mod 11 = 0 as signed)                        as flag,
+       (case when i mod 13 = 0 then null
+             else concat('n', i) end)                       as note
+from seq
+"""
+
+
+@pytest.fixture(scope="module")
+def pg(pg_url):
+    """Side A: PostgreSQL, its own schema, opened read-only."""
+    import psycopg
+
+    con = psycopg.connect(pg_url, autocommit=True)
+    try:
+        con.execute(f"drop schema if exists {SCHEMA} cascade")
+        con.execute(f"create schema {SCHEMA}")
+        con.execute(PG_BUILD)
+    finally:
+        con.close()
+    d = open_pg(pg_url, side="A")
+    yield d
+    d.close()
+
+
+@pytest.fixture(scope="module")
+def my(mysql_url):
+    """Side B: MySQL, identical data, opened read-only."""
+    d = open_mysql(mysql_url, side="B")
+    cur = d._conn.cursor()
+    try:
+        cur.execute("set session cte_max_recursion_depth = 1000000")
+        cur.execute("drop table if exists xeng")
+        cur.execute("drop table if exists xeng_p")
+        cur.execute(MYSQL_BUILD)
+        # A perturbed copy for the planted-difference test, built once.
+        cur.execute("create table xeng_p as select * from xeng")
+        cur.execute("update xeng_p set amount = amount + 0.01 where id = 1234")
+        d._conn.commit()
+    finally:
+        cur.close()
+    yield d
+    d.close()
+
+
+def test_mysql_and_postgres_agree_on_identical_data(pg, my):
+    """The same rows on each engine read identical, with zero download."""
+    result = diff(pg, my, f"{SCHEMA}.xeng", "xeng", "id")
+    assert result.identical, (
+        "MySQL and PostgreSQL disagreed on identical data: "
+        f"{[(d.key, d.columns, d.values_a, d.values_b) for d in result.diffs[:5]]}"
+    )
+    assert result.stats.rows_downloaded == 0
+
+
+def test_a_planted_change_between_mysql_and_postgres_is_found(pg, my):
+    """One changed decimal is reported as exactly that row and column."""
+    result = diff(pg, my, f"{SCHEMA}.xeng", "xeng_p", "id")
+    assert [(d.key, d.kind) for d in result.diffs] == [(1234, "different")]
+    assert result.diffs[0].columns == ["amount"]

{parity_diff-0.2.2 → parity_diff-0.2.3}/tests/test_properties.py

@@ -22,6 +22,7 @@ import pytest
 # dependency must not look like a broken build.
 pytest.importorskip("hypothesis")
 
+from conftest import deep_examples
 from fakes import DictTable, FakeDialect
 from hypothesis import given, settings
 from hypothesis import strategies as st
@@ -81,7 +82,7 @@ def _kinds(result) -> list[tuple[int, str]]:
 # ---------------------------------------------------------------------------
 
 
-@settings(max_examples=400)
+@settings(max_examples=deep_examples(400))
 @given(a=_table, b=_table)
 def test_diff_matches_a_brute_force_oracle(a, b):
     """For any two tables, parity's result equals comparing every row directly.