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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parity-diff
-Version: 0.2.1
+Version: 0.2.2
 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.2}/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.2}/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.2"
 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.2}/src/parity/__init__.py

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

{parity_diff-0.2.1 → parity_diff-0.2.2}/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.2/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.2}/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,))
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parity-diff
-Version: 0.2.1
+Version: 0.2.2
 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.2}/src/parity_diff.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/parity/dialects/base.py
 src/parity/dialects/duckdb_dialect.py
 src/parity/dialects/mysql_dialect.py
 src/parity/dialects/postgres_dialect.py
+src/parity/dialects/snowflake_dialect.py
 src/parity_diff.egg-info/PKG-INFO
 src/parity_diff.egg-info/SOURCES.txt
 src/parity_diff.egg-info/dependency_links.txt
@@ -26,4 +27,6 @@ tests/test_engine.py
 tests/test_fuzz_encoding.py
 tests/test_integration.py
 tests/test_mysql.py
-tests/test_properties.py
+tests/test_properties.py
+tests/test_snowflake.py
+tests/test_snowflake_offline.py

{parity_diff-0.2.1 → parity_diff-0.2.2}/src/parity_diff.egg-info/requires.txt

@@ -3,6 +3,7 @@
 duckdb>=1.0
 psycopg[binary]>=3.1
 mysql-connector-python>=8.0
+snowflake-connector-python>=3.0
 
 [duckdb]
 duckdb>=1.0
@@ -13,5 +14,8 @@ mysql-connector-python>=8.0
 [postgres]
 psycopg[binary]>=3.1
 
+[snowflake]
+snowflake-connector-python>=3.0
+
 [test]
 hypothesis>=6.0

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

@@ -67,6 +67,31 @@ def _mysql_available() -> tuple[bool, str]:
     return True, ""
 
 
+#: Snowflake, if one is configured. There is no local Snowflake and no free
+#: service container, so this is opt-in via an env var and skips otherwise -
+#: it never runs in CI, only when someone points it at a real account.
+SNOWFLAKE_URL = os.environ.get("PARITY_TEST_SNOWFLAKE", "")
+
+
+def _snowflake_available() -> tuple[bool, str]:
+    """Can we reach Snowflake? Returns (yes/no, why not).
+
+    Gated on the env var first so an unconfigured run skips instantly without
+    importing a driver or opening a network connection.
+    """
+    if not SNOWFLAKE_URL:
+        return False, "PARITY_TEST_SNOWFLAKE is not set"
+    try:
+        import snowflake.connector  # noqa: F401 - importing it is the probe
+    except ImportError:  # pragma: no cover - depends on install extras
+        return False, "snowflake-connector-python is not installed"
+    try:
+        get_dialect(SNOWFLAKE_URL, side="A").close()
+    except Exception as exc:  # pragma: no cover - depends on the account
+        return False, f"no Snowflake at the configured URL: {type(exc).__name__}"
+    return True, ""
+
+
 def _duckdb_available() -> tuple[bool, str]:
     """Is the duckdb driver installed? Returns (yes/no, why not)."""
     try:
@@ -94,6 +119,15 @@ def mysql_url() -> str:
     return MYSQL_URL
 
 
+@pytest.fixture(scope="session")
+def snowflake_url() -> str:
+    """The Snowflake endpoint, or skip if none is configured/reachable."""
+    ok, why = _snowflake_available()
+    if not ok:
+        pytest.skip(why)
+    return SNOWFLAKE_URL
+
+
 @pytest.fixture(scope="session")
 def duckdb_path(tmp_path_factory: pytest.TempPathFactory) -> str:
     """A scratch path for a DuckDB file, unique to this test session."""
@@ -128,3 +162,8 @@ def open_pg(url: str, side: str = "A", float_scale: int = 6):
 def open_mysql(url: str, side: str = "A", float_scale: int = 6):
     """Open a read-only, UTC-pinned MySQL dialect."""
     return get_dialect(url, side=side, float_scale=float_scale)
+
+
+def open_snowflake(url: str, side: str = "A", float_scale: int = 6):
+    """Open a UTC-pinned Snowflake dialect (DRAFT - see snowflake_dialect.py)."""
+    return get_dialect(url, side=side, float_scale=float_scale)

{parity_diff-0.2.1 → parity_diff-0.2.2}/tests/test_engine.py

