snowflake-data-validation 1.45.4__tar.gz → 1.46.0__tar.gz

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-data-validation
-Version: 1.45.4
+Version: 1.46.0
 Summary: Snowflake Data Validation
 Project-URL: Bug Tracker, https://github.com/snowflake-eng/migrations-data-validation/issues
 Project-URL: Source code, https://github.com/snowflake-eng/migrations-data-validation/
@@ -38,7 +38,7 @@ Requires-Dist: pydantic-yaml>=1.4.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: ruamel-yaml>=0.18.0
-Requires-Dist: snowflake-connector-python<5,>=4.7.1
+Requires-Dist: snowflake-connector-python<5,>=4.7.3
 Requires-Dist: toml>=0.10.2
 Requires-Dist: typer>=0.15.3
 Requires-Dist: typing-extensions>=4.13.2
@@ -79,7 +79,7 @@ Requires-Dist: psycopg[binary]>=3.2.0; extra == 'postgresql'
 Provides-Extra: redshift
 Requires-Dist: redshift-connector>=2.1.14; extra == 'redshift'
 Provides-Extra: scai
-Requires-Dist: snowflake-code-unit-registry>=0.9.5; extra == 'scai'
+Requires-Dist: snowflake-code-unit-registry>=0.9.7; extra == 'scai'
 Provides-Extra: sqlite
 Requires-Dist: sqlean-py>=3.45.0; extra == 'sqlite'
 Provides-Extra: sqlserver
@@ -230,6 +230,21 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.46.0
+
+**Bug fixes**
+
+- Fixed L2 `DECFLOAT` `MIN` and `MAX` being compared as `FLOAT`, which let differences past about 16 significant digits pass.
+- Fixed high-precision decimals being rounded twice when cast to `Float64`, so identical values failed by one unit in the last place.
+- Fixed SQL Server `FLOAT` and `REAL` row validation using `TRIM()`, which SQL Server 2016 does not support.
+- Fixed result-set comparison failing for column names that contain a double quote.
+- Fixed SQL Server row validation of wide tables failing with "expression services limit has been reached".
+- Fixed L2 validation of an empty source and empty target table not being reported as valid.
+- Fixed direct row validation failing tables whose rows are full duplicates when the row drill-down finds no differences.
+- Fixed SQL Server Iceberg L3 validation reporting mismatches between 9-digit source and 6-digit target fractional seconds.
+- Fixed Teradata object-type mapping: tables with no primary index are now validated as tables, and triggers are no longer mapped as tables.
+- Fixed schema validation failing for SQL Server `image` columns.
+
 ### v1.45.4
 
 **Improvements**

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/README.md

@@ -139,6 +139,21 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.46.0
+
+**Bug fixes**
+
+- Fixed L2 `DECFLOAT` `MIN` and `MAX` being compared as `FLOAT`, which let differences past about 16 significant digits pass.
+- Fixed high-precision decimals being rounded twice when cast to `Float64`, so identical values failed by one unit in the last place.
+- Fixed SQL Server `FLOAT` and `REAL` row validation using `TRIM()`, which SQL Server 2016 does not support.
+- Fixed result-set comparison failing for column names that contain a double quote.
+- Fixed SQL Server row validation of wide tables failing with "expression services limit has been reached".
+- Fixed L2 validation of an empty source and empty target table not being reported as valid.
+- Fixed direct row validation failing tables whose rows are full duplicates when the row drill-down finds no differences.
+- Fixed SQL Server Iceberg L3 validation reporting mismatches between 9-digit source and 6-digit target fractional seconds.
+- Fixed Teradata object-type mapping: tables with no primary index are now validated as tables, and triggers are no longer mapped as tables.
+- Fixed schema validation failing for SQL Server `image` columns.
+
 ### v1.45.4
 
 **Improvements**

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/pyproject.toml

