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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-data-validation
-Version: 1.46.0
+Version: 1.46.2
 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.7; extra == 'scai'
+Requires-Dist: snowflake-code-unit-registry>=0.9.10; extra == 'scai'
 Provides-Extra: sqlite
 Requires-Dist: sqlean-py>=3.45.0; extra == 'sqlite'
 Provides-Extra: sqlserver
@@ -230,6 +230,20 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.46.2
+
+**Improvements**
+
+- Improved L2 validation to report why each column is left out (`CAST_NOT_TOTAL` or `NO_COMPARABLE_METRIC`) in `EVALUATION_CRITERIA` and `COMMENTS`, and to leave Iceberg Teradata `TIME` and `TIMESTAMP` columns to L3.
+
+**Bug fixes**
+
+- Fixed SQL Server `DATETIMEOFFSET` L2 comparison by comparing values in UTC, and L3 comparison of staged ISO time-zone text for SQL Server and Teradata.
+
+### v1.46.1
+
+No user-facing changes in this release.
+
 ### v1.46.0
 
 **Bug fixes**

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

@@ -139,6 +139,20 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.46.2
+
+**Improvements**
+
+- Improved L2 validation to report why each column is left out (`CAST_NOT_TOTAL` or `NO_COMPARABLE_METRIC`) in `EVALUATION_CRITERIA` and `COMMENTS`, and to leave Iceberg Teradata `TIME` and `TIMESTAMP` columns to L3.
+
+**Bug fixes**
+
+- Fixed SQL Server `DATETIMEOFFSET` L2 comparison by comparing values in UTC, and L3 comparison of staged ISO time-zone text for SQL Server and Teradata.
+
+### v1.46.1
+
+No user-facing changes in this release.
+
 ### v1.46.0
 
 **Bug fixes**

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

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

{snowflake_data_validation-1.46.0 → snowflake_data_validation-1.46.2}/src/snowflake/snowflake_data_validation/public/model/metrics_result_shape.py

@@ -31,19 +31,26 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import NotRequired, TypedDict
 
+from snowflake.snowflake_data_validation.utils.metrics_exclusion import (
+    MetricsExclusion,
+    MetricsExclusionDict,
+)
+
 
 class MetricsResultShapeDict(TypedDict):
     """JSON-serializable form of :class:`MetricsResultShape`.
 
     Each entry in ``cells`` is a ``[column_name, metric_name]`` pair
     (list, not tuple, for JSON compatibility).
-    ``excluded_columns`` names columns omitted from ``cells``. Payloads that
-    omit the key have no such columns.
+    ``exclusions`` lists the columns omitted from ``cells`` with the reason.
+    ``excluded_columns`` repeats their names for readers that predate the
+    reasons. Payloads that omit both keys have no such columns.
     """
 
     cells: list[list[str]]
     all_metrics: list[str]
     excluded_columns: NotRequired[list[str]]
+    exclusions: NotRequired[list[MetricsExclusionDict]]
 
 
 @dataclass(frozen=True)
@@ -59,15 +66,20 @@ class MetricsResultShape:
             long-format DataFrame.  Missing (column, metric) pairs are
             filled with ``NaN`` — matching the prior ``NULL AS metric``
             behavior of the CTE/UNION implementation.
-        excluded_columns: Column names left out of ``cells`` because an
-            Iceberg v2 compatible profile stored them as VARCHAR. Empty
-            when every column is measured.
+        exclusions: Columns left out of ``cells`` because an Iceberg target
+            stored them as text no metric can read in full, each with the
+            reason. Empty when every column is measured.
 
     """
 
     cells: list[tuple[str, str]]
     all_metrics: list[str] = field(default_factory=list)
-    excluded_columns: list[str] = field(default_factory=list)
+    exclusions: list[MetricsExclusion] = field(default_factory=list)
+
+    @property
+    def excluded_columns(self) -> list[str]:
+        """Names of the columns in :attr:`exclusions`, in order."""
+        return [exclusion.column for exclusion in self.exclusions]
 
     def to_dict(self) -> MetricsResultShapeDict:
         """Return a JSON-serializable representation.
