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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-data-validation
-Version: 1.45.3
+Version: 1.45.4
 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/
@@ -230,6 +230,17 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.45.4
+
+**Improvements**
+
+- Improved Iceberg validation to read the table format version from the Snowflake catalog once before validation starts, so every validation level uses the actual format version.
+
+**Bug fixes**
+
+- Fixed Redshift Iceberg metrics validation comparing signed-year `DATE` and `TIMESTAMPTZ` values.
+- Fixed Teradata `UNICODE` `CHAR`, `VARCHAR`, and `CLOB` column lengths being reported in bytes, which raised false truncation warnings.
+
 ### v1.45.3
 
 **Bug fixes**

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

@@ -139,6 +139,17 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.45.4
+
+**Improvements**
+
+- Improved Iceberg validation to read the table format version from the Snowflake catalog once before validation starts, so every validation level uses the actual format version.
+
+**Bug fixes**
+
+- Fixed Redshift Iceberg metrics validation comparing signed-year `DATE` and `TIMESTAMPTZ` values.
+- Fixed Teradata `UNICODE` `CHAR`, `VARCHAR`, and `CLOB` column lengths being reported in bytes, which raised false truncation warnings.
+
 ### v1.45.3
 
 **Bug fixes**

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

@@ -5,7 +5,7 @@ requires = ["hatchling"]
 [tool.uv]
 constraint-dependencies = [
   "certifi>=2026.10.23,<2026.11",
-  "virtualenv>=21.7.13,<21.8",
+  "virtualenv>=21.14.9,<21.15",
 ]
 
 [project]

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/bigquery/query/query_generator_bigquery.py

@@ -157,7 +157,7 @@ class QueryGeneratorBigQuery(QueryGeneratorBase):
                 normalized = normalized[:index]
         return normalized.strip()
 
-    def _resolve_metrics_col_type(self, col, table_context: TableContext) -> str:
+    def _resolve_metrics_col_type(self, col: ColumnMetadata, table_context: TableContext) -> str:
         """Key the metrics YAML lookup off the parameterless base type."""
         return self.normalize_bigquery_type(col.data_type)
 

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