@@ -36,7 +36,7 @@ dependencies = [
   "connectorx>=0.3.0",
   "cryptography>=50.0.0",
   "deepdiff>=8.0.0",
-  "snowflake-connector-python>=4.7.1,<5",
+  "snowflake-connector-python>=4.7.3,<5",
   "pandas>=2.2.3",
   "polars>=1.0.0",
   "pyarrow>=14.0.0",
@@ -106,7 +106,7 @@ db2 = [
 # musllinux build, and SDV is published to public PyPI. Inside DMO/DEA the
 # dependency is already declared, so SDV's logger tree is covered there.
 scai = [
-  "snowflake-code-unit-registry>=0.9.5",
+  "snowflake-code-unit-registry>=0.9.7",
 ]
 
 [project.urls]

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/azure_synapse/query/query_generator_azure_synapse.py

@@ -34,9 +34,6 @@ from typing import TYPE_CHECKING
 
 from shared.identifiers.managers import identifier_manager
 from shared.identifiers.sql_identifier import SqlIdentifier
-from snowflake.snowflake_data_validation.query.float_bit_normalization import (
-    build_binary64_canonical_expr,
-)
 from snowflake.snowflake_data_validation.query.numeric_scale_resolution import (
     float_bit_input_expr,
 )
@@ -44,6 +41,9 @@ from snowflake.snowflake_data_validation.query.query_generator_base import (
     QueryGeneratorBase,
     resolve_table_context_modifiers,
 )
+from snowflake.snowflake_data_validation.query.tsql_float_bits import (
+    build_tsql_float_bit_canonical_expr,
+)
 from snowflake.snowflake_data_validation.query.tsql_float_remainder import (
     TsqlFloatMetricModifierMixin,
 )
@@ -77,7 +77,7 @@ LOGGER = logging.getLogger(__name__)
 
 def build_azure_synapse_float_bit_canonical_expr(col_ref: str) -> str:
     """Return the exact binary64 tuple used for Azure Synapse float validation."""
-    return build_binary64_canonical_expr(col_ref, dialect=Platform.AZURE_SYNAPSE.value)
+    return build_tsql_float_bit_canonical_expr(col_ref)
 
 
 class QueryGeneratorAzureSynapse(TsqlFloatMetricModifierMixin, QueryGeneratorBase):

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/db2/extractor/templates/db2_column_metrics_templates.yaml

@@ -338,13 +338,18 @@ DOUBLE PRECISION:
     metric_return_datatype: FLOAT
     metric_column_modifier: ' - 2097143 * (CAST("{{ col_name }}" AS DECIMAL(31,0)) / 2097143)'
 
+# min/max are emitted as exact canonical decimal text (``{{ decfloat_shim }}``
+# over the aggregate), matching Snowflake DECFLOAT's: binary64 keeps only ~16
+# of DECFLOAT's 34 digits.
 DECFLOAT:
   min:
     metric_query: MIN("{{ col_name }}")
     metric_return_datatype: FLOAT
+    metric_normalization: "{{ decfloat_shim }}"
   max:
     metric_query: MAX("{{ col_name }}")
     metric_return_datatype: FLOAT
+    metric_normalization: "{{ decfloat_shim }}"
   count_distinct:
     metric_query: COUNT(DISTINCT "{{ col_name }}")
     metric_return_datatype: INTEGER

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/db2/query/query_generator_db2.py

@@ -28,6 +28,7 @@ below give DB2 its own DB2-valid rendering that still matches Snowflake
 from pathlib import Path
 
 import jinja2
+import pandas as pd
 
 from shared.datatypes.common import CommonType
 from shared.datatypes.db2 import Db2Type
@@ -49,6 +50,8 @@ from snowflake.snowflake_data_validation.query.query_generator_base import (
 )
 from snowflake.snowflake_data_validation.query.sql_type_families import SNOWFLAKE_FLOAT_TYPE_NAMES
 from snowflake.snowflake_data_validation.utils.constants import (
+    DECFLOAT_SHIM_PLACEHOLDER,
+    METRIC_QUERY_PLACEHOLDER,
     NULL_HASHING_SENTINEL,
     NULL_HASHING_SENTINEL_KEY,
     ROW_HASH_COLUMN_DELIMITER,
@@ -59,6 +62,7 @@ from snowflake.snowflake_data_validation.utils.iso_dv_common import (
     get_paired_target_column_types,
     normalize_snowflake_base_type,
 )
+from snowflake.snowflake_data_validation.utils.model.column_metadata import ColumnMetadata
 from snowflake.snowflake_data_validation.utils.model.table_context import TableContext
 
 
@@ -66,6 +70,9 @@ from snowflake.snowflake_data_validation.utils.model.table_context import TableC
 # leading zero for |v| < 1 (matching Snowflake TO_VARCHAR).
 _DB2_INTEGER_NINES = 31
 
+# MIN/MAX of a DECFLOAT mirrored as a Snowflake FLOAT, in place of its exact text.
+DB2_DECFLOAT_AS_FLOAT_METRIC_NORMALIZATION = f"CAST({METRIC_QUERY_PLACEHOLDER} AS DOUBLE)"
+
 
 def build_db2_float_bit_canonical_expr(col_ref: str) -> str:
     """Return the exact binary64 tuple used for DB2 float validation.
@@ -153,21 +160,43 @@ class QueryGeneratorDb2(QueryGeneratorOracle):
         datatypes_normalization_templates: dict[str, str],
         table_context: TableContext,
     ) -> str:
-        """Hash a DECFLOAT mirrored as a Snowflake FLOAT as binary64, as that target does.
-
-        DMO creates DECFLOAT; only a user-mapped target lands on FLOAT, and it
-        holds ~16 digits, so the exact decimal text could never match it.
-        """
-        if self._parse_type_precision_scale(column.data_type or "")[0] == Db2Type.DECFLOAT:
-            target_type = get_paired_target_column_types(table_context).get(column.name)
-            if isinstance(target_type, str) and normalize_snowflake_base_type(target_type) in SNOWFLAKE_FLOAT_TYPE_NAMES:
-                return datatypes_normalization_templates[CommonType.FLOAT]
+        """Hash a DECFLOAT mirrored as a Snowflake FLOAT as binary64, as that target does."""
+        if self._decfloat_lands_in_float(column, table_context):
+            return datatypes_normalization_templates[CommonType.FLOAT]
         return super()._resolve_datatype_normalization_template(
             column,
             datatypes_normalization_templates,
             table_context,
         )
 
+    def _resolve_metric_normalization(
+        self,
+        col: ColumnMetadata,
+        metric_name: str,
+        row: pd.Series,
+        table_context: TableContext,
+    ) -> str | None:
+        """Measure a DECFLOAT mirrored as a Snowflake FLOAT in binary64, as that target does.
+
+        Only the stock exact-text MIN/MAX is swapped, so the DECFLOAT row's custom
+        removals and queries still apply.
+        """
+        normalization = super()._resolve_metric_normalization(col, metric_name, row, table_context)
+        if normalization and DECFLOAT_SHIM_PLACEHOLDER in normalization and self._decfloat_lands_in_float(col, table_context):
+            return DB2_DECFLOAT_AS_FLOAT_METRIC_NORMALIZATION
+        return normalization
+
+    def _decfloat_lands_in_float(self, column: ColumnMetadata, table_context: TableContext) -> bool:
+        """Return True for a DECFLOAT column whose Snowflake mirror is FLOAT.
+
+        DMO creates DECFLOAT; only a user-mapped target lands on FLOAT, and it
+        holds ~16 digits, so the exact decimal text could never match it.
+        """
+        if self._parse_type_precision_scale(column.data_type or "")[0] != Db2Type.DECFLOAT:
+            return False
+        target_type = get_paired_target_column_types(table_context).get(column.name)
+        return isinstance(target_type, str) and normalize_snowflake_base_type(target_type) in SNOWFLAKE_FLOAT_TYPE_NAMES
+
     # ------------------------------------------------------------------
     # text_comparison_mode: apply the per-column text codec (raw/logical)
     #

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/public/reshape/metrics_reshape.py

@@ -45,8 +45,8 @@ def _to_str(value: object) -> object:
     into a plain ``str``.  This guarantees the long-format DataFrame
     contains only strings and ``pd.NA`` — no mixed native types that
     would break ``sort_values`` inside ``normalize_dataframe``.
-    ``MetricsDataValidator`` already applies ``is_numeric`` /
-    ``float()`` for tolerance checks, so string values work correctly.
+    ``MetricsDataValidator`` parses numeric text for its tolerance checks,
+    exactly when both sides are exact, so string values work correctly.
     """
     if value is None:
         return None
@@ -114,8 +114,10 @@ def reshape_wide_metrics_result(
 
     # Single row is guaranteed by the wide-SELECT contract.  If a driver
     # ever returns more rows (e.g. GROUP BY accident) we use the first.
-    # ``tolist()`` yields Python-native types (Timestamp -> datetime, etc.)
-    row_values = wide_df.iloc[0].tolist()
+    # Each cell is read as its own column's value: a row of only numeric
+    # dtypes would otherwise be upcast to float64 as a whole, rounding an
+    # integer MIN/MAX past 2**53 that the comparator measures exactly.
+    row_values = wide_df.iloc[:1].astype(object).iloc[0].tolist()
 
     rows_by_col: dict[str, dict[str, object]] = {
         col_name: {m: pd.NA for m in metric_columns} for col_name in ordered_col_names

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/query/float_bit_normalization.py

@@ -80,23 +80,9 @@ SNOWFLAKE_BINARY64_SQL = Binary64SqlDialect(
     neg_inf_literals=("-inf", "-infinity"),
 )
 
-# SQL Server / Azure Synapse dedicated pool: LOG is natural log; LEAST/GREATEST
-# need SQL Server 2022+. POWER(2.0, n) is DECIMAL arithmetic (2.0 is
-# decimal(2,1)), so 2.0^-4 becomes 0.1. Force FLOAT: POWER(CONVERT(FLOAT, 2), n).
-# LOG(0) raises divide-by-zero even inside CASE; NULLIF the abs input.
-# CAST(... AS VARCHAR) is VARCHAR(30), which is enough for these integers.
-SQLSERVER_BINARY64_SQL = Binary64SqlDialect(
-    log2="LOG(NULLIF({abs}, 0)) / LOG(CONVERT(FLOAT, 2))",
-    power2="POWER(CONVERT(FLOAT, 2), {exp})",
-    integer_type="BIGINT",
-    string_type="VARCHAR(50)",
-    concat="concat",
-    use_least_greatest=False,
-    text_value="LOWER(LTRIM(RTRIM(CONVERT(VARCHAR(50), {value}, 2))))",
-    nan_literals=("nan",),
-    pos_inf_literals=("inf", "infinity"),
-    neg_inf_literals=("-inf", "-infinity"),
-)
+# SQL Server and Azure Synapse read the tuple from the stored bits instead
+# (``tsql_float_bits``): the LOG/POWER search below repeats the column about a
+# hundred times, and T-SQL row hashes compile into one size-limited expression.
 
 # Redshift and PostgreSQL can share Snowflake's spelling
 # (LN / POWER / BIGINT / ||).
@@ -196,9 +182,6 @@ BINARY64_SQL_BY_DIALECT: dict[str, Binary64SqlDialect] = {
     "snowflake": SNOWFLAKE_BINARY64_SQL,
     "redshift": SNOWFLAKE_BINARY64_SQL,
     "postgresql": SNOWFLAKE_BINARY64_SQL,
-    "sqlserver": SQLSERVER_BINARY64_SQL,
-    # Dedicated SQL pool is T-SQL: same LOG/POWER(FLOAT) spelling as SQL Server.
-    "azure_synapse": SQLSERVER_BINARY64_SQL,
     "oracle": ORACLE_BINARY64_SQL,
     "sqlite": SQLITE_BINARY64_SQL,
     "db2": DB2_BINARY64_SQL,

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/query/normalization_render_context.py

@@ -26,11 +26,23 @@ class NormalizationRenderContext:
     has_custom_normalization: bool = False
 
     @classmethod
-    def from_table_context(cls, table_context: TableContext) -> NormalizationRenderContext:
-        """Resolve the per-table inputs; ``for_column`` adds the per-column paired type."""
+    def from_table_context(
+        cls,
+        table_context: TableContext,
+        *,
+        source_timestamp_fraction_digits: int | None = None,
+    ) -> NormalizationRenderContext:
+        """Resolve the per-table inputs; ``for_column`` adds the per-column paired type.
+
+        ``source_timestamp_fraction_digits`` is the paired source's fixed timestamp
+        text width; it replaces the Iceberg spec's digits when given.
+        """
+        fraction_digits = source_timestamp_fraction_digits
+        if fraction_digits is None:
+            fraction_digits = IcebergProfile.from_table_context(table_context).fraction_digits
         return cls(
             paired_source_platform=table_context.paired_source_platform,
-            iceberg_fraction_digits=IcebergProfile.from_table_context(table_context).fraction_digits,
+            iceberg_fraction_digits=fraction_digits,
         )
 
     def for_column(

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/query/query_generator_base.py

@@ -182,12 +182,15 @@ class QueryGeneratorBase(ABC):
             f"DECFLOAT normalization is not supported for platform {self.platform.value!r}",
         )
 
-    def _expand_decfloat_placeholder(self, template: str, column) -> str:
-        """Replace ``{{ decfloat_shim }}`` when present."""
+    def _expand_decfloat_placeholder(self, template: str, column, col_ref: str | None = None) -> str:
+        """Replace ``{{ decfloat_shim }}`` when present, over *col_ref* (default: the column itself)."""
         if DECFLOAT_SHIM_PLACEHOLDER not in template:
             return template
         try:
-            shim = self.build_decfloat_shim(column, self._float_column_reference(column))
+            shim = self.build_decfloat_shim(
+                column,
+                col_ref if col_ref is not None else self._float_column_reference(column),
+            )
         except NotImplementedError as exc:
             raise ValueError(
                 f"{{ decfloat_shim }} is not supported for platform {self.platform.value!r}",
@@ -225,7 +228,7 @@ class QueryGeneratorBase(ABC):
 
         The shipped templates spell the column ``"{{ col_name }}"``; custom ones may
         use a bare ``{{ col_name }}``. Dialects whose writer delimits the name itself
-        (Snowflake, SQL Server, Synapse) render either as one complete identifier.
+        (Snowflake, SQL Server, Synapse, result set) render either as one complete identifier.
         """
         written = self._write_sql_identifier(identifier)
         rendered = template.replace(self._quoted_metric_identifier_placeholder(), written)
@@ -947,6 +950,8 @@ class QueryGeneratorBase(ABC):
                     if normalization is None and row.get(EXPLICIT_METRIC_NORMALIZATION_COLUMN_KEY):
                         normalization = row[NORMALIZATION_COLUMN_KEY]
                     if pd.notna(normalization) and normalization:
+                        # A DECFLOAT aggregate keeps every digit as canonical text over the aggregate.
+                        normalization = self._expand_decfloat_placeholder(normalization, col, METRIC_QUERY_PLACEHOLDER)
                         if NUMERIC_FORMAT_MASK_PLACEHOLDER in normalization:
                             mask = self._build_numeric_format_mask(self._resolve_numeric_scale(col))
                             normalization = normalization.replace(NUMERIC_FORMAT_MASK_PLACEHOLDER, mask)

snowflake_data_validation-1.46.0/src/snowflake/snowflake_data_validation/query/tsql_float_bits.py

@@ -0,0 +1,66 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Read a T-SQL FLOAT's IEEE-754 fields from its stored bits.
+
+SQL Server and the Azure Synapse dedicated SQL pool share this spelling of the
+``sign|exponent|significand`` tuple that Snowflake FLOAT emits.
+"""
+
+from __future__ import annotations
+
+from snowflake.snowflake_data_validation.query.float_bit_normalization import (
+    IEEE754_BINARY64_FRACTION_BITS,
+    IEEE754_BINARY64_MIN_EXPONENT,
+)
+
+
+_BINARY64_EXPONENT_BIAS = 1023
+_BINARY64_MAX_BIASED_EXPONENT = 2047
+# Mask for the 11 exponent bits in the first two big-endian bytes (0x7FF0).
+_BINARY64_EXPONENT_MASK_IN_HIGH_WORD = 0x7FF0
+_BINARY64_EXPONENT_SHIFT_IN_HIGH_WORD = 16
+_BINARY64_FRACTION_MASK = (1 << IEEE754_BINARY64_FRACTION_BITS) - 1
+_BINARY64_IMPLICIT_BIT = 1 << IEEE754_BINARY64_FRACTION_BITS
+
+
+def build_tsql_float_bit_canonical_expr(col_ref: str) -> str:
+    """Return the exact binary64 tuple for a SQL Server or Azure Synapse float.
+
+    Emits the same ``sign|exponent|significand`` strings as
+    ``build_binary64_canonical_expr``, but reads the fields from the stored
+    bits: ``CAST(float AS BINARY(8))`` is the big-endian IEEE-754 encoding.
+    The LOG/POWER exponent search the other dialects use repeats the column
+    about a hundred times, and T-SQL compiles every normalized column of a row
+    hash into one expression with a size limit ("An expression services limit
+    has been reached"), which a few dozen FLOAT columns exceed. Integer
+    literals above INT range are DECIMAL in T-SQL, so the 64-bit masks are
+    cast to BIGINT for the ``&`` operator.
+    """
+    # The inner cast keeps a REAL argument from encoding as four bytes.
+    bits = f"CAST(CAST({col_ref} AS FLOAT) AS BINARY(8))"
+    biased_exponent = (
+        f"((CAST(SUBSTRING({bits}, 1, 2) AS INT) & {_BINARY64_EXPONENT_MASK_IN_HIGH_WORD})"
+        f" / {_BINARY64_EXPONENT_SHIFT_IN_HIGH_WORD})"
+    )
+    fraction = f"(CAST({bits} AS BIGINT) & CAST({_BINARY64_FRACTION_MASK} AS BIGINT))"
+    # Subnormals have a zero biased exponent, a fixed -1022 exponent and no implicit bit.
+    exponent = (
+        f"CASE WHEN {biased_exponent} = 0 THEN {IEEE754_BINARY64_MIN_EXPONENT} "
+        f"ELSE {biased_exponent} - {_BINARY64_EXPONENT_BIAS} END"
+    )
+    significand = (
+        f"{fraction} + CASE WHEN {biased_exponent} = 0 THEN CAST(0 AS BIGINT) "
+        f"ELSE CAST({_BINARY64_IMPLICIT_BIT} AS BIGINT) END"
+    )
+    special_value = (
+        f"CASE WHEN {fraction} <> 0 THEN 'NAN' WHEN {col_ref} < 0 THEN '-INF' ELSE '+INF' END"
+    )
+    sign = f"CASE WHEN {col_ref} < 0 THEN '1' ELSE '0' END"
+    return (
+        f"CASE WHEN {col_ref} IS NULL THEN NULL "
+        f"WHEN {col_ref} = 0 THEN '0|0|0' "
+        f"WHEN {biased_exponent} = {_BINARY64_MAX_BIASED_EXPONENT} THEN {special_value} "
+        f"ELSE CONCAT({sign}, '|', CAST({exponent} AS VARCHAR(50)), '|', "
+        f"CAST({significand} AS VARCHAR(50))) END"
+    )

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/result_set/extractor/templates/result_set_cell_validation_data_select.sql.j2

@@ -1,5 +1,5 @@
 SELECT
 {% for column in column_collection %}
-    COALESCE({{ datatypes_normalization_renderer_templates[column.name] }}, '{{ null_hashing_sentinel }}') AS "{{ column.name }}"{% if not loop.last %},{% endif %}
+    COALESCE({{ datatypes_normalization_renderer_templates[column.name] }}, '{{ null_hashing_sentinel }}') AS {{ column_sql_names[column.name] }}{% if not loop.last %},{% endif %}
 {% endfor %}
 FROM self

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/result_set/query/query_generator_result_set.py

@@ -19,6 +19,15 @@ class QueryGeneratorResultSet(QueryGeneratorBase):
         """Initialize the ResultSet query generator."""
         super().__init__(platform=Platform.RESULT_SET)
 
+    def _render_normalization_template_identifier(self, template: str, identifier: str) -> str:
+        """Insert *identifier* into a normalization template as one complete, quoted identifier.
+
+        Both the quoted ``"{{ col_name }}"`` and a bare ``{{ col_name }}`` placeholder are
+        replaced with the name as written by ``_write_sql_identifier``, so an inner double
+        quote is doubled and a custom template cannot split or break the statement.
+        """
+        return self._render_written_identifier_template(template, identifier)
+
     def generate_extract_md5_rows_chunk_query(self, chunk_id: str, table_context: TableContext) -> str:
         """Generate the SQL query to extract the MD5 rows for a specific chunk.
 
@@ -97,6 +106,7 @@ class QueryGeneratorResultSet(QueryGeneratorBase):
             has_where_clause=False,
             where_clause="",
             order_by_columns=[],
+            write_identifier=self._write_sql_identifier,
         )
 
         return query

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/snowflake/extractor/templates/snowflake_column_metrics_templates.yaml

@@ -49,17 +49,21 @@ FLOAT:
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
 
-# DECFLOAT mirror of the DB2 DECFLOAT metric block. min/max stay uncast like
-# DB2's MIN/MAX. The avg/sum/stddev shape matches the Snowflake NUMBER block
-# (CAST ... AS FLOAT), so the aggregate runs in binary64 and matches DB2's
-# CAST(... AS FLOAT) on the source side.
+# DECFLOAT mirror of the DB2 DECFLOAT metric block. min/max are emitted as the
+# same canonical decimal text as DB2's (``{{ decfloat_shim }}`` over the
+# aggregate), since binary64 keeps only ~16 of DECFLOAT's 34 digits. The
+# avg/sum/stddev shape matches the Snowflake NUMBER block (CAST ... AS FLOAT),
+# so the aggregate runs in binary64 and matches DB2's CAST(... AS FLOAT) on the
+# source side.
 DECFLOAT:
   min:
     metric_query: MIN("{{ col_name }}")
     metric_return_datatype: FLOAT
+    metric_normalization: "{{ decfloat_shim }}"
   max:
     metric_query: MAX("{{ col_name }}")
     metric_return_datatype: FLOAT
+    metric_normalization: "{{ decfloat_shim }}"
   count_distinct:
     metric_query: COUNT(DISTINCT "{{ col_name }}")
     metric_return_datatype: NUMBER

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/snowflake/l3/pushdown_diff_sql.py

@@ -117,7 +117,13 @@ def _joined_cte(pk_column_names: Sequence[str]) -> str:
 
 
 def _category_case_sql() -> str:
-    """Map joined aggregates to Result enum values (duplicates first)."""
+    """Map joined aggregates to Result enum values (duplicates first).
+
+    A key repeated the same number of times on both sides, with every copy
+    hashing to one ROW_MD5 that both sides share, is the same multiset of
+    rows (a keyless table indexed on all its columns, for instance). It is no
+    anomaly, so it gets no category and does not fail the table.
+    """
     dup_both = Result.DUPLICATE_BOTH_SIDES.value
     dup_src = Result.DUPLICATE_SOURCE.value
     dup_tgt = Result.DUPLICATE_TARGET.value
@@ -126,6 +132,8 @@ def _category_case_sql() -> str:
     mismatch = Result.MISMATCH.value
     return (
         "CASE\n"
+        "    WHEN SRC_CNT > 1 AND SRC_CNT = TGT_CNT AND SRC_MD5 = TGT_MD5\n"
+        "         AND NOT SRC_HASH_COLLISION AND NOT TGT_HASH_COLLISION THEN NULL\n"
         f"    WHEN COALESCE(SRC_CNT, 0) > 1 AND COALESCE(TGT_CNT, 0) > 1 THEN '{dup_both}'\n"
         f"    WHEN COALESCE(SRC_CNT, 0) > 1 THEN '{dup_src}'\n"
         f"    WHEN COALESCE(TGT_CNT, 0) > 1 THEN '{dup_tgt}'\n"

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/snowflake/query/query_generator_snowflake.py

@@ -88,6 +88,7 @@ from snowflake.snowflake_data_validation.utils.constants import (
     NORMALIZATION_COLUMN_KEY,
     NUMERIC_FORMAT_MASK_PLACEHOLDER,
     Platform,
+    fixed_source_timestamp_text_fraction_digits,
 )
 from snowflake.snowflake_data_validation.utils.iceberg_dv_common import (
     IcebergProfile,
@@ -426,7 +427,12 @@ class QueryGeneratorSnowflake(QueryGeneratorBase):
     ) -> dict[str, str]:
         datatypes_normalization_templates = table_context.templates_loader_manager.datatypes_normalization_templates
         paired_source_types = get_paired_source_column_types(table_context)
-        base_context = NormalizationRenderContext.from_table_context(table_context)
+        base_context = NormalizationRenderContext.from_table_context(
+            table_context,
+            source_timestamp_fraction_digits=fixed_source_timestamp_text_fraction_digits(
+                table_context.paired_source_platform,
+            ),
+        )
         renderer_templates: dict[str, str] = {}
         renderer_columns = self._row_md5_normalization_columns(table_context)
         for column in renderer_columns:

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/sqlserver/extractor/templates/sqlserver_table_metadata_query.sql.j2

@@ -10,7 +10,9 @@ WITH rc_cte AS (
         -- For nvarchar(max)/nchar(max), divide by 2 for 2-byte encoding (approx. 1 billion characters).
         -- For varchar(max)/char(max), approx. 2 billion characters.
         CASE
-            WHEN C.DATA_TYPE IN ('varbinary', 'binary') THEN NULL
+            -- Binary types have no character length; Snowflake BINARY reports none
+            -- either. image (deprecated) otherwise reports its 2147483647 maximum.
+            WHEN C.DATA_TYPE IN ('varbinary', 'binary', 'image') THEN NULL
             -- Spatial CLR types are not character types; INFORMATION_SCHEMA still
             -- reports CHARACTER_MAXIMUM_LENGTH = -1 (unbounded sentinel). Treat as
             -- N/A so L1 matches Snowflake GEOGRAPHY/GEOMETRY (also NULL/N/A).

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/sqlserver/query/query_generator_sqlserver.py

@@ -34,9 +34,6 @@ from shared.datatypes.snowflake import SnowflakeType
 from shared.identifiers.managers import identifier_manager
 from shared.identifiers.sql_identifier import SqlIdentifier
 from shared.sqlserver.version_detection import detect_sql_server_version
-from snowflake.snowflake_data_validation.query.float_bit_normalization import (
-    build_binary64_canonical_expr,
-)
 from snowflake.snowflake_data_validation.query.numeric_scale_resolution import (
     float_bit_input_expr,
 )
@@ -44,6 +41,9 @@ from snowflake.snowflake_data_validation.query.query_generator_base import (
     QueryGeneratorBase,
     resolve_table_context_modifiers,
 )
+from snowflake.snowflake_data_validation.query.tsql_float_bits import (
+    build_tsql_float_bit_canonical_expr,
+)
 from snowflake.snowflake_data_validation.query.tsql_float_remainder import (
     TsqlFloatMetricModifierMixin,
 )
@@ -81,7 +81,7 @@ LOGGER = logging.getLogger(__name__)
 
 def build_sqlserver_float_bit_canonical_expr(col_ref: str) -> str:
     """Return the exact binary64 tuple used for SQL Server float validation."""
-    return build_binary64_canonical_expr(col_ref, dialect=Platform.SQLSERVER.value)
+    return build_tsql_float_bit_canonical_expr(col_ref)
 
 
 def build_sqlserver_vector_bit_shim(col_ref: str, element) -> str:

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_table_metadata_query.sql.j2

@@ -103,8 +103,8 @@ WITH rc_cte AS (
             SELECT CASE t.TableKind
                 WHEN 'T' THEN 'TABLE'
                 WHEN 'V' THEN 'VIEW'
+                WHEN 'O' THEN 'TABLE'
                 WHEN 'Q' THEN 'TABLE'
-                WHEN 'G' THEN 'TABLE'
                 ELSE 'UNKNOWN'
             END
             FROM DBC.TablesV t

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/utils/constants.py

@@ -75,6 +75,33 @@ def platform_skips_view_materialization(platform: Platform) -> bool:
     return platform in _VIEW_MATERIALIZATION_SKIP_PLATFORMS
 
 
+# Fraction digits of a nanosecond-precision timestamp.
+NANOSECOND_FRACTION_DIGITS = 9
+
+# Source platforms whose L3 timestamp text carries a fixed number of fraction digits
+# whatever their paired Snowflake target stores. The T-SQL templates pad DATETIME,
+# DATETIME2 and DATETIMEOFFSET to nine digits, and the Oracle and DB2 templates render
+# DATE and TIMESTAMP with FF9. The Snowflake generator renders an Iceberg v2 mirror at
+# the same width, so stored microseconds pad with zeros and a source digit past the
+# sixth lost to TIMESTAMP_NTZ(6) still shows. Sources not listed follow the Iceberg
+# spec's digits. This is a platform capability rather than a source generator
+# attribute because the Snowflake generator would have to reach the source generators
+# through QueryGeneratorFactory, which imports it.
+_FIXED_SOURCE_TIMESTAMP_TEXT_FRACTION_DIGITS: dict[Platform, int] = {
+    Platform.SQLSERVER: NANOSECOND_FRACTION_DIGITS,
+    Platform.AZURE_SYNAPSE: NANOSECOND_FRACTION_DIGITS,
+    Platform.ORACLE: NANOSECOND_FRACTION_DIGITS,
+    Platform.DB2: NANOSECOND_FRACTION_DIGITS,
+}
+
+
+def fixed_source_timestamp_text_fraction_digits(paired_source_platform: Platform | None) -> int | None:
+    """Return the paired source's fixed L3 timestamp text digits, or None when it follows the target."""
+    if paired_source_platform is None:
+        return None
+    return _FIXED_SOURCE_TIMESTAMP_TEXT_FRACTION_DIGITS.get(paired_source_platform)
+
+
 class ExecutionMode(Enum):
     """Enumeration of available execution modes."""
 

{snowflake_data_validation-1.45.4 → snowflake_data_validation-1.46.0}/src/snowflake/snowflake_data_validation/utils/helpers/helper_polars_cast.py

@@ -88,6 +88,17 @@ def _parse_time_series(series: pl.Series) -> pl.Series:
     return series.str.to_time(strict=False)
 
 
+def _decimal_to_float64(col_expr: pl.Expr) -> pl.Expr:
+    """Round each decimal once, to its nearest double, as ``float(Decimal)`` does.
+
+    Polars' Decimal -> Float64 cast (1.x, which scai ships) converts the unscaled
+    integer to a double, then divides by ``10**scale``: a second rounding that can
+    land one ulp off, so a ``Decimal`` (Snowflake's connector) and a ``float`` (a
+    JSON baseline) of the same value stop comparing equal.
+    """
+    return col_expr.cast(pl.String).cast(pl.Float64)
+
+
 def _native_cast_expression(col_name: str, current_type: pl.DataType, target_type: pl.DataType) -> pl.Expr:
     """Build the cast for every target that needs no Python callback."""
     col_expr = pl.col(col_name)
@@ -97,6 +108,8 @@ def _native_cast_expression(col_name: str, current_type: pl.DataType, target_typ
         return _null_out_sentinel_strings(col_expr).str.to_datetime(strict=False).cast(pl.Date, strict=False)
     if target_type == pl.Boolean and is_string:
         return col_expr.str.to_lowercase().is_in(["true", "1", "yes"])
+    if target_type.is_float() and current_type.is_decimal():
+        return _decimal_to_float64(col_expr).cast(target_type, strict=False)
     return col_expr.cast(target_type, strict=False)