@@ -884,3 +884,54 @@ def test_identity_and_bucket_are_different_expressions_when_hashed():
     assert d.key_bucket(text) != d.key_identity(text)
     assert "md5" in d.key_bucket(text)
     assert "md5" not in d.key_identity(text)
+
+
+# ---------------------------------------------------------------------------
+# Case-insensitive identifier matching across engines.
+# ---------------------------------------------------------------------------
+
+
+def _cased(names, rows, key_name, side):
+    """A fake side whose key and columns carry the given (cased) names."""
+    cols = [Column(n, LogicalType.STRING, "varchar") for n in names]
+    return FakeDialect(
+        DictTable(cols, dict(rows)),
+        side=side,
+        key_type_override=Column(key_name, LogicalType.INTEGER, "bigint"),
+    )
+
+
+def test_columns_and_key_match_across_engines_that_fold_case_differently():
+    """Snowflake upper-cases unquoted identifiers; PostgreSQL and DuckDB
+    lower-case them. The same column and key must line up across the two sides
+    regardless of case, or a table and its migration would share no columns and
+    no usable key - the headline comparison this tool exists for.
+    """
+    rows = {1: ("10", "ok"), 2: ("20", "paid"), 3: ("30", "void")}
+    upper = _cased(["AMOUNT", "STATUS"], rows, "ID", "A")   # Snowflake-style
+    lower = _cased(["amount", "status"], rows, "id", "B")   # Postgres-style
+
+    # Identical data, differently-cased identifiers -> identical, zero download.
+    same = diff(upper, lower, "t", "t", "id")
+    assert same.identical, same.diffs
+    assert same.stats.rows_downloaded == 0
+
+    # A planted change is still found, and the key resolves even when --key is
+    # given in yet another case than either side stores.
+    changed_lower = _cased(["amount", "status"], {**rows, 2: ("999", "paid")}, "id", "B")
+    changed = diff(upper, changed_lower, "t", "t", "Id")
+    assert [(d.key, d.kind) for d in changed.diffs] == [(2, "different")]
+    # The differing column is named as side A stores it.
+    assert changed.diffs[0].columns == ["AMOUNT"]
+
+
+def test_two_columns_differing_only_in_case_are_refused():
+    """A table with `Col` and `col` cannot be folded unambiguously, so parity
+    refuses it with a clear message rather than silently dropping one.
+    """
+    cols = [Column("Amount", LogicalType.STRING, "varchar"),
+            Column("amount", LogicalType.STRING, "varchar")]
+    a = FakeDialect(DictTable(cols, {1: ("a", "b")}), side="A")
+    b = FakeDialect(DictTable(list(COLS), {1: ("a", "b")}), side="B")
+    with pytest.raises(ValueError, match="differ only in case"):
+        diff(a, b, "t", "t", "id")

parity_diff-0.2.2/tests/test_snowflake.py