@@ -79,7 +91,8 @@ class MetricsResultShape:
         return MetricsResultShapeDict(
             cells=[list(cell) for cell in self.cells],
             all_metrics=list(self.all_metrics),
-            excluded_columns=list(self.excluded_columns),
+            excluded_columns=self.excluded_columns,
+            exclusions=[exclusion.to_dict() for exclusion in self.exclusions],
         )
 
     @classmethod
@@ -88,5 +101,10 @@ class MetricsResultShape:
         raw_cells = data.get("cells", []) or []
         cells: list[tuple[str, str]] = [(str(cell[0]), str(cell[1])) for cell in raw_cells]
         all_metrics = [str(m) for m in (data.get("all_metrics") or [])]
-        excluded_columns = [str(name) for name in (data.get("excluded_columns") or [])]
-        return cls(cells=cells, all_metrics=all_metrics, excluded_columns=excluded_columns)
+        raw_exclusions = data.get("exclusions")
+        if raw_exclusions is not None:
+            exclusions = [MetricsExclusion.from_dict(item) for item in raw_exclusions]
+        else:
+            # A payload from a release without reasons carries only the names.
+            exclusions = [MetricsExclusion.legacy(str(name)) for name in (data.get("excluded_columns") or [])]
+        return cls(cells=cells, all_metrics=all_metrics, exclusions=exclusions)

{snowflake_data_validation-1.46.0 → snowflake_data_validation-1.46.2}/src/snowflake/snowflake_data_validation/public/validation/metrics_validation.py

@@ -40,10 +40,9 @@ from snowflake.snowflake_data_validation.utils.constants import (
     ValidationLevel,
 )
 from snowflake.snowflake_data_validation.utils.iceberg_dv_common import (
-    FLATTENED_VARCHAR_METRICS_COMMENT,
-    FLATTENED_VARCHAR_METRICS_CRITERIA,
     FLATTENED_VARCHAR_STORED_TYPE,
 )