@@ -394,8 +394,7 @@ class QueryGeneratorBase(ABC):
         override this. Combined generators leave the base raise in place.
         """
         raise NotImplementedError(
-            f"{self.platform.value} uses a combined schema query; "
-            "call generate_schema_query instead of generate_schema_row_count_query"
+            f"{self.platform.value} uses a combined schema query; call generate_schema_query instead of generate_schema_row_count_query"
         )
 
     def generate_schema_details_query(self, table_context: TableContext) -> str:
@@ -405,8 +404,7 @@ class QueryGeneratorBase(ABC):
         override this. Combined generators leave the base raise in place.
         """
         raise NotImplementedError(
-            f"{self.platform.value} uses a combined schema query; "
-            "call generate_schema_query instead of generate_schema_details_query"
+            f"{self.platform.value} uses a combined schema query; call generate_schema_query instead of generate_schema_details_query"
         )
 
     def normalize_schema_details_result(
@@ -420,10 +418,7 @@ class QueryGeneratorBase(ABC):
         as a combined schema query (without ``ROW_COUNT``; the fetch helper
         attaches that). Combined generators leave the base raise in place.
         """
-        raise NotImplementedError(
-            f"{self.platform.value} uses a combined schema query; "
-            "normalize_schema_details_result is not used"
-        )
+        raise NotImplementedError(f"{self.platform.value} uses a combined schema query; normalize_schema_details_result is not used")
 
     def generate_metrics_query(self, table_context: TableContext) -> GeneratedMetricsQuery:
         """Generate a single wide metrics SELECT for a table.
@@ -645,7 +640,7 @@ class QueryGeneratorBase(ABC):
                 return numeric_norm
         return None
 
-    def _resolve_metrics_col_type(self, col, table_context: TableContext) -> str:
+    def _resolve_metrics_col_type(self, col: ColumnMetadata, table_context: TableContext) -> str:
         """Return the metrics YAML type key for a column (platforms may override)."""
         from snowflake.snowflake_data_validation.utils.vector_common import is_vector_base_type
 
@@ -956,9 +951,7 @@ class QueryGeneratorBase(ABC):
                             mask = self._build_numeric_format_mask(self._resolve_numeric_scale(col))
                             normalization = normalization.replace(NUMERIC_FORMAT_MASK_PLACEHOLDER, mask)
                         if ICEBERG_FRACTION_DIGITS_PLACEHOLDER in normalization:
-                            normalization = normalization.replace(
-                                ICEBERG_FRACTION_DIGITS_PLACEHOLDER, str(iceberg_fraction_digits)
-                            )
+                            normalization = normalization.replace(ICEBERG_FRACTION_DIGITS_PLACEHOLDER, str(iceberg_fraction_digits))
                         metric_expr = self._wrap_metric_with_normalization(normalization, metric_expr)
                 alias = f"c{measured_idx}_m{metric_idx}"
                 select_exprs.append(f"{metric_expr} AS {alias}")

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/redshift/extractor/templates/redshift_column_metrics_templates.yaml

@@ -635,6 +635,36 @@ TIMESTAMP_AS_TEXT:
     metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
     metric_return_datatype: BIGINT
 
+# Iceberg VARCHAR DATE (SNOW-4381535): MIN/MAX rendered as the UNLOAD footer's
+# signed astronomical-year text. Kept in sync with DMO by test_redshift_consistency.py.
+DATE_AS_TEXT:
+  min:
+    metric_query: MIN("{{ col_name }}")
+    metric_return_datatype: VARCHAR
+    metric_normalization: '(CASE WHEN (CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END) < 0 THEN ''-'' ELSE '''' END || (CASE WHEN ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END)) < 1000 THEN LPAD(ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END))::VARCHAR, 4, ''0'') ELSE ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END))::VARCHAR END)) || ''-'' || LPAD(EXTRACT(MONTH FROM {{ metric_query }})::VARCHAR, 2, ''0'') || ''-'' || LPAD(EXTRACT(DAY FROM {{ metric_query }})::VARCHAR, 2, ''0'')'
+  max:
+    metric_query: MAX("{{ col_name }}")
+    metric_return_datatype: VARCHAR
+    metric_normalization: '(CASE WHEN (CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END) < 0 THEN ''-'' ELSE '''' END || (CASE WHEN ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END)) < 1000 THEN LPAD(ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END))::VARCHAR, 4, ''0'') ELSE ABS((CASE WHEN EXTRACT(YEAR FROM {{ metric_query }})::INT < 0 THEN EXTRACT(YEAR FROM {{ metric_query }})::INT + 1 ELSE EXTRACT(YEAR FROM {{ metric_query }})::INT END))::VARCHAR END)) || ''-'' || LPAD(EXTRACT(MONTH FROM {{ metric_query }})::VARCHAR, 2, ''0'') || ''-'' || LPAD(EXTRACT(DAY FROM {{ metric_query }})::VARCHAR, 2, ''0'')'
+  count_null:
+    metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
+    metric_return_datatype: BIGINT
+
+# Iceberg VARCHAR TIMESTAMPTZ (SNOW-4381535): MIN/MAX of the instant, rendered in
+# UTC with the UNLOAD footer's signed year. Kept in sync with DMO by test_redshift_consistency.py.
+TIMESTAMPTZ_AS_TEXT:
+  min:
+    metric_query: MIN("{{ col_name }}")
+    metric_return_datatype: VARCHAR
+    metric_normalization: '(CASE WHEN (CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END) < 0 THEN ''-'' ELSE '''' END || (CASE WHEN ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END)) < 1000 THEN LPAD(ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END))::VARCHAR, 4, ''0'') ELSE ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END))::VARCHAR END)) || TO_CHAR(({{ metric_query }} AT TIME ZONE ''UTC''), ''-MM-DD"T"HH24:MI:SS.US'') || ''000'' || ''+00:00'''
+  max:
+    metric_query: MAX("{{ col_name }}")
+    metric_return_datatype: VARCHAR
+    metric_normalization: '(CASE WHEN (CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END) < 0 THEN ''-'' ELSE '''' END || (CASE WHEN ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END)) < 1000 THEN LPAD(ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END))::VARCHAR, 4, ''0'') ELSE ABS((CASE WHEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT < 0 THEN EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT + 1 ELSE EXTRACT(YEAR FROM ({{ metric_query }} AT TIME ZONE ''UTC''))::INT END))::VARCHAR END)) || TO_CHAR(({{ metric_query }} AT TIME ZONE ''UTC''), ''-MM-DD"T"HH24:MI:SS.US'') || ''000'' || ''+00:00'''
+  count_null:
+    metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
+    metric_return_datatype: BIGINT
+
 TIMESTAMPTZ:
   min: 
     metric_query: MIN("{{ col_name }}")

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/redshift/query/query_generator_redshift.py

@@ -62,7 +62,9 @@ from snowflake.snowflake_data_validation.utils.constants import (
     SchemaValidationFields,
 )
 from snowflake.snowflake_data_validation.utils.iceberg_dv_common import (
+    DATE_AS_TEXT_KEY,
     TIMESTAMP_AS_TEXT_KEY,
+    TIMESTAMPTZ_AS_TEXT_KEY,
     IcebergProfile,
     resolve_iceberg_v2_compatible_source_normalization_key,
 )
@@ -80,12 +82,21 @@ from snowflake.snowflake_data_validation.utils.measure_collation import (
     base_type,
     has_effective_collation,
 )
+from snowflake.snowflake_data_validation.utils.model.column_metadata import ColumnMetadata
 from snowflake.snowflake_data_validation.utils.model.table_context import TableContext
 
 
 LOGGER = logging.getLogger(__name__)
 _REDSHIFT_NORMALIZED_COLLATION_TOKENS = ("COLLATE(", ", 'case_sensitive')")
-_TIMESTAMP_BASE_TYPES = frozenset({CommonType.TIMESTAMP, CommonType.TIMESTAMP_WITHOUT_TIME_ZONE})
+# Source clocks the Iceberg UNLOAD stages as signed-year text, keyed to the
+# metrics template that renders MIN / MAX the same way.
+_SIGNED_YEAR_TEXT_METRICS_KEYS: dict[str, str] = {
+    CommonType.DATE: DATE_AS_TEXT_KEY,
+    CommonType.TIMESTAMP: TIMESTAMP_AS_TEXT_KEY,
+    CommonType.TIMESTAMP_WITHOUT_TIME_ZONE: TIMESTAMP_AS_TEXT_KEY,
+    CommonType.TIMESTAMPTZ: TIMESTAMPTZ_AS_TEXT_KEY,
+    CommonType.TIMESTAMP_WITH_TIME_ZONE: TIMESTAMPTZ_AS_TEXT_KEY,
+}
 
 # Redshift ``TO_CHAR`` formats numbers with 64-bit arithmetic. A numeric format
 # mask with N total digit placeholders (integer nines + fractional zeros) admits
@@ -525,19 +536,12 @@ class QueryGeneratorRedshift(QueryGeneratorBase):
         ``schema.table`` only (same rule as :func:`quoted_non_empty_fqn`).
         """
         if not table_context.schema_name or not table_context.internal_table_name:
-            raise ValueError(
-                "Redshift schema-details query requires schema and table names for "
-                f"{table_context.fully_qualified_name}"
-            )
+            raise ValueError(f"Redshift schema-details query requires schema and table names for {table_context.fully_qualified_name}")
         platform = self.platform.value
-        template = self.jinja_env.get_template(
-            SHOW_COLUMNS_QUERY_TEMPLATE_NAME_FORMAT.format(platform=platform)
-        )
+        template = self.jinja_env.get_template(SHOW_COLUMNS_QUERY_TEMPLATE_NAME_FORMAT.format(platform=platform))
         database_name = table_context.database_name or ""
         return template.render(
-            object_database_sql=(
-                write_sql_name(database_name, platform) if database_name.strip() else ""
-            ),
+            object_database_sql=(write_sql_name(database_name, platform) if database_name.strip() else ""),
             object_schema_sql=write_sql_name(table_context.schema_name, platform),
             object_name_sql=write_sql_name(table_context.internal_table_name, platform),
         )
@@ -582,9 +586,7 @@ class QueryGeneratorRedshift(QueryGeneratorBase):
     @staticmethod
     def _lowered_data_types(data_types: pd.Series) -> pd.Series:
         """Lower-case data-type spellings for the fixup masks, with missing values as ``""``."""
-        return data_types.map(
-            lambda value: str(value).lower() if value is not None and not pd.isna(value) else ""
-        )
+        return data_types.map(lambda value: str(value).lower() if value is not None and not pd.isna(value) else "")
 
     def _apply_length_overrides(self, frame: pd.DataFrame, lowered_data_types: pd.Series) -> None:
         """Null the length of spatial and binary types, and set the HLLSKETCH length."""
@@ -592,25 +594,19 @@ class QueryGeneratorRedshift(QueryGeneratorBase):
         if length_column not in frame.columns:
             return
         frame.loc[lowered_data_types.isin(self._NULL_LENGTH_DATA_TYPES), length_column] = None
-        frame.loc[lowered_data_types == RedshiftType.HLLSKETCH.lower(), length_column] = (
-            REDSHIFT_HLLSKETCH_CHARACTER_MAXIMUM_LENGTH
-        )
+        frame.loc[lowered_data_types == RedshiftType.HLLSKETCH.lower(), length_column] = REDSHIFT_HLLSKETCH_CHARACTER_MAXIMUM_LENGTH
 
     def _apply_float_precision(self, frame: pd.DataFrame, lowered_data_types: pd.Series) -> None:
         """Give float types the precision L1 compares, which ``SHOW COLUMNS`` does not report."""
         precision_column = SchemaValidationFields.NUMERIC_PRECISION.value
         if precision_column not in frame.columns:
             return
-        frame.loc[lowered_data_types.isin(self._FLOAT_PRECISION_DATA_TYPES), precision_column] = (
-            REDSHIFT_FLOAT_NUMERIC_PRECISION
-        )
+        frame.loc[lowered_data_types.isin(self._FLOAT_PRECISION_DATA_TYPES), precision_column] = REDSHIFT_FLOAT_NUMERIC_PRECISION
 
     @staticmethod
     def _uppercased_data_types(data_types: pd.Series) -> pd.Series:
         """Upper-case data-type spellings, leaving missing values untouched."""
-        return data_types.map(
-            lambda value: str(value).upper() if value is not None and not pd.isna(value) else value
-        )
+        return data_types.map(lambda value: str(value).upper() if value is not None and not pd.isna(value) else value)
 
     @staticmethod
     def _stamp_object_type(frame: pd.DataFrame, table_context: TableContext) -> None:
@@ -755,20 +751,22 @@ class QueryGeneratorRedshift(QueryGeneratorBase):
             raise ValueError(f"No normalization template found for data type {data_type} and no DEFAULT template available.")
         return normalization_template
 
-    def _resolve_metrics_col_type(self, col, table_context: TableContext) -> str:
-        """Key an Iceberg VARCHAR TIMESTAMP to the signed-year metrics (SNOW-4353618).
+    def _resolve_metrics_col_type(self, col: ColumnMetadata, table_context: TableContext) -> str:
+        """Key an Iceberg VARCHAR DATE / TIMESTAMP / TIMESTAMPTZ to the signed-year metrics.
 
         ``TO_CHAR 'YYYY'`` drops the era, so MIN / MAX would not match the text
-        the UNLOAD staged. Native targets keep the shared TIMESTAMP template.
+        the UNLOAD staged (SNOW-4353618, SNOW-4381535). Native targets keep the
+        shared templates.
         """
         col_type = super()._resolve_metrics_col_type(col, table_context)
         if not IcebergProfile.from_table_context(table_context).is_active:
             return col_type
-        if col_type.upper() not in _TIMESTAMP_BASE_TYPES:
+        signed_year_key = _SIGNED_YEAR_TEXT_METRICS_KEYS.get(col_type.upper())
+        if signed_year_key is None:
             return col_type
         if not is_snowflake_varchar_like_type(get_paired_target_column_types(table_context).get(col.name)):
             return col_type
-        return TIMESTAMP_AS_TEXT_KEY
+        return signed_year_key
 
     def _resolve_normalization_templates(
         self,

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

@@ -265,6 +265,36 @@ VARCHAR_TIMESTAMP_SIGNED:
     metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
     metric_return_datatype: NUMBER
 
+# Signed-year ISO DATE text (Redshift Iceberg, SNOW-4381535): TRY_TO_DATE alone is
+# NULL for negative and 5+ digit years, so parse like the column comment's cast back.
+VARCHAR_DATE_SIGNED:
+  min:
+    metric_query: 'MIN(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))'
+    metric_return_datatype: VARCHAR
+    metric_normalization: TO_CHAR({{ metric_query }}, 'YYYY-MM-DD')
+  max:
+    metric_query: 'MAX(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))'
+    metric_return_datatype: VARCHAR
+    metric_normalization: TO_CHAR({{ metric_query }}, 'YYYY-MM-DD')
+  count_null:
+    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.
+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')
+  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')
+  count_null:
+    metric_query: SUM(CASE WHEN "{{ col_name }}" IS NULL THEN 1 ELSE 0 END)
+    metric_return_datatype: NUMBER
+
 # Order by UTC time-of-day. A plain MIN of the parsed instant uses today's date
 # and can cross midnight, so the formatted value would keep the wrong offset.
 VARCHAR_TIME_TZ:

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/snowflake/extractor/templates/snowflake_datatypes_normalization_templates.yaml

@@ -13,7 +13,7 @@ TIME: LEFT(TO_CHAR("{{ col_name }}", 'HH24:MI:SS.FF9'), {{ time_text_length }})
 TIME WITH TIME ZONE: LEFT(TO_CHAR("{{ col_name }}", 'HH24:MI:SS.FF9'), {{ time_text_length }})
 # Typed Snowflake timestamps. The fractional-second digits are the Iceberg Parquet
 # format version (v2 micro FF6 / v3 nano FF9), substituted at render from
-# resolve_iceberg_fraction_digits; non-Iceberg paths default to FF9.
+# resolve_iceberg_fraction_digits from iceberg_spec; a spec other than v2 stays FF9.
 TIMESTAMP_LTZ: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD"T"HH24:MI:SS.FF{{ fraction_digits }}')
 # Paired Oracle TIMESTAMP WITH LOCAL TIME ZONE: compare the retained instant in UTC.
 TIMESTAMP_LTZ_UTC: TO_CHAR(CONVERT_TIMEZONE('UTC', "{{ col_name }}"), 'YYYY-MM-DD"T"HH24:MI:SS.FF{{ fraction_digits }}')

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

@@ -521,7 +521,7 @@ class QueryGeneratorSnowflake(QueryGeneratorBase):
             write_identifier=self._write_sql_identifier,
         )
 
-    def _resolve_metrics_col_type(self, col, table_context: TableContext) -> str:
+    def _resolve_metrics_col_type(self, col: ColumnMetadata, table_context: TableContext) -> str:
         paired = get_paired_source_column_types(table_context)
         paired_source = paired.get(col.name)
         target_base = normalize_snowflake_base_type(col.data_type)
@@ -532,12 +532,8 @@ class QueryGeneratorSnowflake(QueryGeneratorBase):
                 CommonType.STRING,
             }:
                 return CommonType.CHAR