@@ -0,0 +1,181 @@
+"""Snowflake against DuckDB, end to end - the verification the draft needs.
+
+DRAFT dialect (see src/parity/dialects/snowflake_dialect.py): Snowflake earns
+the word "supported" only once this file passes against a live account, byte
+for byte with DuckDB. It is the Snowflake twin of test_mysql.py, and the only
+Snowflake-specific content is the fixture DDL and the three decisions the draft
+made: the row hash goes through FLOOR(MD5_NUMBER_UPPER64(x)/16), integer and
+decimal are split by numeric_scale, and the NULL sentinel is CHR(92)||'N'. Each
+is verified below by the values agreeing with DuckDB, not by reading the SQL.
+
+Skips cleanly unless PARITY_TEST_SNOWFLAKE points at a reachable account, so it
+never runs in CI and never spends warehouse credits on its own. Run it with:
+
+    pip install -e ".[duckdb,snowflake]" pytest
+    set PARITY_TEST_SNOWFLAKE=snowflake://user:pw@account/PARITY_TEST/ENC?warehouse=PARITY_WH&role=PARITY_RO
+    pytest tests/test_snowflake.py -v
+"""
+
+from __future__ import annotations
+
+import pytest
+from conftest import duckdb_write, open_duckdb, open_snowflake
+
+from parity.engine import diff
+
+pytestmark = pytest.mark.snowflake
+
+N = 5_000
+
+#: Side B: the DuckDB reference. Types line up with the Snowflake table below -
+#: a real boolean on both sides (Snowflake has one, unlike MySQL), a decimal,
+#: a naive timestamp - so any difference the tool reports is a real one, not a
+#: type mismatch.
+DUCKDB_TABLE = f"""
+create table orders as
+select i::bigint                                             as id,
+       (i % 97)::integer                                     as customer_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       as status,
+       (i % 11 = 0)                                          as is_refunded,
+       (timestamp '2024-01-01 00:00:00'
+            + (i % 86400) * interval '1 second')             as created_at,
+       case when i % 13 = 0 then null
+            else 'note ' || i::varchar end                   as note
+from generate_series(1, {N}) as s(i)
+"""
+
+#: Side A: the Snowflake table. NUMBER(38,0) reports as an integer only because
+#: its scale is 0 - the draft's columns() reads numeric_scale to tell it from
+#: the decimal `amount`, and a bug there would render the key as `1.000000`.
+SNOWFLAKE_TABLE = """
+create or replace table orders (
+    id          number(38,0),
+    customer_id number(38,0),
+    amount      number(12,2),
+    status      varchar,
+    is_refunded boolean,
+    created_at  timestamp_ntz,
+    note        varchar
+)
+"""
+
+#: GENERATOR makes N rows; row_number() turns them into a stable 1..N key. id
+#: is materialised in the subquery so each derived column reads one fixed value
+#: rather than calling the sequence generator again mid-row.
+SNOWFLAKE_FILL = f"""
+insert into orders
+select id,
+       mod(id, 97),
+       (mod(id * 7, 100000) / 100.0),
+       case when mod(id, 3) = 0 then 'paid'
+            when mod(id, 3) = 1 then 'open' else 'void' end,
+       (mod(id, 11) = 0),
+       dateadd(second, mod(id, 86400), '2024-01-01 00:00:00'::timestamp_ntz),
+       case when mod(id, 13) = 0 then null else 'note ' || id::varchar end
+from (
+    select row_number() over (order by seq4()) as id
+    from table(generator(rowcount => {N}))
+)
+"""
+
+
+@pytest.fixture(scope="module")
+def duck_path(tmp_path_factory) -> str:
+    """Side B: the DuckDB reference table, built once and opened read-only."""
+    path = str(tmp_path_factory.mktemp("snowflake_it") / "b.duckdb")
+    con = duckdb_write(path)
+    try:
+        con.execute(DUCKDB_TABLE)
+    finally:
+        con.close()
+    return path
+
+
+def _build_snowflake(snowflake_url: str, plant: str | None) -> None:
+    """Create the Snowflake `orders` table, optionally with one planted defect.
+
+    Uses its own connection and commits (autocommit is on), because the dialect
+    opened later must see the data. This is the *only* place the tests write to
+    Snowflake; the parity dialect itself issues SELECT only.
+    """
+    a = open_snowflake(snowflake_url, side="A")
+    cur = a._conn.cursor()
+    try:
+        cur.execute(SNOWFLAKE_TABLE)
+        cur.execute("truncate table orders")
+        cur.execute(SNOWFLAKE_FILL)
+        if plant == "changed":
+            cur.execute("update orders set amount = amount + 0.01 where id = 1234")
+        elif plant == "deleted":
+            cur.execute("delete from orders where id = 777")
+        elif plant == "null_trap":
+            # id 13 is a multiple of 13, so `note` is NULL on the DuckDB side;
+            # setting it to '' here plants the NULL-versus-empty-string trap.
+            cur.execute("update orders set note = '' where id = 13")
+    finally:
+        cur.close()
+        a.close()
+
+
+def _diff(snowflake_url: str, duck_path: str, **kwargs):
+    """Diff the Snowflake orders table against the DuckDB one."""
+    a = open_snowflake(snowflake_url, side="A")
+    b = open_duckdb(duck_path, side="B")
+    try:
+        # Side A names the table as Snowflake stored it (unquoted -> ORDERS);
+        # the key is given lower-case on purpose, to exercise the engine's
+        # case-insensitive key/column matching against Snowflake's ID/AMOUNT.
+        return diff(a, b, "ORDERS", "main.orders", "id", **kwargs)
+    finally:
+        a.close()
+        b.close()
+
+
+def test_the_hash_constant_agrees_with_the_other_engines(snowflake_url):
+    """The whole cross-engine contract in one number.
+
+    Snowflake reaches it through FLOOR(MD5_NUMBER_UPPER64(x)/16), a fourth
+    distinct path after PostgreSQL's bit-cast, DuckDB's hex-cast and MySQL's
+    CONV. If this disagrees, nothing else can be trusted.
+    """
+    a = open_snowflake(snowflake_url, side="A")
+    try:
+        got = a.query(f"select {a.hash_expr(chr(39) + 'abc' + chr(39))}")[0][0]
+        assert int(got) == 648541476951500027
+    finally:
+        a.close()
+
+
+def test_identical_tables_match_and_download_nothing(snowflake_url, duck_path):
+    """The headline claim, cross-engine: agreement moves zero rows."""
+    _build_snowflake(snowflake_url, plant=None)
+    result = _diff(snowflake_url, duck_path)
+    assert result.identical
+    assert result.diffs == []
+    assert result.stats.rows_downloaded == 0
+
+
+def test_a_changed_decimal_is_found_on_exactly_that_row(snowflake_url, duck_path):
+    """A one-cent change on one row is reported as that row, that column."""
+    _build_snowflake(snowflake_url, plant="changed")
+    result = _diff(snowflake_url, duck_path)
+    assert [(d.key, d.kind) for d in result.diffs] == [(1234, "different")]
+    # Columns are reported as side A (Snowflake) stores them - upper-cased.
+    assert result.diffs[0].columns == ["AMOUNT"]
+
+
+def test_a_deleted_row_is_reported_only_in_b(snowflake_url, duck_path):
+    """A row missing from Snowflake is only_in_b, not an error."""
+    _build_snowflake(snowflake_url, plant="deleted")
+    result = _diff(snowflake_url, duck_path)
+    assert [(d.key, d.kind) for d in result.diffs] == [(777, "only_in_b")]
+
+
+def test_null_versus_empty_string_is_caught(snowflake_url, duck_path):
+    """The trap naive tools miss: NULL on one side, '' on the other."""
+    _build_snowflake(snowflake_url, plant="null_trap")
+    result = _diff(snowflake_url, duck_path)
+    assert [(d.key, d.kind) for d in result.diffs] == [(13, "different")]
+    assert result.diffs[0].columns == ["NOTE"]

