snowflake-data-validation 1.44.0__tar.gz → 1.44.1__tar.gz

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-data-validation
-Version: 1.44.0
+Version: 1.44.1
 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/
@@ -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.0; extra == 'scai'
+Requires-Dist: snowflake-code-unit-registry>=0.9.2; extra == 'scai'
 Provides-Extra: sqlite
 Requires-Dist: sqlean-py>=3.45.0; extra == 'sqlite'
 Provides-Extra: sqlserver
@@ -214,6 +214,24 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.44.1
+
+**New features**
+
+- Added support for L3 row and hybrid validation on Iceberg v3 tables in native storage mode, keyed by the stored column type.
+
+**Bug fixes**
+
+- Fixed `PERIOD` validation normalization and signature extraction.
+- Fixed Teradata `XML` columns not being cast to `UNICODE` before L3 hashing.
+- Fixed SQL Server and Synapse `FLOAT`/`REAL` L2 aggregates being cast to `DECIMAL(38,10)` on the source only.
+- Fixed `TIME` and `TIME WITH TIME ZONE` normalization dropping fractional seconds on several platforms.
+- Fixed `DECFLOAT` L3 comparisons diverging past about 16 digits by comparing exact decimal text.
+- Fixed Teradata float aggregate comparisons by comparing on the signed significand.
+- Fixed false row-hash mismatches on Iceberg-compatible geospatial columns.
+- Fixed offset timestamps (SQL Server `DATETIMEOFFSET`, Teradata `TIMESTAMP WITH TIME ZONE`) not being compared as UTC instants under Iceberg `FULL_INGEST`.
+- Fixed Redshift Iceberg validation findings: L3 `TIME`, L2 `count_distinct` overflow, and the L1 precision message.
+
 ### v1.44.0
 
 **New features**

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/README.md

@@ -123,6 +123,24 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.44.1
+
+**New features**
+
+- Added support for L3 row and hybrid validation on Iceberg v3 tables in native storage mode, keyed by the stored column type.
+
+**Bug fixes**
+
+- Fixed `PERIOD` validation normalization and signature extraction.
+- Fixed Teradata `XML` columns not being cast to `UNICODE` before L3 hashing.
+- Fixed SQL Server and Synapse `FLOAT`/`REAL` L2 aggregates being cast to `DECIMAL(38,10)` on the source only.
+- Fixed `TIME` and `TIME WITH TIME ZONE` normalization dropping fractional seconds on several platforms.
+- Fixed `DECFLOAT` L3 comparisons diverging past about 16 digits by comparing exact decimal text.
+- Fixed Teradata float aggregate comparisons by comparing on the signed significand.
+- Fixed false row-hash mismatches on Iceberg-compatible geospatial columns.
+- Fixed offset timestamps (SQL Server `DATETIMEOFFSET`, Teradata `TIMESTAMP WITH TIME ZONE`) not being compared as UTC instants under Iceberg `FULL_INGEST`.
+- Fixed Redshift Iceberg validation findings: L3 `TIME`, L2 `count_distinct` overflow, and the L1 precision message.
+
 ### v1.44.0
 
 **New features**

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/pyproject.toml

@@ -105,7 +105,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.0",
+  "snowflake-code-unit-registry>=0.9.2",
 ]
 
 [project.urls]

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/azure_synapse/extractor/templates/azure_synapse_column_metrics_templates.yaml

@@ -258,6 +258,9 @@ SMALLMONEY:
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
 
+# avg/sum/stddev aggregate the binary64 value, as Snowflake aggregates its FLOAT
+# (SNOW-4314808); REAL widens exactly. T-SQL has no FLOAT %, so the generator
+# renders {{ modifier }} on this operand as Snowflake's float remainder (tsql_float_remainder.py).
 FLOAT:
   min:
     metric_query: MIN("{{ col_name }}")
@@ -275,18 +278,19 @@ FLOAT:
     metric_query: SUM(CASE WHEN "{{ col_name }}" = 0 THEN 1 ELSE 0 END)
     metric_return_datatype: INT
   avg:
-    metric_query: AVG(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: AVG(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
   sum:
-    metric_query: SUM(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: SUM(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
   stddev:
-    metric_query: STDEVP(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: STDEVP(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
 
+# avg/sum/stddev widen to binary64, as FLOAT's do (SNOW-4314808).
 REAL:
   min:
     metric_query: MIN("{{ col_name }}")
@@ -304,15 +308,15 @@ REAL:
     metric_query: SUM(CASE WHEN "{{ col_name }}" = 0 THEN 1 ELSE 0 END)
     metric_return_datatype: INT
   avg:
-    metric_query: AVG(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: AVG(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
   sum:
-    metric_query: SUM(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: SUM(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: REAL
     metric_column_modifier: "% 2097143"
   stddev:
-    metric_query: STDEVP(CAST("{{ col_name }}" AS DECIMAL(38, 10)) {{ modifier }})
+    metric_query: STDEVP(CAST("{{ col_name }}" AS FLOAT) {{ modifier }})
     metric_return_datatype: FLOAT
     metric_column_modifier: "% 2097143"
 

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/azure_synapse/extractor/templates/azure_synapse_datatypes_normalization_templates.yaml

@@ -50,7 +50,8 @@ NVARCHAR: '"{{ col_name }}"'
 # Use '+' (not CONCAT) so a NULL input propagates to NULL.
 # DATENAME(TZOFFSET) emits '+HH:MM'/'-HH:MM' for every offset, including UTC.
 DATE: CONVERT(VARCHAR(10), "{{ col_name }}", 23)
-TIME: CONVERT(VARCHAR(8), "{{ col_name }}", 108)
+# Same text as SQL Server TIME: hh:mi:ss.fffffff + '00', cut to {{ time_text_length }}.
+TIME: LEFT(SUBSTRING(CONVERT(VARCHAR(27), CAST("{{ col_name }}" AS DATETIME2(7)), 121), 12, 16) + '00', {{ time_text_length }})
 DATETIME: STUFF(CONVERT(VARCHAR(27), CAST(CAST("{{ col_name }}" AS DATETIME2(3)) AS DATETIME2(7)), 121), 11, 1, 'T') + '00'
 DATETIME2: LEFT(STUFF(CONVERT(VARCHAR(27), CAST("{{ col_name }}" AS DATETIME2(7)), 121), 11, 1, 'T'), 26) + '000'
 SMALLDATETIME: CONVERT(VARCHAR(19), "{{ col_name }}", 126) + '.000000000'

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/azure_synapse/query/query_generator_azure_synapse.py

@@ -44,6 +44,9 @@ from snowflake.snowflake_data_validation.query.query_generator_base import (
     QueryGeneratorBase,
     resolve_table_context_modifiers,
 )
+from snowflake.snowflake_data_validation.query.tsql_float_remainder import (
+    TsqlFloatMetricModifierMixin,
+)
 from snowflake.snowflake_data_validation.sqlserver.query.charset_normalization import (
     SqlServerCharacterSetResolver,
 )
@@ -72,7 +75,7 @@ def build_azure_synapse_float_bit_canonical_expr(col_ref: str) -> str:
     return build_binary64_canonical_expr(col_ref, dialect=Platform.AZURE_SYNAPSE.value)
 
 
-class QueryGeneratorAzureSynapse(QueryGeneratorBase):
+class QueryGeneratorAzureSynapse(TsqlFloatMetricModifierMixin, QueryGeneratorBase):
     """Azure Synapse Analytics implementation of the query generator.
 
     Uses T-SQL syntax shared with SQL Server.  L3 row hashing is emitted as a

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/bigquery/extractor/templates/bigquery_datatypes_normalization_templates.yaml

@@ -47,11 +47,15 @@ FLOAT: '{{ float_bit_shim }}'
 # bounded BIGNUMERIC(p, s) that fits NUMBER hashes identically. A bare
 # BIGNUMERIC is created as DECFLOAT (SnowConvert engine parity); precision
 # above 38 or scale above 37 reports as an L1 WARNING rather than a schema
-# failure, and L2/L3 are not expected to reach parity on the extreme form.
+# failure.
 NUMERIC: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
 DECIMAL: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
 BIGNUMERIC: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
 BIGDECIMAL: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
+# A BIGNUMERIC / BIGDECIMAL whose mirror is DECFLOAT (the paired target type, or
+# a bare type when unpaired) emits the exact canonical decimal text Snowflake
+# DECFLOAT does. A value past DECFLOAT's 38 digits then reports as a mismatch.
+BIGNUMERIC_DECFLOAT: '{{ decfloat_shim }}'
 
 # Snowflake BOOLEAN normalizes to uppercase 'TRUE'/'FALSE' (see
 # snowflake_datatypes_normalization_templates.yaml); match it so the row hashes agree.
@@ -65,7 +69,8 @@ BYTES: UPPER(TO_HEX(`{{ col_name }}`))
 
 # %E4Y zero-pads the year to 4 digits so year 1 renders "0001" (matches Snowflake YYYY).
 DATE: FORMAT_DATE('%E4Y-%m-%d', `{{ col_name }}`)
-TIME: FORMAT_TIME('%H:%M:%S', `{{ col_name }}`)
+# TIME: microseconds + '000' pad to nine digits, cut to the precision both sides share.
+TIME: LEFT(FORMAT_TIME('%H:%M:%E6S', `{{ col_name }}`) || '000', {{ time_text_length }})
 DATETIME: FORMAT_DATETIME('%E4Y-%m-%dT%H:%M:%E9S', `{{ col_name }}`)
 TIMESTAMP: FORMAT_TIMESTAMP('%E4Y-%m-%dT%H:%M:%E9S%Ez', `{{ col_name }}`, 'UTC')
 

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/bigquery/query/query_generator_bigquery.py

@@ -17,7 +17,12 @@ from __future__ import annotations
 
 import logging
 
+from shared.datatypes.bigquery import BigQueryType
 from shared.datatypes.common import CommonType
+from shared.datatypes.snowflake import SnowflakeType
+from snowflake.snowflake_data_validation.query.decimal_text_normalization import (
+    build_decimal_text_canonical_expr,
+)
 from snowflake.snowflake_data_validation.query.float_bit_normalization import (
     build_binary64_canonical_expr,
 )
@@ -33,6 +38,10 @@ from snowflake.snowflake_data_validation.utils.constants import (
     METRIC_COLUMN_MODIFIER_PLACEHOLDER,
     Platform,
 )
+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.table_context import TableContext
 from snowflake.snowflake_data_validation.validation.comparison_codec import (
     ComparisonCodec,
@@ -43,6 +52,10 @@ from snowflake.snowflake_data_validation.validation.comparison_codec import (
 
 LOGGER = logging.getLogger(__name__)
 
+_WIDE_NUMERIC_BASE_TYPES = frozenset({BigQueryType.BIGNUMERIC, BigQueryType.BIGDECIMAL})
+# Normalization key for a BIGNUMERIC / BIGDECIMAL whose Snowflake mirror is DECFLOAT.
+BIGNUMERIC_DECFLOAT_NORMALIZATION_KEY = "BIGNUMERIC_DECFLOAT"
+
 
 def build_bigquery_float_bit_canonical_expr(col_ref: str) -> str:
     """Return the exact binary64 tuple used for BigQuery float validation."""
@@ -151,6 +164,27 @@ class QueryGeneratorBigQuery(QueryGeneratorBase):
         )
         return build_bigquery_float_bit_canonical_expr(value_expr)
 
+    def build_decfloat_shim(self, column, col_ref: str) -> str:
+        """Canonicalize a BIGNUMERIC mirrored as DECFLOAT from its exact ``STRING`` text."""
+        return build_decimal_text_canonical_expr(f"CAST({col_ref} AS STRING)", dialect=self.platform.value)
+
+    def _lands_in_decfloat(self, column, table_context: TableContext) -> bool:
+        """Return True when a BIGNUMERIC / BIGDECIMAL column's Snowflake mirror is DECFLOAT.
+
+        The paired target type decides when it is known: Iceberg and user-chosen
+        targets keep a bare BIGNUMERIC on NUMBER. Without it, a bare type follows
+        the create path, which emits DECFLOAT (``apply_type_parameters``).
+        """
+        if self.normalize_bigquery_type(column.data_type) not in _WIDE_NUMERIC_BASE_TYPES:
+            return False
+        target_type = get_paired_target_column_types(table_context).get(column.name)
+        if isinstance(target_type, str):
+            return normalize_snowflake_base_type(target_type) == SnowflakeType.DECFLOAT
+        if "(" in column.data_type:
+            return False
+        LOGGER.debug(f"No paired target type for {column.data_type} {column.name}; assuming the DECFLOAT mirror the create path emits.")
+        return True
+
     def _apply_metric_column_modifier(
         self,
         metric_template: str,
@@ -200,8 +234,11 @@ class QueryGeneratorBigQuery(QueryGeneratorBase):
         self,
         column,
         datatypes_normalization_templates: dict[str, str],
+        table_context: TableContext,
     ) -> str:
         base_type = self.normalize_bigquery_type(column.data_type)
+        if self._lands_in_decfloat(column, table_context):
+            base_type = BIGNUMERIC_DECFLOAT_NORMALIZATION_KEY
         normalization_template = datatypes_normalization_templates.get(base_type)
         if normalization_template is None:
             LOGGER.debug(
@@ -227,6 +264,7 @@ class QueryGeneratorBigQuery(QueryGeneratorBase):
             normalization_template = self._resolve_datatype_normalization_template(
                 column,
                 datatypes_normalization_templates,
+                table_context,
             )
             normalization_template = resolve_column_normalization_template(
                 column.name,

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/db2/extractor/templates/db2_datatypes_normalization_templates.yaml

@@ -15,6 +15,7 @@
 # - {{ numeric_format_mask }} is a pre-built DB2-valid 9…90 mask (no FM prefix)
 #   from the query generator's _build_fm_to_char_mask override.
 # - {{ float_bit_shim }} expands to the IEEE-754 sign|exponent|significand tuple.
+# - {{ decfloat_shim }} expands to DECFLOAT's exact canonical decimal text.
 # - HEX(HASH(val, 0)) computes MD5 in DB2 11.5 (algorithm 0 = MD5) using the built-in
 #   SYSIBM.HASH scalar — no special privilege (unlike SYSPROC.HASH2, which is often absent).
 # - Double-quoted column names handle lowercase/mixed-case identifiers.
@@ -37,7 +38,8 @@ FLOAT: '{{ float_bit_shim }}'
 REAL: '{{ float_bit_shim }}'
 DOUBLE: '{{ float_bit_shim }}'
 DOUBLE PRECISION: '{{ float_bit_shim }}'
-DECFLOAT: '{{ float_bit_shim }}'
+# DECFLOAT(16/34) is decimal: a DOUBLE drops digits past ~16, so compare its exact text.
+DECFLOAT: '{{ decfloat_shim }}'
 
 # ---- Character types (text family) ----
 # CHAR/NCHAR are blank-padded; the Snowflake E2E/SCAI mirror is VARCHAR/TEXT.
@@ -103,9 +105,9 @@ XML: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN OCTET_LENGTH(XMLSERIALIZE
 # DATE: no fractional seconds in DB2 DATE.
 DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
 # TIME: no fractional seconds in DB2 TIME. DB2's TO_CHAR / VARCHAR_FORMAT has no
-# TIME signature (SQL0245N, ambiguous routine), so CHAR(col, JIS) renders the
-# hh:mm:ss form Snowflake's TO_CHAR(col, 'HH24:MI:SS') produces.
-TIME: CHAR("{{ col_name }}", JIS)
+# TIME signature (SQL0245N, ambiguous routine), so CHAR(col, JIS) renders hh:mm:ss,
+# padded to nine zero digits and cut like Snowflake's TIME ({{ time_text_length }}).
+TIME: LEFT(CHAR("{{ col_name }}", JIS) || '.000000000', {{ time_text_length }})
 # TIMESTAMP: ISO 8601 with T-separator and 9 fractional digits, Snowflake
 # TIMESTAMP_NTZ's .FF9 canonical form. FF9 pads TIMESTAMP(0-8) with zeros and keeps
 # digits 7-9 of TIMESTAMP(9-12), the most Snowflake stores. DB2's TO_CHAR rejects an

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/db2/query/query_generator_db2.py

@@ -21,15 +21,22 @@ below give DB2 its own DB2-valid rendering that still matches Snowflake
   canonical wrapper and uses the base substitution with the DB2 mask.
 * ``build_float_bit_shim`` — IEEE-754 ``sign|exponent|significand`` tuple (same
   contract as Snowflake FLOAT). DB2 ``LN``/``POWER`` run in ``DOUBLE``.
+* ``build_decfloat_shim`` — DECFLOAT's exact ``CHAR`` text, canonicalized like
+  Snowflake DECFLOAT's ``TO_VARCHAR`` (a ``DOUBLE`` keeps ~16 of its 34 digits).
 """
 
 from pathlib import Path
 
 import jinja2
 
+from shared.datatypes.common import CommonType
+from shared.datatypes.db2 import Db2Type
 from snowflake.snowflake_data_validation.oracle.query.query_generator_oracle import (
     QueryGeneratorOracle,
 )
+from snowflake.snowflake_data_validation.query.decimal_text_normalization import (
+    build_decimal_text_canonical_expr,
+)
 from snowflake.snowflake_data_validation.query.float_bit_normalization import (
     build_binary64_canonical_expr,
 )
@@ -40,6 +47,7 @@ from snowflake.snowflake_data_validation.query.query_generator_base import (
     QueryGeneratorBase,
     resolve_table_context_modifiers,
 )
+from snowflake.snowflake_data_validation.query.sql_type_families import SNOWFLAKE_FLOAT_TYPE_NAMES
 from snowflake.snowflake_data_validation.utils.constants import (
     NULL_HASHING_SENTINEL,
     NULL_HASHING_SENTINEL_KEY,
@@ -47,6 +55,11 @@ from snowflake.snowflake_data_validation.utils.constants import (
     ROW_HASH_COLUMN_DELIMITER_KEY,
     Platform,
 )
+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.table_context import TableContext
 
 
 # Wide enough for BIGINT (19 digits) and DECIMAL(31); the trailing 0 forces the
@@ -57,8 +70,8 @@ _DB2_INTEGER_NINES = 31
 def build_db2_float_bit_canonical_expr(col_ref: str) -> str:
     """Return the exact binary64 tuple used for DB2 float validation.
 
-    ``LN``/``POWER`` must run in IEEE-754, so values (including ``DECFLOAT``)
-    are cast to ``DOUBLE`` first. A value that is already ``DOUBLE`` (including
+    ``LN``/``POWER`` must run in IEEE-754, so values are cast to ``DOUBLE``
+    first. A value that is already ``DOUBLE`` (including
     float32-widened ``REAL``) is left unchanged.
     """
     ieee_expr = col_ref
@@ -130,6 +143,31 @@ class QueryGeneratorDb2(QueryGeneratorOracle):
         value_expr = float_bit_input_expr(col_ref, data_type, dialect=self.platform.value)
         return build_db2_float_bit_canonical_expr(value_expr)
 
+    def build_decfloat_shim(self, column, col_ref: str) -> str:
+        """Canonicalize DECFLOAT from its exact ``CHAR`` text (``NaN``/``Infinity`` become markers)."""
+        return build_decimal_text_canonical_expr(f"CHAR({col_ref})", dialect=self.platform.value)
+
+    def _resolve_datatype_normalization_template(
+        self,
+        column,
+        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]
+        return super()._resolve_datatype_normalization_template(
+            column,
+            datatypes_normalization_templates,
+            table_context,
+        )
+
     # ------------------------------------------------------------------
     # text_comparison_mode: apply the per-column text codec (raw/logical)
     #

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/executer/base_validation_executor.py

@@ -39,6 +39,7 @@ from snowflake.snowflake_data_validation.utils.constants import (
 from snowflake.snowflake_data_validation.utils.context import Context
 from snowflake.snowflake_data_validation.utils.iso_dv_common import (
     attach_paired_column_types_for_iso_timestamp_dv,
+    attach_paired_time_comparison_precision,
 )
 from snowflake.snowflake_data_validation.utils.model.table_column_metadata import (
     TableColumnMetadata,
@@ -129,6 +130,11 @@ class BaseValidationExecutor(ABC):
                 table_configuration.column_mappings,
             )
         )
+        attach_paired_time_comparison_precision(
+            source_table_context,
+            target_table_context,
+            self.context.source_platform,
+        )
 
         if validations[SCHEMA_VALIDATION_KEY]:
             self.execute_schema_validation(

{snowflake_data_validation-1.44.0 → snowflake_data_validation-1.44.1}/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_datatypes_normalization_templates.yaml

@@ -88,9 +88,10 @@ SERIAL: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC), '{{ numeric_format_mask
 SMALLINT: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC), '{{ numeric_format_mask }}'))
 SMALLSERIAL: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC), '{{ numeric_format_mask }}'))
 TEXT: '"{{ col_name }}"'
-TIME: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
+# TIME: microseconds + '000' pad to nine digits, cut to the precision both sides share.
+TIME: LEFT(TO_CHAR("{{ col_name }}", 'HH24:MI:SS.US') || '000', {{ time_text_length }})
 TIME WITH TIME ZONE: CASE WHEN "{{ col_name }}" IS NULL THEN NULL ELSE '1970-01-01T' || TO_CHAR(CAST("{{ col_name }}" AS TIME), 'HH24:MI:SS.US') || '000' || CASE WHEN EXTRACT(TIMEZONE FROM "{{ col_name }}") < 0 THEN '-' ELSE '+' END || LPAD(CAST(FLOOR(ABS(EXTRACT(TIMEZONE FROM "{{ col_name }}")) / 3600) AS TEXT), 2, '0') || ':' || LPAD(CAST(FLOOR(MOD(ABS(EXTRACT(TIMEZONE FROM "{{ col_name }}")), 3600) / 60) AS TEXT), 2, '0') END
-TIME WITHOUT TIME ZONE: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
+TIME WITHOUT TIME ZONE: LEFT(TO_CHAR("{{ col_name }}", 'HH24:MI:SS.US') || '000', {{ time_text_length }})
 TIMESTAMP: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD"T"HH24:MI:SS.US') || '000'
 # timestamptz has no stored offset; compare UTC instants as ISO FF9 (+00:00).
 TIMESTAMP WITH TIME ZONE: TO_CHAR(("{{ col_name }}" AT TIME ZONE 'UTC'), 'YYYY-MM-DD"T"HH24:MI:SS.US') || '000+00:00'

snowflake_data_validation-1.44.1/src/snowflake/snowflake_data_validation/query/decimal_text_normalization.py

@@ -0,0 +1,130 @@
+"""Exact decimal canonicalization for cross-engine DECFLOAT comparison.
+
+DECFLOAT holds up to 34 (DB2) or 38 (Snowflake) significant decimal digits, so
+it must not be compared through IEEE-754 binary64, which keeps about 16. Each
+engine renders the value as text instead, and the text is reduced in SQL to
+one canonical form that depends only on the value:
+
+* ``[-]d[.ddd]E<n>``: the significant digits with leading and trailing zeros
+  removed, one digit before the point, and the adjusted decimal exponent;
+* ``0`` for every zero (``0``, ``-0``, ``0E+5``, ``0.000``);
+* ``NAN``, ``+INF`` and ``-INF`` for the special values, the markers the
+  binary64 tuple uses.
+
+The input text may be plain (``-0.00120``) or E-notation (``1.20E+3``,
+``1.2e-7``), with any sign, case or trailing zeros, so neither engine's own
+text format has to match the other's: ``1.50``, ``15E-1`` and ``1.5E+0`` all
+become ``1.5E0``.
+
+Every step is position arithmetic that is valid for any input, never a CASE
+branch that would fail if evaluated eagerly (DB2 may evaluate both branches).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DecimalTextSqlDialect:
+    """SQL spelling for the decimal-text canonicalizer. Output strings stay identical."""
+
+    # 1-based position of ``{needle}`` in ``{haystack}``, 0 when absent.
+    locate: str
+    ltrim_zeros: str
+    rtrim_zeros: str
+    integer_type: str
+    integer_text: str
+
+
+SNOWFLAKE_DECIMAL_TEXT_SQL = DecimalTextSqlDialect(
+    locate="POSITION({needle}, {haystack})",
+    ltrim_zeros="LTRIM({value}, '0')",
+    rtrim_zeros="RTRIM({value}, '0')",
+    integer_type="INTEGER",
+    integer_text="CAST({value} AS VARCHAR)",
+)
+
+# DB2 LUW: TRIM(LEADING .. FROM ..) predates the two-argument LTRIM/RTRIM (11.1).
+DB2_DECIMAL_TEXT_SQL = DecimalTextSqlDialect(
+    locate="LOCATE({needle}, {haystack})",
+    ltrim_zeros="TRIM(LEADING '0' FROM {value})",
+    rtrim_zeros="TRIM(TRAILING '0' FROM {value})",
+    integer_type="INTEGER",
+    integer_text="CAST({value} AS VARCHAR(12))",
+)
+
+BIGQUERY_DECIMAL_TEXT_SQL = DecimalTextSqlDialect(
+    locate="STRPOS({haystack}, {needle})",
+    ltrim_zeros="LTRIM({value}, '0')",
+    rtrim_zeros="RTRIM({value}, '0')",
+    integer_type="INT64",
+    integer_text="CAST({value} AS STRING)",
+)
+
+
+DECIMAL_TEXT_SQL_BY_DIALECT: dict[str, DecimalTextSqlDialect] = {
+    "snowflake": SNOWFLAKE_DECIMAL_TEXT_SQL,
+    "db2": DB2_DECIMAL_TEXT_SQL,
+    "bigquery": BIGQUERY_DECIMAL_TEXT_SQL,
+}
+
+
+_E = "'E'"
+_POINT = "'.'"
+
+
+def _resolve_dialect(dialect: str | DecimalTextSqlDialect) -> DecimalTextSqlDialect:
+    if not isinstance(dialect, str):
+        return dialect
+    sql = DECIMAL_TEXT_SQL_BY_DIALECT.get(dialect.lower())
+    if sql is None:
+        raise ValueError(f"Unknown decimal-text SQL dialect: {dialect!r}")
+    return sql
+
+
+def build_decimal_text_canonical_expr(
+    text_expr: str,
+    *,
+    dialect: str | DecimalTextSqlDialect,
+) -> str:
+    """Return SQL that reduces the exact decimal text *text_expr* to its canonical form.
+
+    *text_expr* must render every digit the engine stores (``TO_VARCHAR`` on
+    Snowflake, ``CHAR`` on DB2, ``CAST(.. AS STRING)`` on BigQuery). The digits
+    are joined across the point, ``exp10 = exponent - fraction digits``, and the
+    adjusted exponent of the first significant digit is
+    ``exp10 + len(digits without leading zeros) - 1``.
+    """
+    sql = _resolve_dialect(dialect)
+
+    def locate(needle: str, haystack: str) -> str:
+        return sql.locate.format(needle=needle, haystack=haystack)
+
+    text = f"UPPER(TRIM({text_expr}))"
+    # Always carry an exponent, so the mantissa and exponent split never needs a CASE.
+    with_exponent = f"({text} || CASE WHEN {locate(_E, text)} = 0 THEN 'E0' ELSE '' END)"
+    exponent_at = locate(_E, with_exponent)
+    mantissa = f"SUBSTR({with_exponent}, 1, {exponent_at} - 1)"
+    exponent = f"CAST(REPLACE(SUBSTR({with_exponent}, {exponent_at} + 1), '+', '') AS {sql.integer_type})"
+    point_at = locate(_POINT, mantissa)
+    fraction_digits = f"(CASE WHEN {point_at} = 0 THEN 0 ELSE LENGTH({mantissa}) - {point_at} END)"
+    digits = f"REPLACE(REPLACE(REPLACE({mantissa}, '-', ''), '+', ''), '.', '')"
+    significant = sql.ltrim_zeros.format(value=digits)
+    coefficient_digits = sql.rtrim_zeros.format(value=significant)
+    adjusted_exponent = f"({exponent} - {fraction_digits} + LENGTH({significant}) - 1)"
+    coefficient = (
+        f"SUBSTR({coefficient_digits}, 1, 1) || "
+        f"CASE WHEN LENGTH({coefficient_digits}) > 1 THEN '.' || SUBSTR({coefficient_digits}, 2) ELSE '' END"
+    )
+    sign = f"CASE WHEN SUBSTR({text}, 1, 1) = '-' THEN '-' ELSE '' END"
+    canonical = f"{sign} || {coefficient} || 'E' || {sql.integer_text.format(value=adjusted_exponent)}"
+
+    return (
+        f"CASE WHEN {text_expr} IS NULL THEN NULL "
+        f"WHEN {text} LIKE '%NAN%' THEN 'NAN' "
+        f"WHEN {text} LIKE '%INF%' THEN (CASE WHEN SUBSTR({text}, 1, 1) = '-' THEN '-INF' ELSE '+INF' END) "
+        # COALESCE: a DB2 database in Oracle compatibility mode turns '' into NULL.
+        f"WHEN COALESCE(LENGTH({significant}), 0) = 0 THEN '0' "
+        f"ELSE {canonical} END"
+    )

snowflake_data_validation-1.44.1/src/snowflake/snowflake_data_validation/query/float_aggregate_reduction.py

@@ -0,0 +1,57 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Signed binary64 significand for Snowflake float avg, sum, and stddev against Teradata.
+
+Teradata ``MOD`` and Snowflake ``%`` stop agreeing once a magnitude is too
+large for an exact remainder (around 1e20 for modulus 2097143). The signed
+unit significand of the same stored value matches on both engines, and
+``STDDEV_POP`` of that significand stays inside the L2 absolute tolerance.
+"""
+
+from __future__ import annotations
+
+from shared.datatypes.common import CommonType
+from snowflake.snowflake_data_validation.query.float_bit_normalization import (
+    SNOWFLAKE_BINARY64_SQL,
+    build_binary64_signed_significand_expr,
+)
+
+
+_FLOAT_AGGREGATE_SQL = {"avg": "AVG", "sum": "SUM", "stddev": "STDDEV_POP"}
+_SHIPPED_SNOWFLAKE_FLOAT_MODIFIER = "%2097143"
+
+
+def _base_type(data_type: str) -> str:
+    return data_type.strip().upper().split("(", 1)[0].strip()
+
+
+def is_shipped_snowflake_float_aggregate(metric_name: str, metric_template: str, column_sql: str) -> bool:
+    """Return whether *metric_template* is the packaged Snowflake FLOAT avg/sum/stddev, modifier on or off.
+
+    A column override or customized template YAML is the user's SQL, which both
+    engines must run as written; only the packaged default is replaced.
+    """
+    aggregate = _FLOAT_AGGREGATE_SQL.get(metric_name)
+    if aggregate is None:
+        return False
+    compact = "".join(metric_template.split())
+    column = "".join(column_sql.split())
+    return compact in {
+        f"{aggregate}({column})",
+        f"{aggregate}({column}{_SHIPPED_SNOWFLAKE_FLOAT_MODIFIER})",
+    }
+
+
+def snowflake_teradata_float_aggregate_template(metric_name: str, data_type: str, column_sql: str) -> str | None:
+    """Return the Snowflake twin of the Teradata float avg/sum/stddev metric templates, or None.
+
+    The Teradata side lives in ``teradata_column_metrics_templates.yaml`` (FLOAT,
+    REAL and DOUBLE PRECISION), rendered from the same builder in the Teradata
+    dialect. The Snowflake YAML is shared by every source, so
+    this pairing-only rewrite runs from ``QueryGeneratorSnowflake``.
+    """
+    if metric_name not in _FLOAT_AGGREGATE_SQL or _base_type(data_type) != CommonType.FLOAT:
+        return None
+    significand = build_binary64_signed_significand_expr(column_sql, dialect=SNOWFLAKE_BINARY64_SQL)
+    return f"{_FLOAT_AGGREGATE_SQL[metric_name]}({significand})"