-        iso_tz_type = resolve_snowflake_iso_tz_varchar_metrics_type(
-            col.data_type,
-            paired_source,
-        )
-        if iso_tz_type:
-            return iso_tz_type
+        # The platform's own clock text wins over the generic ISO TZ parser:
+        # Redshift TIMESTAMPTZ text carries a signed year TRY_TO_TIMESTAMP_TZ rejects.
         temporal_text_type = resolve_snowflake_varchar_temporal_metrics_type(
             col.data_type,
             paired_source,
@@ -545,6 +541,12 @@ class QueryGeneratorSnowflake(QueryGeneratorBase):
         )
         if temporal_text_type:
             return temporal_text_type
+        iso_tz_type = resolve_snowflake_iso_tz_varchar_metrics_type(
+            col.data_type,
+            paired_source,
+        )
+        if iso_tz_type:
+            return iso_tz_type
         if target_base in {CommonType.TEXT, CommonType.STRING}:
             return CommonType.VARCHAR
         return target_base or col.data_type

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

@@ -60,6 +60,11 @@ WITH rc_cte AS (
             -- MONTH). Returning ColumnLength here would fail L1 against the N/A
             -- target. The DAY/HOUR/MINUTE/SECOND/YEAR/MONTH codes therefore fall
             -- through to NULL below.