+from snowflake.snowflake_data_validation.utils.metrics_exclusion import MetricsExclusion
 from snowflake.snowflake_data_validation.utils.model.table_context import (
     TableContext,
     platform_identifier_manager,
@@ -58,25 +57,25 @@ from snowflake.snowflake_data_validation.validation.validation_report_status imp
 
 def append_flattened_metrics_exclusions(
     results: pd.DataFrame,
-    excluded_columns: list[str] | None,
+    excluded_columns: list[MetricsExclusion] | None,
     *,
     table_name: str,
 ) -> pd.DataFrame:
-    """Append one WARNING row per column omitted from the metrics SELECT."""
+    """Append one WARNING row per column omitted from the metrics SELECT, naming the reason."""
     if not excluded_columns:
         return results
     rows = [
         {
             VALIDATION_TYPE_KEY: ValidationLevel.METRICS_VALIDATION.value,
             TABLE_KEY: table_name,
-            COLUMN_VALIDATED_KEY: column_name,
-            EVALUATION_CRITERIA_KEY: FLATTENED_VARCHAR_METRICS_CRITERIA,
+            COLUMN_VALIDATED_KEY: exclusion.column,
+            EVALUATION_CRITERIA_KEY: exclusion.reason.value,
             SOURCE_VALUE_KEY: None,
             SNOWFLAKE_VALUE_KEY: FLATTENED_VARCHAR_STORED_TYPE,
             STATUS_KEY: Result.WARNING.value,
-            COMMENTS_KEY: FLATTENED_VARCHAR_METRICS_COMMENT,
+            COMMENTS_KEY: exclusion.detail,
         }
-        for column_name in excluded_columns
+        for exclusion in excluded_columns
     ]
     exclusion_frame = pd.DataFrame(rows)
     if results is None or results.empty:
@@ -91,7 +90,7 @@ def validate_metrics(
     column_mappings: dict[str, str],
     tolerance: float | None = DEFAULT_TOLERANCE,
     relative_tolerance: float | None = None,
-    excluded_columns: list[str] | None = None,
+    excluded_columns: list[MetricsExclusion] | None = None,
     target_names: Mapping[str, str] | None = None,
 ) -> ValidationResult:
     """Validate metrics by comparing source and target DataFrames.
@@ -108,8 +107,9 @@ def validate_metrics(
             Pass ``None`` to skip the absolute check when only a relative bound is configured.
         relative_tolerance: Optional relative tolerance (fraction). ``0.001`` = 0.1%.
             When both are set, a pair passes if either check passes (OR).
-        excluded_columns: Columns left out of the metrics SELECT (Iceberg v2
-            flattened VARCHAR columns); each is reported as one WARNING row.
+        excluded_columns: Columns left out of the metrics SELECT because an
+            Iceberg target stored them as text no metric reads in full; each is
+            reported as one WARNING row that names the reason.
         target_names: Each actual source column's actual target name, resolved by
             the caller (Cloud Data Validation: the column data migration creates).
             With it the comparison pairs names exactly; without it, through

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

@@ -88,9 +88,9 @@ from snowflake.snowflake_data_validation.utils.iceberg_dv_common import (
     IcebergProfile,
 )
 from snowflake.snowflake_data_validation.utils.iso_dv_common import (
-    column_omitted_from_iceberg_metrics,
     get_paired_source_column_types,
     get_paired_target_column_types,
+    iceberg_metrics_exclusion,
 )
 from snowflake.snowflake_data_validation.utils.measure_collation import COUNT_DISTINCT_METRIC
 from snowflake.snowflake_data_validation.utils.model.table_context import TableContext, configured_object_name
@@ -117,6 +117,7 @@ if TYPE_CHECKING:  # pragma: no cover - used only for type hints.
     from snowflake.snowflake_data_validation.public.model.generated_query import (
         GeneratedMetricsQuery,
     )
+    from snowflake.snowflake_data_validation.utils.metrics_exclusion import MetricsExclusion
     from snowflake.snowflake_data_validation.utils.model.column_metadata import (
         ColumnMetadata,
     )
@@ -813,15 +814,15 @@ class QueryGeneratorBase(ABC):
         delimiter_literal = f"'{ROW_HASH_COLUMN_DELIMITER}'"
         return f", {delimiter_literal}, ".join(column_names)
 
-    def _excludes_iceberg_flattened_column(self, col, table_context: TableContext) -> bool:
-        """Return True when this column is omitted from an Iceberg metrics SELECT.
+    def _iceberg_metrics_exclusion(self, col: ColumnMetadata, table_context: TableContext) -> MetricsExclusion | None:
+        """Return why this column is omitted from an Iceberg metrics SELECT, or None to measure it.
 
         The profile is checked first: a table that is not Iceberg keeps every
         column, so its origin and paired column types are never read.
         """
         profile = IcebergProfile.from_table_context(table_context)
         if not profile.is_active:
-            return False
+            return None
         if table_context.origin == Origin.TARGET:
             source_type = get_paired_source_column_types(table_context).get(col.name)
             target_type = col.data_type
@@ -830,7 +831,8 @@ class QueryGeneratorBase(ABC):
             source_type = col.data_type
             target_type = get_paired_target_column_types(table_context).get(col.name)
             platform = table_context.platform
-        return column_omitted_from_iceberg_metrics(
+        return iceberg_metrics_exclusion(
+            col.name,
             source_type if isinstance(source_type, str) else None,
             target_type if isinstance(target_type, str) else None,
             paired_source_platform=platform,
@@ -897,15 +899,16 @@ class QueryGeneratorBase(ABC):
         cells: list[tuple[str, str]] = []
         all_metrics: list[str] = []
         all_metrics_seen: set[str] = set()
-        excluded_columns: list[str] = []
+        exclusions: list[MetricsExclusion] = []
         # Aliases follow appearance in ``cells``. A gap from a skipped column
         # would make the in-warehouse compare read the next metric under the
         # wrong ``cN_mM`` name.
         measured_idx = 0
 
         for col in columns:
-            if self._excludes_iceberg_flattened_column(col, table_context):
-                excluded_columns.append(col.name)
+            exclusion = self._iceberg_metrics_exclusion(col, table_context)
+            if exclusion is not None:
+                exclusions.append(exclusion)
                 continue
             col_type = self._resolve_metrics_col_type(col, table_context)
 
@@ -988,7 +991,7 @@ class QueryGeneratorBase(ABC):
             if metric_idx > 0:
                 measured_idx += 1
 
-        if not select_exprs and not excluded_columns:
+        if not select_exprs and not exclusions:
             error_message = f"Metrics templates are missing for the column data types in {table_context.fully_qualified_name}."
             raise Exception(error_message)
 
@@ -1014,7 +1017,7 @@ class QueryGeneratorBase(ABC):
         shape = MetricsResultShape(
             cells=cells,
             all_metrics=all_metrics,
-            excluded_columns=excluded_columns,
+            exclusions=exclusions,
         )
         return GeneratedMetricsQuery(query_string=sql, result_shape=shape)
 

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

@@ -284,17 +284,19 @@ VARCHAR_DATE_SIGNED:
     metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
     metric_return_datatype: NUMBER
 
-# Signed-year ISO TIMESTAMPTZ text (Redshift Iceberg, SNOW-4381535), staged in UTC.
-# Parse like the column comment's cast back; TO_CHAR prints a zero offset as Z.
+# ISO TIMESTAMPTZ text with a per-row offset: Redshift Iceberg (signed year, UTC,
+# SNOW-4381535) and SQL Server DATETIMEOFFSET (SNOW-4353895). Parse like the column
+# comment's cast back, then render the instant in UTC like the source metrics do;
+# TO_CHAR prints a zero offset as Z.
 VARCHAR_TIMESTAMP_TZ_SIGNED:
   min:
     metric_query: 'MIN(DATEADD(nanosecond, DATEDIFF(nanosecond, ''00:00:00''::TIME, TRY_TO_TIME(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''T([0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?)'', 1, 1, ''e'', 1))), DATEADD(day, DATEDIFF(day, ''2000-01-01''::DATE, IFF(TRY_TO_NUMBER(REGEXP_SUBSTR(TO_VARCHAR(TRY_TO_DATE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+-[0-9]{2}-[0-9]{2})'', 1, 1, ''e'', 1)), ''YYYY-MM-DD''), ''^(-?[0-9]+)-'', 1, 1, ''e'', 1), 38, 0) = TRY_TO_NUMBER(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+)-'', 1, 1, ''e'', 1), 38, 0), TRY_TO_DATE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+-[0-9]{2}-[0-9]{2})'', 1, 1, ''e'', 1)), NULL)), TRY_TO_TIMESTAMP_TZ(''2000-01-01 00:00:00 '' || COALESCE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''([+-][0-9]{2}:[0-9]{2})$'', 1, 1, ''e'', 1), ''+00:00''), ''YYYY-MM-DD HH24:MI:SS TZH:TZM''))))'
     metric_return_datatype: VARCHAR
-    metric_normalization: REGEXP_REPLACE(TO_CHAR({{ metric_query }}, 'YYYY-MM-DD"T"HH24:MI:SS.FF9TZH:TZM'), 'Z$', '+00:00')
+    metric_normalization: REGEXP_REPLACE(TO_CHAR(CONVERT_TIMEZONE('UTC', {{ metric_query }}), 'YYYY-MM-DD"T"HH24:MI:SS.FF9TZH:TZM'), 'Z$', '+00:00')
   max:
     metric_query: 'MAX(DATEADD(nanosecond, DATEDIFF(nanosecond, ''00:00:00''::TIME, TRY_TO_TIME(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''T([0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?)'', 1, 1, ''e'', 1))), DATEADD(day, DATEDIFF(day, ''2000-01-01''::DATE, IFF(TRY_TO_NUMBER(REGEXP_SUBSTR(TO_VARCHAR(TRY_TO_DATE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+-[0-9]{2}-[0-9]{2})'', 1, 1, ''e'', 1)), ''YYYY-MM-DD''), ''^(-?[0-9]+)-'', 1, 1, ''e'', 1), 38, 0) = TRY_TO_NUMBER(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+)-'', 1, 1, ''e'', 1), 38, 0), TRY_TO_DATE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''^(-?[0-9]+-[0-9]{2}-[0-9]{2})'', 1, 1, ''e'', 1)), NULL)), TRY_TO_TIMESTAMP_TZ(''2000-01-01 00:00:00 '' || COALESCE(REGEXP_SUBSTR(TRIM("{{ col_name }}"), ''([+-][0-9]{2}:[0-9]{2})$'', 1, 1, ''e'', 1), ''+00:00''), ''YYYY-MM-DD HH24:MI:SS TZH:TZM''))))'
     metric_return_datatype: VARCHAR
-    metric_normalization: REGEXP_REPLACE(TO_CHAR({{ metric_query }}, 'YYYY-MM-DD"T"HH24:MI:SS.FF9TZH:TZM'), 'Z$', '+00:00')
+    metric_normalization: REGEXP_REPLACE(TO_CHAR(CONVERT_TIMEZONE('UTC', {{ metric_query }}), 'YYYY-MM-DD"T"HH24:MI:SS.FF9TZH:TZM'), 'Z$', '+00:00')
   count_null:
     metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
     metric_return_datatype: NUMBER

{snowflake_data_validation-1.46.0 → snowflake_data_validation-1.46.2}/src/snowflake/snowflake_data_validation/utils/iceberg_dv_common.py

@@ -44,6 +44,7 @@ from snowflake.snowflake_data_validation.utils.constants import (
     LOAD_MODE_KEY,
     NANOSECOND_FRACTION_DIGITS,
     STORAGE_MODE_KEY,
+    Platform,
 )
 
 
@@ -81,6 +82,10 @@ _COMPLEX_SOURCE_BASES = frozenset(
 
 _VARCHAR_ISO_TZ = f"{CommonType.VARCHAR}_ISO_TZ"
 
+# SQL Server stages DATETIMEOFFSET as 7 digits + '00' with its offset, which its
+# L3 source template renders the same way; re-parsing would cut the fraction.
+_FLATTENED_SQLSERVER_ISO_TZ_SOURCE_BASES = frozenset({CommonType.DATETIMEOFFSET})
+
 _FLATTENED_REDSHIFT_SOURCE_BASES = frozenset(
     {
         CommonType.TIME,
@@ -96,6 +101,25 @@ _FLATTENED_REDSHIFT_SOURCE_BASES = frozenset(
     }
 )
 
+# Per source platform: zoned clocks whose L3 source template renders the staged
+# Iceberg VARCHAR text exactly. Platform is a StrEnum, so a raw value looks it up too.
+_RAW_ISO_TZ_TEXT_SOURCE_BASES: dict[str, frozenset[str]] = {
+    Platform.REDSHIFT: _FLATTENED_REDSHIFT_SOURCE_BASES,
+    Platform.SQLSERVER: _FLATTENED_SQLSERVER_ISO_TZ_SOURCE_BASES,
+    # Teradata stages TIMESTAMP WITH TIME ZONE as FF6 + '000' with its offset.
+    Platform.TERADATA: frozenset({CommonType.TIMESTAMP_WITH_TIME_ZONE, TeradataType.TIMESTAMP_WITH_TIME_ZONE_CODE}),
+}
+
+
+def _zoned_type_label(token: str | None) -> str:
+    """Drop the precision but keep a ``WITH TIME ZONE`` suffix: ``TIMESTAMP(6) WITH TIME ZONE``."""
+    text = " ".join(str(token or "").strip().upper().split())
+    if "(" in text and ")" in text:
+        head, _, rest = text.partition("(")
+        text = " ".join(f"{head} {rest.partition(')')[2]}".split())
+    return text
+
+
 # Physical-outcome normalization keys for an Iceberg target that stored a value
 # as text: the key names what the value physically became, not the source type.
 # Each must match a key in the per-platform *_datatypes_normalization_templates.yaml.
@@ -126,9 +150,8 @@ _REDSHIFT_SOURCE_ICEBERG_KEYS = {
 _TSQL_TIME_ICEBERG_KEY = "TIME_ICEBERG"
 
 
-# Result-row text for a column omitted from L2 because Iceberg stored it as VARCHAR.
-FLATTENED_VARCHAR_METRICS_CRITERIA = "FLATTENED_TO_VARCHAR"
-FLATTENED_VARCHAR_METRICS_COMMENT = "Left out of metrics because it flattened to VARCHAR."
+# Stored type reported on the result row of a column omitted from L2 because
+# Iceberg stored it as VARCHAR; the reason itself is a MetricsExclusionReason.
 FLATTENED_VARCHAR_STORED_TYPE = "VARCHAR"
 
 _VARCHAR_LIKE_TARGET_BASES = frozenset({"VARCHAR", "TEXT", "STRING"})
@@ -293,8 +316,14 @@ def iceberg_flag_from_show_tables_rows(rows: object, table_name: str | None = No
 
 
 _ICEBERG_FLAG_BY_TOKEN = {
-    "y": True, "yes": True, "true": True, "1": True,
-    "n": False, "no": False, "false": False, "0": False,
+    "y": True,
+    "yes": True,
+    "true": True,
+    "1": True,
+    "n": False,
+    "no": False,
+    "false": False,
+    "0": False,
 }
 
 
@@ -449,11 +478,12 @@ def resolve_iceberg_v2_compatible_normalization_key(
 
     key = data_type.strip().upper() if data_type else data_type
     paired_source_base = _base_type(paired_source_type)
-    platform_value = getattr(paired_source_platform, "value", paired_source_platform)
-    is_redshift_source = str(platform_value).strip().lower() == "redshift"
-    # FULL_INGEST keeps Redshift zoned clocks on the UNLOAD VARCHAR too, so the text
-    # compare applies on every load mode.
-    if key == _VARCHAR_ISO_TZ and is_redshift_source and paired_source_base in _FLATTENED_REDSHIFT_SOURCE_BASES:
+    platform_value = str(getattr(paired_source_platform, "value", paired_source_platform)).strip().lower()
+    # The source template already renders the staged text exactly, so compare the
+    # stored VARCHAR as is. FULL_INGEST keeps Redshift zoned clocks on the UNLOAD
+    # VARCHAR too, so the text compare applies on every load mode.
+    raw_text_bases = _RAW_ISO_TZ_TEXT_SOURCE_BASES.get(platform_value, frozenset())
+    if key == _VARCHAR_ISO_TZ and (paired_source_base in raw_text_bases or _zoned_type_label(paired_source_type) in raw_text_bases):
         return CommonType.VARCHAR
 
     base = _base_type(key)

{snowflake_data_validation-1.46.0 → snowflake_data_validation-1.46.2}/src/snowflake/snowflake_data_validation/utils/iso_dv_common.py

@@ -41,6 +41,10 @@ from snowflake.snowflake_data_validation.utils.interval_common import (
     SNOWFLAKE_INTERVAL_DV_FAMILIES,
     normalize_interval_datatype_key,
 )
+from snowflake.snowflake_data_validation.utils.metrics_exclusion import (
+    MetricsExclusion,
+    MetricsExclusionReason,
+)
 from snowflake.snowflake_data_validation.utils.period_common import (
     is_period_snowflake_type,
     normalize_period_datatype_key,
@@ -115,6 +119,14 @@ _SQLSERVER_CLOCK_METRICS: dict[_IsoClockTextKey, str] = {
     _IsoClockTextKey.TIME: VARCHAR_TIME_METRICS_TYPE,
 }
 
+# SQL Server keeps all 7 fractional digits of DATETIMEOFFSET and renders its
+# MIN / MAX in UTC, so the text parses through the per-row-offset template.
+# Azure Synapse truncates the source side to 6 digits and stays without it.
+_SQLSERVER_ONLY_CLOCK_METRICS: dict[_IsoClockTextKey, str] = {
+    **_SQLSERVER_CLOCK_METRICS,
+    _IsoClockTextKey.TIMESTAMP_TZ: VARCHAR_TIMESTAMP_TZ_SIGNED_METRICS_TYPE,
+}
+
 # PostgreSQL TIMESTAMP stays absent: its extract is not this ISO text.
 _ISO_CLOCK_TEXT_METRICS: dict[Platform, dict[_IsoClockTextKey, str]] = {
     Platform.TERADATA: {
@@ -132,10 +144,25 @@ _ISO_CLOCK_TEXT_METRICS: dict[Platform, dict[_IsoClockTextKey, str]] = {
     Platform.ORACLE: {
         _IsoClockTextKey.TIMESTAMP: VARCHAR_TIMESTAMP_METRICS_TYPE,
     },
-    Platform.SQLSERVER: _SQLSERVER_CLOCK_METRICS,
+    Platform.SQLSERVER: _SQLSERVER_ONLY_CLOCK_METRICS,
     Platform.AZURE_SYNAPSE: _SQLSERVER_CLOCK_METRICS,
 }
 
+# Clock text whose Snowflake parser cannot read every source value, so L2 leaves
+# the Iceberg VARCHAR column out and names the gap. L3 still compares the text.
+# Checked against each _ISO_CLOCK_TEXT_METRICS platform: Redshift signed-year text
+# and SQL Server / Synapse text all parse back, and Oracle has no Iceberg load yet.
+_CAST_NOT_TOTAL: dict[Platform, dict[_IsoClockTextKey, str]] = {
+    Platform.TERADATA: dict.fromkeys(
+        (_IsoClockTextKey.TIME, _IsoClockTextKey.TIME_TZ, _IsoClockTextKey.TIMESTAMP, _IsoClockTextKey.TIMESTAMP_TZ),
+        "Teradata allows seconds 60-61, which Snowflake TIME and TIMESTAMP reject.",
+    ),
+    Platform.POSTGRESQL: dict.fromkeys(
+        (_IsoClockTextKey.DATE, _IsoClockTextKey.TIMESTAMP),
+        "PostgreSQL 'infinity' and '-infinity' have no Snowflake DATE or TIMESTAMP value.",
+    ),
+}
+
 _MAPPED_VARCHAR_LENGTH_RE = re.compile(
     r"^\s*VARCHAR\s*\(\s*(\d+)\s*\)\s*$",
     re.IGNORECASE,
@@ -230,7 +257,7 @@ def _iso_clock_text_key(source_data_type: str) -> _IsoClockTextKey | None:
         return _IsoClockTextKey.TIME_TZ
     if leading == _IsoClockTextKey.TIME:
         return _IsoClockTextKey.TIME
-    if leading == _SHORT_TIMESTAMPTZ or (leading == _IsoClockTextKey.TIMESTAMP and has_time_zone):
+    if leading in (_SHORT_TIMESTAMPTZ, _SHORT_DATETIMEOFFSET) or (leading == _IsoClockTextKey.TIMESTAMP and has_time_zone):
         return _IsoClockTextKey.TIMESTAMP_TZ
     if leading == _IsoClockTextKey.TIMESTAMP:
         return _IsoClockTextKey.TIMESTAMP
@@ -267,35 +294,45 @@ def resolve_snowflake_varchar_temporal_metrics_type(
     return platform_metrics.get(clock_key)
 
 
-def column_omitted_from_iceberg_metrics(
+def iceberg_metrics_exclusion(
+    column: str,
     source_data_type: str | None,
     target_data_type: str | None,
     *,
     paired_source_platform: Platform | None,
     is_iceberg: bool,
-) -> bool:
-    """Return True when Iceberg leaves this column out of L2.
-
-    A clock whose extract writes the paired template text stays in the SELECT.
-    The Snowflake generator then uses that platform's ``VARCHAR_*`` clock
-    template (for example ``VARCHAR_TIME`` or ``VARCHAR_DATE_SIGNED``). Every
-    other flatten stays out.
+) -> MetricsExclusion | None:
+    """Return why Iceberg leaves this column out of L2, or None to measure it.
+
+    A clock whose extract writes the paired template text stays in the SELECT
+    when its parser reads every source value. The Snowflake generator then uses
+    that platform's ``VARCHAR_*`` clock template (for example ``VARCHAR_TIME``
+    or ``VARCHAR_DATE_SIGNED``). A clock whose parser misses some values leaves
+    with ``CAST_NOT_TOTAL``. Every other flatten leaves with
+    ``NO_COMPARABLE_METRIC``.
     """
+    if source_data_type is None or target_data_type is None:
+        return None
+    if not column_excluded_from_iceberg_metrics(source_data_type, target_data_type, is_iceberg=is_iceberg):
+        return None
+    clock_key = _iso_clock_text_key(source_data_type)
+    if clock_key is not None and paired_source_platform is not None:
+        gap = _CAST_NOT_TOTAL.get(paired_source_platform, {}).get(clock_key)
+        if gap is not None:
+            return MetricsExclusion(column=column, reason=MetricsExclusionReason.CAST_NOT_TOTAL, detail=gap)
     if (
-        isinstance(source_data_type, str)
-        and isinstance(target_data_type, str)
-        and resolve_snowflake_varchar_temporal_metrics_type(
+        resolve_snowflake_varchar_temporal_metrics_type(
             target_data_type,
             source_data_type,
             paired_source_platform=paired_source_platform,
         )
         is not None
     ):
-        return False
-    return column_excluded_from_iceberg_metrics(
-        source_data_type,
-        target_data_type,
-        is_iceberg=is_iceberg,
+        return None
+    return MetricsExclusion(
+        column=column,
+        reason=MetricsExclusionReason.NO_COMPARABLE_METRIC,
+        detail=f"{source_data_type} is stored as {target_data_type}, and no metric reads that text as {source_data_type}.",
     )
 
 

snowflake_data_validation-1.46.2/src/snowflake/snowflake_data_validation/utils/metrics_exclusion.py

@@ -0,0 +1,68 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Why an Iceberg column was left out of L2 metrics.
+
+An Iceberg target can store a source value as lossless canonical VARCHAR. L2
+measures that column through a parser only when the parser reads every value
+the source type can hold. Otherwise the column leaves the metrics SELECT, and
+its result row names the reason instead of a generic warning (SNOW-4353895).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TypedDict
+
+
+class MetricsExclusionReason(StrEnum):
+    """``EVALUATION_CRITERIA`` of the result row for a column left out of L2."""
+
+    CAST_NOT_TOTAL = "CAST_NOT_TOTAL"
+    """The stored text has a parser, but it cannot read every source value."""
+
+    NO_COMPARABLE_METRIC = "NO_COMPARABLE_METRIC"
+    """No metric reads the stored text as the source type."""
+
+    FLATTENED_TO_VARCHAR = "FLATTENED_TO_VARCHAR"
+    """A payload from a release that did not record the reason."""
+
+
+_LEGACY_DETAIL = "Left out of metrics because it flattened to VARCHAR."
+
+
+class MetricsExclusionDict(TypedDict):
+    """JSON-serializable form of :class:`MetricsExclusion`."""
+
+    column: str
+    reason: str
+    detail: str
+
+
+@dataclass(frozen=True)
+class MetricsExclusion:
+    """One column left out of the metrics SELECT, with the reason."""
+
+    column: str
+    reason: MetricsExclusionReason
+    detail: str
+
+    @classmethod
+    def legacy(cls, column: str) -> MetricsExclusion:
+        """Return the exclusion a payload without reasons implies."""
+        return cls(column=column, reason=MetricsExclusionReason.FLATTENED_TO_VARCHAR, detail=_LEGACY_DETAIL)
+
+    def to_dict(self) -> MetricsExclusionDict:
+        """Return a JSON-serializable representation."""
+        return MetricsExclusionDict(column=self.column, reason=self.reason.value, detail=self.detail)
+
+    @classmethod
+    def from_dict(cls, data: MetricsExclusionDict) -> MetricsExclusion:
+        """Reconstruct an exclusion from its JSON-serializable form."""
+        return cls(
+            column=str(data["column"]),
+            reason=MetricsExclusionReason(data["reason"]),
+            detail=str(data["detail"]),
+        )

{snowflake_data_validation-1.46.0 → snowflake_data_validation-1.46.2}/tests/unit/test_catalog_queries_take_actual_names.py

@@ -99,6 +99,8 @@ def test_snowflake_information_schema_prefix_keeps_a_mixed_case_database() -> No
         (Platform.POSTGRESQL, "Public", "public"),
         (Platform.POSTGRESQL, '"MixedCase"', "MixedCase"),
         (Platform.SNOWFLAKE, "orders", "ORDERS"),
+        # SNOW-4328091 (G6): a Snowflake source a Hop launcher wrote, named with the CUR's lowercase schema.
+        (Platform.SNOWFLAKE, "dbo", "DBO"),
         (Platform.SQLSERVER, "[Order Details]", "Order Details"),
         (Platform.TERADATA, "Sales", "Sales"),
         (Platform.RESULT_SET, '"Kept"', "Kept"),