parity_diff-0.2.2/tests/test_snowflake_offline.py

@@ -0,0 +1,113 @@
+"""Offline unit tests for the Snowflake dialect's SQL rendering.
+
+The live end-to-end proof is `test_snowflake.py`, which needs a real account and
+so cannot run in CI. These tests pin the *SQL the dialect generates* - every
+rendering decision from CLAUDE.md section 4, in pure string form - so the logic
+stays covered on every push without a database. Only `connect`/`close`/`query`,
+which touch the live driver, are left to the credential-gated live test (they
+carry `# pragma: no cover`); `columns()` is exercised here through a stubbed
+`query`.
+"""
+
+from __future__ import annotations
+
+from parity.dialects.snowflake_dialect import SnowflakeDialect, map_type_snowflake
+from parity.types import Column, LogicalType
+
+
+def _d() -> SnowflakeDialect:
+    """A dialect instance; no connection is opened."""
+    return SnowflakeDialect(side="A")
+
+
+def _col(name: str, t: LogicalType) -> Column:
+    """A column of the given logical type, for rendering."""
+    return Column(name, t, name)
+
+
+def test_hash_expr_is_the_top_60_bits_of_the_md5_number():
+    """The whole cross-engine contract: 15 hex chars = top 64 bits, drop 4."""
+    assert _d().hash_expr("'abc'") == "floor(md5_number_upper64('abc') / 16)"
+
+
+def test_the_null_sentinel_is_built_from_chr_92():
+    r"""A literal '\N' is unsafe on Snowflake (it processes backslash escapes)."""
+    assert _d().null_sentinel_sql() == "(chr(92) || 'N')"
+
+
+def test_quote_doubles_embedded_quotes():
+    """The injection boundary - names arrive from the command line."""
+    assert _d().quote('a"b') == '"a""b"'
+
+
+def test_integer_division_and_widening():
+    """`/` is exact on NUMBER and `floor` truncates; NUMBER(38,0) cannot overflow."""
+    d = _d()
+    assert d.int_div("x", "y") == "floor((x) / (y))"
+    assert d.wide_int("k") == "cast((k) as number(38,0))"
+    assert d.sum_wide("h") == "coalesce(sum(cast((h) as number(38,0))), 0)"
+
+
+def test_normalize_renders_each_logical_type():
+    """Every branch of the canonical-text encoding, null-safe."""
+    d = _d()
+    sentinel = "(chr(92) || 'N')"
+    cases = {
+        LogicalType.INTEGER: 'cast("c" as varchar)',
+        LogicalType.DECIMAL: 'cast(cast("c" as number(38,6)) as varchar)',
+        LogicalType.FLOAT: 'cast(cast("c" as number(38,6)) as varchar)',
+        LogicalType.BOOLEAN: 'case when "c" then \'true\' when not "c" then \'false\' end',
+        LogicalType.DATE: 'to_char("c", \'YYYY-MM-DD\')',
+        LogicalType.TIMESTAMP: 'to_char("c", \'YYYY-MM-DD HH24:MI:SS.FF6\')',
+        LogicalType.STRING: 'cast("c" as varchar)',
+        LogicalType.UNKNOWN: 'cast("c" as varchar)',
+    }
+    for t, inner in cases.items():
+        assert d.normalize(_col("c", t)) == f"coalesce({inner}, {sentinel})", t
+
+
+def test_map_type_splits_number_by_scale_and_maps_the_rest():
+    """Snowflake reports integer and decimal both as NUMBER; only scale tells
+    them apart, and a wrong split would render an integer key as `42.000000`."""
+    assert map_type_snowflake("NUMBER", 0) is LogicalType.INTEGER
+    assert map_type_snowflake("NUMBER(38,0)", 0) is LogicalType.INTEGER
+    assert map_type_snowflake("NUMBER", 2) is LogicalType.DECIMAL
+    assert map_type_snowflake("NUMBER", None) is LogicalType.DECIMAL  # no scale -> not integer
+    assert map_type_snowflake("DECIMAL", 6) is LogicalType.DECIMAL
+    assert map_type_snowflake("INT", 0) is LogicalType.INTEGER
+    assert map_type_snowflake("FLOAT", None) is LogicalType.FLOAT
+    assert map_type_snowflake("DOUBLE", None) is LogicalType.FLOAT
+    assert map_type_snowflake("BOOLEAN", None) is LogicalType.BOOLEAN
+    assert map_type_snowflake("DATE", None) is LogicalType.DATE
+    assert map_type_snowflake("TIMESTAMP_NTZ", None) is LogicalType.TIMESTAMP
+    assert map_type_snowflake("DATETIME", None) is LogicalType.TIMESTAMP
+    assert map_type_snowflake("TEXT", None) is LogicalType.STRING
+    assert map_type_snowflake("VARCHAR", None) is LogicalType.STRING
+    assert map_type_snowflake("VARIANT", None) is LogicalType.UNKNOWN
+    # A non-integer scale value is treated defensively as decimal, not a crash.
+    assert map_type_snowflake("NUMBER", "oops") is LogicalType.DECIMAL
+
+
+def test_columns_reads_numeric_scale_to_split_number():
+    """`columns()` turns information_schema rows into typed Columns, splitting
+    NUMBER on its scale - checked here through a stubbed query, no connection."""
+
+    class Stubbed(SnowflakeDialect):
+        def query(self, sql):  # type: ignore[override]
+            """Return canned information_schema rows instead of hitting a DB."""
+            assert "information_schema.columns" in sql
+            assert "PARITY_TEST" in sql or "ENC" in sql or "ORDERS" in sql
+            return [
+                ("ID", "NUMBER", 0),
+                ("AMOUNT", "NUMBER", 2),
+                ("STATUS", "TEXT", None),
+                ("CREATED_AT", "TIMESTAMP_NTZ", None),
+            ]
+
+    cols = Stubbed(side="A").columns("ENC.ORDERS")
+    assert [(c.name, c.logical_type) for c in cols] == [
+        ("ID", LogicalType.INTEGER),
+        ("AMOUNT", LogicalType.DECIMAL),
+        ("STATUS", LogicalType.STRING),
+        ("CREATED_AT", LogicalType.TIMESTAMP),
+    ]