+            -- ColumnLength is a byte width. UNICODE (CharType 2) stores two bytes
+            -- per character, so CHAR, VARCHAR and CLOB report ColumnLength / 2.
+            -- LATIN is one byte per character and already matches. PERIOD widths
+            -- are the text form, not a character-set width, and stay as ColumnLength.
+            WHEN TRIM(C.ColumnType) IN ('CF', 'CV', 'CO') AND C.CharType = 2 THEN C.ColumnLength / 2
             WHEN TRIM(C.ColumnType) IN ('CF', 'CV', 'CO', 'PD', 'PM', 'PS', 'PT', 'PZ') THEN C.ColumnLength
             ELSE NULL
         END AS CHARACTER_MAXIMUM_LENGTH,

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/teradata/query/query_generator_teradata.py

@@ -50,6 +50,7 @@ from snowflake.snowflake_data_validation.utils.iso_dv_common import get_paired_t
 from snowflake.snowflake_data_validation.utils.measure_collation import (
     SOURCE_CHARACTER_TYPES,
 )
+from snowflake.snowflake_data_validation.utils.model.column_metadata import ColumnMetadata
 from snowflake.snowflake_data_validation.utils.model.table_context import TableContext
 from snowflake.snowflake_data_validation.utils.teradata_string_rtrim import (
     teradata_rtrim_string_type,
@@ -380,7 +381,7 @@ class QueryGeneratorTeradata(QueryGeneratorBase):
             return normalization
         return None
 
-    def _resolve_metrics_col_type(self, col, table_context: TableContext) -> str:
+    def _resolve_metrics_col_type(self, col: ColumnMetadata, table_context: TableContext) -> str:
         paired = get_paired_target_column_types(table_context)
         if is_teradata_timetz_timestamp_tz_pair(col.data_type, paired.get(col.name)):
             return CommonType.TIMESTAMP_WITH_TIME_ZONE

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

@@ -265,8 +265,7 @@ SNAPSHOT_METADATA_PARQUET_SCHEMAS_KEY = "parquetSchemas"
 ICEBERG_SPEC_KEY = "iceberg_spec"
 STORAGE_MODE_KEY = "storage_mode"
 LOAD_MODE_KEY = "load_mode"
-ICEBERG_FORMAT_VERSION_KEY = "iceberg_format_version"
-# Iceberg table format versions a Snowflake catalog reports (its ICEBERG_VERSION parameter)
+# Catalog format versions ``iceberg_spec`` names. v2 renders FF6; v3 renders FF9.
 ICEBERG_FORMAT_VERSION_V2 = 2
 ICEBERG_FORMAT_VERSION_V3 = 3
 

{snowflake_data_validation-1.45.3 → snowflake_data_validation-1.45.4}/src/snowflake/snowflake_data_validation/utils/iceberg_dv_common.py

@@ -7,9 +7,10 @@ Iceberg L3 normalization key overlays.
 Source/target SQL bridge overlays for Snowflake Iceberg tables under
 ``storageMode=compatible`` (v2/v3) and ``storageMode=native`` (v3 only):
 
-- v2 and v3: typed Snowflake timestamps stay on the default ``FF9`` templates.
-  Every source renders nine fractional digits (zero-padded), so an ``FF6``
-  target would never match; a value Iceberg truncated still mismatches.
+- Typed Snowflake timestamps take their fraction from ``iceberg_spec``.
+  Validation fills that spec from the target table's ``ICEBERG_VERSION``
+  (``SHOW PARAMETERS``): ``v2`` renders microseconds (FF6), ``v3`` and any
+  other spec render nanoseconds (FF9).
 - Redshift ``TIMESTAMP`` / ``TIMESTAMPTZ`` land as ``VARCHAR`` on both specs and
   compare as the stored UNLOAD text.
 - Redshift flattened values → the same text emitted by migration UNLOAD.
@@ -27,6 +28,7 @@ above apply where native also stores ``VARCHAR``.
 
 from __future__ import annotations
 
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import Protocol
 
@@ -34,10 +36,10 @@ from shared.datatypes.common import CommonType
 from shared.datatypes.redshift import RedshiftType
 from shared.datatypes.snowflake import SnowflakeType
 from shared.datatypes.teradata import TeradataType
-from shared.enums.iceberg import IcebergLoadMode
+from shared.enums.iceberg import IcebergLoadMode, IcebergSpec
 from snowflake.snowflake_data_validation.utils.constants import (
-    ICEBERG_FORMAT_VERSION_KEY,
     ICEBERG_FORMAT_VERSION_V2,
+    ICEBERG_FORMAT_VERSION_V3,
     ICEBERG_SPEC_KEY,
     LOAD_MODE_KEY,
     STORAGE_MODE_KEY,
@@ -227,9 +229,90 @@ def _as_str(value: object) -> str | None:
     return value if isinstance(value, str) else None
 
 
-def _as_format_version(value: object) -> int | None:
-    # bool is an int subclass, so True would otherwise read as format version 1.
-    return value if isinstance(value, int) and not isinstance(value, bool) else None
+def _row_value(row: Mapping[object, object], column: str) -> object:
+    """Read one ``SHOW`` result cell by column name, case-insensitively."""
+    target = column.casefold()
+    return next((item for key, item in row.items() if str(key).casefold() == target), None)
+
+
+def _catalog_version(value: object) -> int | None:
+    """Return 2 or 3 from a SHOW PARAMETERS ``value`` cell, or None."""
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int) and value in (ICEBERG_FORMAT_VERSION_V2, ICEBERG_FORMAT_VERSION_V3):
+        return value
+    if isinstance(value, str):
+        token = value.strip()
+        if token in {str(ICEBERG_FORMAT_VERSION_V2), str(ICEBERG_FORMAT_VERSION_V3)}:
+            return int(token)
+    return None
+
+
+def iceberg_spec_from_show_rows(rows: object) -> IcebergSpec | None:
+    """Map a ``SHOW PARAMETERS`` ``ICEBERG_VERSION`` result onto ``iceberg_spec``.
+
+    The ``value`` column name is matched case-insensitively. ``2`` is ``v2``
+    and ``3`` is ``v3``. An empty result or any other value stays unset.
+    """
+    if isinstance(rows, (str, bytes)) or not isinstance(rows, Sequence) or not rows:
+        return None
+    row = rows[0]
+    if not isinstance(row, Mapping):
+        return None
+    version = _catalog_version(_row_value(row, "value"))
+    if version == ICEBERG_FORMAT_VERSION_V2:
+        return IcebergSpec.V2
+    if version == ICEBERG_FORMAT_VERSION_V3:
+        return IcebergSpec.V3
+    return None
+
+
+def iceberg_flag_from_show_tables_rows(rows: object, table_name: str | None = None) -> bool | None:
+    """Read ``SHOW TABLES`` ``is_iceberg`` as True/False, or None when missing.
+
+    When ``table_name`` is provided, the matching ``name`` row is selected so
+    wildcard matches from ``LIKE`` cannot bleed into another table.
+    """
+    if isinstance(rows, (str, bytes)) or not isinstance(rows, Sequence) or not rows:
+        return None
+    if table_name is not None:
+        expected = table_name.casefold()
+        for row in rows:
+            if isinstance(row, Mapping):
+                row_name = _row_value(row, "name")
+                if isinstance(row_name, str) and row_name.casefold() == expected:
+                    return _iceberg_flag_from_show_tables_row(row)
+        # A named table that LIKE did not return exactly stays unknown rather
+        # than inheriting a wildcard sibling's flag.
+        return None
+    first = rows[0]
+    if not isinstance(first, Mapping):
+        return None
+    return _iceberg_flag_from_show_tables_row(first)
+
+
+_ICEBERG_FLAG_BY_TOKEN = {
+    "y": True, "yes": True, "true": True, "1": True,
+    "n": False, "no": False, "false": False, "0": False,
+}
+
+
+def _iceberg_flag_from_show_tables_row(row: Mapping[object, object]) -> bool | None:
+    """Map a ``SHOW TABLES`` ``is_iceberg`` cell (``Y``/``N``, bool, or ``0``/``1``) to a flag."""
+    value = _row_value(row, "is_iceberg")
+    if value is None:
+        return None
+    return _ICEBERG_FLAG_BY_TOKEN.get(str(value).strip().casefold())
+
+
+def format_version_from_spec(iceberg_spec: object) -> int | None:
+    """Map ``iceberg_spec`` to the catalog format version it names."""
+    spec = IcebergSpec.parse(iceberg_spec)
+    if spec is IcebergSpec.V2:
+        return ICEBERG_FORMAT_VERSION_V2
+    if spec is IcebergSpec.V3:
+        return ICEBERG_FORMAT_VERSION_V3
+    return None
 
 
 _MICROSECOND_FRACTION_DIGITS = 6
@@ -239,10 +322,8 @@ _NANOSECOND_FRACTION_DIGITS = 9
 def resolve_iceberg_fraction_digits(is_iceberg: bool, iceberg_format_version: int | None = None) -> int:
     """Return the fractional-second digits a Snowflake timestamp renders under Iceberg.
 
-    The micro/nano choice is the Iceberg Parquet format version read from the
-    catalog: v2 truncates to microseconds (FF6), v3 keeps nanoseconds (FF9). A
-    non-Iceberg target, or an Iceberg target whose format version the catalog
-    did not report, renders the default nanosecond templates.
+    Spec v2 truncates to microseconds (FF6). v3, a missing spec, and a
+    non-Iceberg target render the default nanosecond templates.
     """
     if is_iceberg and iceberg_format_version == ICEBERG_FORMAT_VERSION_V2:
         return _MICROSECOND_FRACTION_DIGITS
@@ -264,17 +345,19 @@ class IcebergProfile:
 
     @classmethod
     def from_table_context(cls, table_context: IcebergTableContext) -> IcebergProfile:
-        """Read the Iceberg flag and load mode from a table context's config.
+        """Read the Iceberg flag and load mode from a table context's spec.
 
-        A value that is not a string (an unset attribute, a test double) reads as unset.
+        ``iceberg_spec`` is the catalog spec (``v2`` or ``v3``). A value that is
+        not a string (an unset attribute, a test double) reads as unset.
         """
+        spec = _as_str(getattr(table_context, ICEBERG_SPEC_KEY, None))
         return cls(
             is_iceberg=is_iceberg_dv_profile(
-                _as_str(getattr(table_context, ICEBERG_SPEC_KEY, None)),
+                spec,
                 _as_str(getattr(table_context, STORAGE_MODE_KEY, None)),
             ),
             load_mode=_as_str(getattr(table_context, LOAD_MODE_KEY, None)),
-            iceberg_format_version=_as_format_version(getattr(table_context, ICEBERG_FORMAT_VERSION_KEY, None)),
+            iceberg_format_version=format_version_from_spec(spec),
         )
 
     @property
@@ -288,7 +371,7 @@ class IcebergProfile:
 
     @property
     def fraction_digits(self) -> int:
-        """Fractional-second digits a Snowflake timestamp renders: FF6 for v2, else FF9."""
+        """Fractional-second digits a Snowflake timestamp renders: FF6 when the spec is v2, else FF9."""
         return resolve_iceberg_fraction_digits(self.is_iceberg, self.iceberg_format_version)