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

{parity_diff-0.2.1 → 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.1/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.1
+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
@@ -30,10 +30,13 @@ Provides-Extra: postgres
 Requires-Dist: psycopg[binary]>=3.1; extra == "postgres"
 Provides-Extra: mysql
 Requires-Dist: mysql-connector-python>=8.0; extra == "mysql"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-connector-python>=3.0; extra == "snowflake"
 Provides-Extra: all
 Requires-Dist: duckdb>=1.0; extra == "all"
 Requires-Dist: psycopg[binary]>=3.1; extra == "all"
 Requires-Dist: mysql-connector-python>=8.0; extra == "all"
+Requires-Dist: snowflake-connector-python>=3.0; extra == "all"
 Provides-Extra: test
 Requires-Dist: hypothesis>=6.0; extra == "test"
 Dynamic: license-file
@@ -127,6 +130,7 @@ pip install "parity-diff[all]"        # every engine
 pip install "parity-diff[duckdb]"     # DuckDB only — no other driver pulled in
 pip install "parity-diff[postgres]"   # PostgreSQL only
 pip install "parity-diff[mysql]"      # MySQL only
+pip install "parity-diff[snowflake]"  # Snowflake only
 ```
 
 > The PyPI distribution is `parity-diff` — plain `parity` is squatted by an
@@ -288,7 +292,8 @@ stated plainly rather than buried.
 | PostgreSQL | supported (tested against 16 and 18) |
 | DuckDB | supported (tested against 1.5) |
 | MySQL | supported (tested against 8.0) |
-| Snowflake, BigQuery, Redshift | not yet — see `CONTRIBUTING.md`, a dialect is ~80 lines |
+| Snowflake | supported (verified live on AWS; `pip install "parity-diff[snowflake]"`) |
+| BigQuery, Redshift | not yet — see `CONTRIBUTING.md`, a dialect is ~80 lines |
 
 ## Scope
 
@@ -336,7 +341,10 @@ way it is. `ROADMAP.md` is what is done and what comes next.
 
 ## Changelog
 
-See `CHANGELOG.md`.
+Latest release **0.2.1** — a generative test suite (property-based, oracle, and
+cross-engine fuzzing) and the correctness fix it surfaced: a same-content
+insert-plus-delete falling in one bucket that could previously read as
+identical. See `CHANGELOG.md` for the full history.
 
 ## License
 

{parity_diff-0.2.1 → parity_diff-0.2.3}/README.md

@@ -87,6 +87,7 @@ pip install "parity-diff[all]"        # every engine
 pip install "parity-diff[duckdb]"     # DuckDB only — no other driver pulled in
 pip install "parity-diff[postgres]"   # PostgreSQL only
 pip install "parity-diff[mysql]"      # MySQL only
+pip install "parity-diff[snowflake]"  # Snowflake only
 ```
 
 > The PyPI distribution is `parity-diff` — plain `parity` is squatted by an
@@ -248,7 +249,8 @@ stated plainly rather than buried.
 | PostgreSQL | supported (tested against 16 and 18) |
 | DuckDB | supported (tested against 1.5) |
 | MySQL | supported (tested against 8.0) |
-| Snowflake, BigQuery, Redshift | not yet — see `CONTRIBUTING.md`, a dialect is ~80 lines |
+| Snowflake | supported (verified live on AWS; `pip install "parity-diff[snowflake]"`) |
+| BigQuery, Redshift | not yet — see `CONTRIBUTING.md`, a dialect is ~80 lines |
 
 ## Scope
 
@@ -296,7 +298,10 @@ way it is. `ROADMAP.md` is what is done and what comes next.
 
 ## Changelog
 
-See `CHANGELOG.md`.
+Latest release **0.2.1** — a generative test suite (property-based, oracle, and
+cross-engine fuzzing) and the correctness fix it surfaced: a same-content
+insert-plus-delete falling in one bucket that could previously read as
+identical. See `CHANGELOG.md` for the full history.
 
 ## License
 

{parity_diff-0.2.1 → 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.1"
+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"
@@ -37,7 +37,11 @@ dependencies = []
 duckdb = ["duckdb>=1.0"]
 postgres = ["psycopg[binary]>=3.1"]
 mysql = ["mysql-connector-python>=8.0"]
-all = ["duckdb>=1.0", "psycopg[binary]>=3.1", "mysql-connector-python>=8.0"]
+snowflake = ["snowflake-connector-python>=3.0"]
+all = [
+    "duckdb>=1.0", "psycopg[binary]>=3.1",
+    "mysql-connector-python>=8.0", "snowflake-connector-python>=3.0",
+]
 # Test-only dependencies, kept out of every runtime extra. Hypothesis drives
 # the generative suite (tests/test_properties.py); the core stays stdlib-only.
 test = ["hypothesis>=6.0"]
@@ -64,6 +68,7 @@ markers = [
     "postgres: requires a reachable PostgreSQL server",
     "mysql: requires a reachable MySQL server",
     "duckdb: requires the duckdb driver",
+    "snowflake: requires a reachable Snowflake account (PARITY_TEST_SNOWFLAKE)",
 ]
 
 [tool.ruff]
@@ -105,6 +110,7 @@ ignore = [
 "src/parity/dialects/base.py" = ["S608"]
 "src/parity/dialects/postgres_dialect.py" = ["S608"]
 "src/parity/dialects/mysql_dialect.py" = ["S608"]
+"src/parity/dialects/snowflake_dialect.py" = ["S608"]
 # proof.py is kept close to the original author's script so it stays readable
 # next to the findings it produced; its terse one-line style is deliberate.
 "demo/proof.py" = ["E401", "E402", "E701", "E702", "B007", "S311", "S608"]

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

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

{parity_diff-0.2.1 → parity_diff-0.2.3}/src/parity/dialects/base.py

@@ -551,10 +551,14 @@ def get_dialect(
         from parity.dialects.mysql_dialect import MySQLDialect
 
         dialect = MySQLDialect(float_scale=float_scale, side=side)
+    elif scheme in ("snowflake",):
+        from parity.dialects.snowflake_dialect import SnowflakeDialect
+
+        dialect = SnowflakeDialect(float_scale=float_scale, side=side)
     else:
         raise ValueError(
             f"[side {side}] no dialect for scheme {scheme!r}. "
-            f"Supported: duckdb, postgres, mysql."
+            f"Supported: duckdb, postgres, mysql, snowflake."
         )
     try:
         dialect.connect(connection_string)

parity_diff-0.2.3/src/parity/dialects/snowflake_dialect.py

@@ -0,0 +1,231 @@
+"""Snowflake dialect.
+
+Verified against a live Snowflake account (AWS eu-central-2, 2026-09-07): the
+hash constant agrees, a full-table checksum matches DuckDB byte-for-byte over
+5,000 mixed-type rows, and `tests/test_snowflake.py` passes end to end - the
+identical check, a changed decimal, a deleted row, and the NULL-versus-empty
+trap. It was first written against Snowflake's documentation; the live run then
+turned up the one thing docs could not: Snowflake upper-cases unquoted
+identifiers, so the engine had to match keys and columns case-insensitively
+(see `_fold_columns` in engine.py) for a Snowflake table to diff against a
+lower-casing engine at all.
+
+The Snowflake-specific decisions, each confirmed by that run:
+
+- **No `CONV` and no bit-cast for the hash.** Snowflake has neither, but
+  `MD5_NUMBER_UPPER64(x)` returns the top 64 bits of the digest as an unsigned
+  number, and the top 60 bits - the first 15 hex characters the other engines
+  fold - are `FLOOR(that / 16)`. That should equal 648541476951500027 for
+  `'abc'`; a test must pin it.
+- **Integer and decimal both report as `NUMBER`.** `information_schema` tells
+  them apart only by `numeric_scale` (0 = integer), so `columns()` reads the
+  scale rather than trusting `data_type` - otherwise an integer key would be
+  rendered as `42.000000` and never match another engine's `42`.
+- **The NULL sentinel is built from `CHR(92)`.** Snowflake interprets
+  backslash escapes in string literals, so a literal `'\\N'` is unsafe the same
+  way it was on MySQL.
+- **One-snapshot isolation is not available.** Snowflake offers only READ
+  COMMITTED, so unlike PostgreSQL the walk cannot be pinned to a single
+  snapshot; a source table mutating mid-diff can produce an inconsistent
+  result. This is a genuine limitation, documented rather than hidden.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import parse_qs, unquote, urlparse
+
+from parity.dialects.base import Dialect, sql_literal
+from parity.types import Column, LogicalType
+
+
+class SnowflakeDialect(Dialect):
+    name = "snowflake"
+    #: Set from the connection's schema segment. Snowflake folds unquoted names
+    #: to upper case, so an unqualified table is looked up in the connected
+    #: schema as stored.
+    default_schema = "PUBLIC"
+
+    def connect(self, connection_string: str) -> None:  # pragma: no cover
+        """Open a connection, pinned to UTC.
+
+        URL grammar mirrors SQLAlchemy's Snowflake dialect:
+        ``snowflake://user:password@account/database/schema?warehouse=wh&role=r``
+
+        Note the honest gap: Snowflake supports only READ COMMITTED, so there
+        is no equivalent of PostgreSQL's REPEATABLE READ - the diff cannot hold
+        one snapshot across the walk. UTC is still pinned so timestamps render
+        deterministically.
+        """
+        import snowflake.connector
+
+        url = urlparse(connection_string)
+        parts = [p for p in url.path.split("/") if p]
+        database = parts[0] if parts else None
+        schema = parts[1] if len(parts) > 1 else None
+        params = parse_qs(url.query)
+
+        def opt(key: str) -> str | None:
+            """First value of a query parameter, or None."""
+            values = params.get(key)
+            return values[0] if values else None
+        if schema:
+            self.default_schema = schema
+
+        self._conn = snowflake.connector.connect(
+            account=url.hostname,
+            user=unquote(url.username) if url.username else None,
+            password=unquote(url.password) if url.password else None,
+            database=database,
+            schema=schema,
+            warehouse=opt("warehouse"),
+            role=opt("role"),
+            autocommit=True,
+        )
+        cur = self._conn.cursor()
+        try:
+            # Timestamps render through this; pin it so two accounts in
+            # different regions cannot disagree on the same instant.
+            cur.execute("alter session set timezone = 'UTC'")
+        finally:
+            cur.close()
+
+    def close(self) -> None:  # pragma: no cover
+        """Close the connection."""
+        self._conn.close()
+
+    def query(self, sql: str) -> list[tuple[Any, ...]]:  # pragma: no cover
+        """Run `sql` and return every row as a list of tuples."""
+        cur = self._conn.cursor()
+        try:
+            cur.execute(sql)
+            return list(cur.fetchall())
+        finally:
+            cur.close()
+
+    def columns(self, table: str) -> list[Column]:
+        """Introspect columns, reading numeric_scale to split NUMBER.
+
+        Snowflake reports every integer and decimal as `NUMBER`; only the scale
+        distinguishes them, so this cannot use the shared `columns()`.
+        """
+        schema, name = self.split_table(table, self.default_schema)
+        rows = self.query(
+            "select column_name, data_type, numeric_scale "
+            "from information_schema.columns "
+            f"where table_schema = {sql_literal(schema)} "
+            f"and table_name = {sql_literal(name)} "
+            "order by ordinal_position"
+        )
+        if not rows:
+            raise self._err(self._not_found(table, schema, name))
+        return [
+            Column(str(r[0]), map_type_snowflake(str(r[1]), r[2]), str(r[1]))
+            for r in rows
+        ]
+
+    def quote(self, identifier: str) -> str:
+        """Wrap an identifier in double quotes, doubling any it contains.
+
+        The injection boundary - names arrive from the command line. Snowflake
+        stores unquoted names upper-cased, so a lower-case `"id"` will not match
+        a column created as `ID`; the tool sidesteps this by quoting the exact
+        names `columns()` read back.
+        """
+        return '"' + identifier.replace('"', '""') + '"'
+
+    # ----------------------------------------------------------- rendering
+
+    def null_sentinel_sql(self) -> str:
+        r"""Build the sentinel from CHR(92), not a `\N` literal.
+
+        Snowflake processes backslash escapes in string literals, so a literal
+        is unsafe; CHR(92) is a backslash unconditionally and CHR returns a
+        varchar (not binary), so the coalesce stays text.
+        """
+        return "(chr(92) || 'N')"
+
+    def normalize(self, column: Column) -> str:
+        """Render one column as canonical text, null-safe.
+
+        DECIMAL/FLOAT match DuckDB's path - cast to NUMBER(38, scale) then to
+        text - so `1.5` becomes `'1.500000'`. Non-finite floats are a known
+        unverified gap: Snowflake's Inf/NaN detection differs from the other
+        engines and must be checked against a real account before this is
+        trusted for FLOAT columns holding them.
+        """
+        c = self.quote(column.name)
+        t = column.logical_type
+        if t is LogicalType.INTEGER:
+            expr = f"cast({c} as varchar)"
+        elif t in (LogicalType.DECIMAL, LogicalType.FLOAT):
+            expr = f"cast(cast({c} as number(38,{self.float_scale})) as varchar)"
+        elif t is LogicalType.BOOLEAN:
+            expr = f"case when {c} then 'true' when not {c} then 'false' end"
+        elif t is LogicalType.DATE:
+            expr = f"to_char({c}, 'YYYY-MM-DD')"
+        elif t is LogicalType.TIMESTAMP:
+            # FF6 is microseconds, matching the other engines' six digits.
+            expr = f"to_char({c}, 'YYYY-MM-DD HH24:MI:SS.FF6')"
+        else:
+            expr = f"cast({c} as varchar)"
+        return f"coalesce({expr}, {self.null_sentinel_sql()})"
+
+    def hash_expr(self, text_expr: str) -> str:
+        """Fold canonical text into a positive 60-bit integer.
+
+        `MD5_NUMBER_UPPER64` is the top 64 bits of the digest as an unsigned
+        number; the top 60 bits - the first 15 hex characters the other engines
+        take - are that floor-divided by 16.
+        """
+        return f"floor(md5_number_upper64({text_expr}) / 16)"
+
+    def int_div(self, numerator: str, denominator: str) -> str:
+        """Truncating integer division.
+
+        Operands are NUMBER (via `wide_int`), so `/` is exact decimal and
+        `floor` truncates exactly for the non-negative operands used here -
+        unlike a float `/`, which CLAUDE.md 4.5 warns loses precision.
+        """
+        return f"floor(({numerator}) / ({denominator}))"
+
+    def wide_int(self, expr: str) -> str:
+        """Widen past 64 bits before arithmetic. NUMBER(38,0) holds 38 digits,
+        which the key offset cannot overflow."""
+        return f"cast(({expr}) as number(38,0))"
+
+    def sum_wide(self, expr: str) -> str:
+        """Sum row hashes without overflowing, and return 0 for an empty group.
+
+        NUMBER(38,0) is far beyond any row count times 2^60.
+        """
+        return f"coalesce(sum(cast(({expr}) as number(38,0))), 0)"
+
+
+def map_type_snowflake(raw: str, numeric_scale: Any) -> LogicalType:
+    """Map a Snowflake type onto a logical category.
+
+    Snowflake reports both integers and decimals as `NUMBER`; only the scale
+    tells them apart, so it is passed in. A NULL scale (non-numeric type) is
+    treated as not-an-integer.
+    """
+    t = raw.upper().split("(")[0].strip()
+    if t in {"NUMBER", "DECIMAL", "NUMERIC"}:
+        try:
+            scale = int(numeric_scale) if numeric_scale is not None else 6
+        except (TypeError, ValueError):
+            scale = 6
+        return LogicalType.INTEGER if scale == 0 else LogicalType.DECIMAL
+    if t in {"INT", "INTEGER", "BIGINT", "SMALLINT", "TINYINT", "BYTEINT"}:
+        return LogicalType.INTEGER  # aliases that may appear via DATA_TYPE_ALIAS
+    if t in {"FLOAT", "FLOAT4", "FLOAT8", "DOUBLE", "DOUBLE PRECISION", "REAL"}:
+        return LogicalType.FLOAT
+    if t == "BOOLEAN":
+        return LogicalType.BOOLEAN
+    if t == "DATE":
+        return LogicalType.DATE
+    if t.startswith("TIMESTAMP") or t == "DATETIME":
+        return LogicalType.TIMESTAMP
+    if t in {"TEXT", "VARCHAR", "CHAR", "CHARACTER", "STRING"}:
+        return LogicalType.STRING
+    return LogicalType.UNKNOWN

{parity_diff-0.2.1 → parity_diff-0.2.3}/src/parity/engine.py

@@ -132,6 +132,34 @@ def _key_order(key: int | str) -> tuple[int, int | str]:
     return (1, key) if isinstance(key, str) else (0, key)
 
 
+def _fold_columns(
+    columns: list[Column], side: str, table: str
+) -> dict[str, Column]:
+    """Index a side's columns by case-folded name, for cross-engine matching.
+
+    Two engines fold unquoted identifiers to different cases, so a column is
+    the same column on both sides when its *folded* name matches. Each side
+    still holds its own `Column`, whose real stored name is what gets quoted
+    into SQL - only the matching is case-insensitive, never the rendering.
+
+    A table with two columns that differ only in case (possible only through
+    quoted identifiers) cannot be folded unambiguously, so it is refused with
+    a clear message rather than silently dropping one of them.
+    """
+    out: dict[str, Column] = {}
+    for c in columns:
+        fold = c.name.casefold()
+        if fold in out:
+            raise ValueError(
+                f"[side {side}] {table} has two columns that differ only in "
+                f"case: {out[fold].name!r} and {c.name!r}. parity matches "
+                f"columns case-insensitively across engines and cannot tell "
+                f"these apart - rename or quote one, or diff a view that does."
+            )
+        out[fold] = c
+    return out
+
+
 def _resolve_key(
     key: str | Sequence[str],
     cols_a: dict[str, Column],
@@ -149,22 +177,27 @@ def _resolve_key(
 
     Returns one spec per side. They agree on shape but hold each side's own
     `Column` objects, because a column can be `text` on one side and
-    `varchar` on the other and each dialect renders its own.
+    `varchar` on the other and each dialect renders its own - and the key can
+    be `ID` on one side and `id` on the other, since `--key` is one name that
+    has to resolve against whatever case each engine stored.
+
+    `cols_a` and `cols_b` are keyed by case-folded name (see `_fold_columns`),
+    so the same `--key id` finds `id` on PostgreSQL and `ID` on Snowflake.
     """
     names = [key] if isinstance(key, str) else list(dict.fromkeys(key))
     if not names:
         raise ValueError("--key needs at least one column")
 
     for side, table, cols in (("A", a_table, cols_a), ("B", b_table, cols_b)):
-        missing = [n for n in names if n not in cols]
+        missing = [n for n in names if n.casefold() not in cols]
         if missing:
             raise ValueError(
                 f"[side {side}] key column(s) {missing} not in {table}. "
-                f"Columns are: {sorted(cols)}"
+                f"Columns are: {sorted(c.name for c in cols.values())}"
             )
 
-    a_key = tuple(cols_a[n] for n in names)
-    b_key = tuple(cols_b[n] for n in names)
+    a_key = tuple(cols_a[n.casefold()] for n in names)
+    b_key = tuple(cols_b[n.casefold()] for n in names)
 
     # Hash unless it is one integer column on both sides. A single-column key
     # that is integer on one side and text on the other has to be hashed too,
@@ -194,21 +227,29 @@ def _resolve_key(
 def _select_columns(
     cols_a: dict[str, Column],
     cols_b: dict[str, Column],
-    key_names: Sequence[str],
+    key_folds: set[str],
     columns: Sequence[str] | None,
     exclude: Sequence[str],
     warnings: list[str],
 ) -> list[str]:
     """Decide which columns to compare, explaining anything dropped.
 
+    `cols_a`/`cols_b` are keyed by case-folded name and the returned list is
+    folded names too, so matching is case-insensitive across engines (see
+    `_fold_columns`); the caller maps each folded name back to that side's real
+    `Column`. Messages echo the user's own tokens, or side A's stored name, so
+    a folded lookup never leaks a lower-cased identifier back at the reader.
+
     Key columns are never compared: they are how rows are matched up, not
     something compared between them.
     """
-    keys = set(key_names)
-    both = (set(cols_a) & set(cols_b)) - keys
-    excluded = set(exclude)
+    both = (set(cols_a) & set(cols_b)) - key_folds
+    excluded = {e.casefold() for e in exclude}
 
-    unknown_exclude = excluded - set(cols_a) - set(cols_b)
+    unknown_exclude = [
+        e for e in dict.fromkeys(exclude)
+        if e.casefold() not in cols_a and e.casefold() not in cols_b
+    ]
     if unknown_exclude:
         warnings.append(
             f"--exclude named columns that exist on neither side: "
@@ -217,13 +258,19 @@ def _select_columns(
 
     shared = sorted(both - excluded)
     if columns:
-        requested = list(dict.fromkeys(columns))  # de-duplicate, keep order
-        nowhere = [c for c in requested if c not in cols_a and c not in cols_b]
-        one_side = [c for c in requested if c not in nowhere and c not in both]
-        dropped = [c for c in requested if c in excluded]
+        # Fold for matching, but keep the first spelling the user gave each
+        # column so error messages read back their own words, not a fold.
+        token: dict[str, str] = {}
+        for c in columns:
+            token.setdefault(c.casefold(), c)
+        req = list(token)  # folded, de-duplicated, order kept
+        nowhere_folds = {f for f in req if f not in cols_a and f not in cols_b}
+        nowhere = [token[f] for f in req if f in nowhere_folds]
+        one_side = [token[f] for f in req if f not in nowhere_folds and f not in both]
+        dropped = [token[f] for f in req if f in excluded]
         # Order matters: key columns are present on both sides but excluded
         # from `both`, so they would otherwise be misreported as one-sided.
-        if named_keys := [c for c in requested if c in keys]:
+        if named_keys := [token[f] for f in req if f in key_folds]:
             raise ValueError(
                 f"--columns named the key column(s) {named_keys}; the key is "
                 f"how rows are matched up, not something compared between them"
@@ -238,26 +285,28 @@ def _select_columns(
             raise ValueError(
                 f"--columns and --exclude both name: {dropped}"
             )
-        shared = [c for c in shared if c in set(requested)]
+        shared = [f for f in shared if f in set(req)]
 
-    for side, only in (
-        ("A", sorted(set(cols_a) - set(cols_b) - keys)),
-        ("B", sorted(set(cols_b) - set(cols_a) - keys)),
+    for side, cols, only in (
+        ("A", cols_a, sorted(set(cols_a) - set(cols_b) - key_folds)),
+        ("B", cols_b, sorted(set(cols_b) - set(cols_a) - key_folds)),
     ):
         if only:
-            warnings.append(f"not compared, present only on side {side}: {only}")
+            names = sorted(cols[f].name for f in only)
+            warnings.append(f"not compared, present only on side {side}: {names}")
 
     # A column whose logical type differs between sides renders through a
     # different canonical encoding, so every row would report as changed. That
     # looks like a catastrophic data difference but is really a schema
     # difference, so name it explicitly.
-    for name in shared:
-        ta, tb = cols_a[name].logical_type, cols_b[name].logical_type
+    for f in shared:
+        name = cols_a[f].name
+        ta, tb = cols_a[f].logical_type, cols_b[f].logical_type
         if ta is tb or {ta, tb} <= _NUMERIC_EQUIVALENT:
             continue
         warnings.append(
-            f"column {name!r} is {cols_a[name].raw_type or ta.value} on side A "
-            f"but {cols_b[name].raw_type or tb.value} on side B; values are "
+            f"column {name!r} is {cols_a[f].raw_type or ta.value} on side A "
+            f"but {cols_b[f].raw_type or tb.value} on side B; values are "
             f"compared as text and will very likely all differ"
         )
 
@@ -267,21 +316,21 @@ def _select_columns(
     # are pinned to UTC, so a migration that stored UTC compares clean. One
     # that stored local wall-clock reports *every* row as different, and
     # without this line there is nothing pointing at which axis to look along.
-    for name in shared:
-        aware_a = _is_tz_aware(cols_a[name])
-        if aware_a is _is_tz_aware(cols_b[name]):
+    for f in shared:
+        aware_a = _is_tz_aware(cols_a[f])
+        if aware_a is _is_tz_aware(cols_b[f]):
             continue
         aware, naive = ("A", "B") if aware_a else ("B", "A")
         warnings.append(
-            f"column {name!r} is timezone-aware on side {aware} but not on "
-            f"side {naive}; both are read in UTC, so a migration that stored "
-            f"local wall-clock time rather than UTC will show every row as "
-            f"different"
+            f"column {cols_a[f].name!r} is timezone-aware on side {aware} but "
+            f"not on side {naive}; both are read in UTC, so a migration that "
+            f"stored local wall-clock time rather than UTC will show every row "
+            f"as different"
         )
 
     unknown = sorted(
-        {n for n in shared if cols_a[n].logical_type is LogicalType.UNKNOWN}
-        | {n for n in shared if cols_b[n].logical_type is LogicalType.UNKNOWN}
+        {cols_a[f].name for f in shared if cols_a[f].logical_type is LogicalType.UNKNOWN}
+        | {cols_a[f].name for f in shared if cols_b[f].logical_type is LogicalType.UNKNOWN}
     )
     if unknown:
         warnings.append(
@@ -343,8 +392,15 @@ def diff(
             return _gather(fa, fb)
 
         cols_a_list, cols_b_list = both("columns")
-        cols_a = {c.name: c for c in cols_a_list}
-        cols_b = {c.name: c for c in cols_b_list}
+        # Match identifiers case-insensitively across the two sides. Engines
+        # fold unquoted names differently - Snowflake upper-cases, PostgreSQL
+        # and DuckDB lower-case - so a Postgres `amount` and its Snowflake
+        # `AMOUNT` are the same column and must line up, or the headline use
+        # case (diffing a table against its migration) finds no shared columns
+        # and no usable key. The map is keyed by the folded name; each side
+        # keeps its own Column, with its real stored name, for quoting in SQL.
+        cols_a = _fold_columns(cols_a_list, "A", a_table)
+        cols_b = _fold_columns(cols_b_list, "B", b_table)
         # Introspection is metadata, not a scan; do not inflate the query count
         # users read as "how much work did this cost".
         stats.queries -= 2
@@ -352,12 +408,13 @@ def diff(
         key_a, key_b = _resolve_key(
             key, cols_a, cols_b, a_table, b_table, warnings
         )
+        key_folds = {c.name.casefold() for c in key_a.columns}
 
         shared = _select_columns(
-            cols_a, cols_b, key_a.names, columns, exclude, warnings
+            cols_a, cols_b, key_folds, columns, exclude, warnings
         )
-        a_cols = [cols_a[c] for c in shared]
-        b_cols = [cols_b[c] for c in shared]
+        a_cols = [cols_a[f] for f in shared]
+        b_cols = [cols_b[f] for f in shared]
 
         ks_a, ks_b = both("key_stats", key_a, _args_b=(key_b,))