snowflake-data-validation 1.45.1__tar.gz → 1.45.2__tar.gz

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-data-validation
-Version: 1.45.1
+Version: 1.45.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/
@@ -156,7 +156,7 @@ Compares table structure between source and target:
 
 Some differences are reported as `WARNING` and do not fail L1:
 - Snowflake still holds every source value: a different column order, a Snowflake precision or scale that can hold the source's, and a `NOT NULL` source column whose Snowflake column is nullable (a Snowflake virtual column is always nullable).
-- Snowflake may truncate or reject source values, so review it: a source character length longer than Snowflake's.
+- Snowflake may truncate or reject source values, so review it: a source character length longer than Snowflake's, and a source number with no declared precision or scale (Oracle's bare `NUMBER`) on a Snowflake `NUMBER(p,s)`, such as `NUMBER(38,18)`. The warning names the precision and scale Snowflake fixes.
 
 A nullable source column on a `NOT NULL` Snowflake column still fails, since Snowflake can reject the source's NULLs.
 
@@ -226,6 +226,14 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.45.2
+
+**Bug fixes**
+
+- Fixed hybrid row validation reporting false mismatches for SQL Server `DATETIMEOFFSET` columns landed as `VARCHAR` in Iceberg v3 compatible tables.
+- Fixed schema validation failing an Oracle unconstrained `NUMBER` against a Snowflake `NUMBER(38,18)`; it now reports a warning.
+- Fixed Snowflake target connections not resolving from `connections.toml`.
+
 ### v1.45.1
 
 **Improvements**

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/README.md

@@ -65,7 +65,7 @@ Compares table structure between source and target:
 
 Some differences are reported as `WARNING` and do not fail L1:
 - Snowflake still holds every source value: a different column order, a Snowflake precision or scale that can hold the source's, and a `NOT NULL` source column whose Snowflake column is nullable (a Snowflake virtual column is always nullable).
-- Snowflake may truncate or reject source values, so review it: a source character length longer than Snowflake's.
+- Snowflake may truncate or reject source values, so review it: a source character length longer than Snowflake's, and a source number with no declared precision or scale (Oracle's bare `NUMBER`) on a Snowflake `NUMBER(p,s)`, such as `NUMBER(38,18)`. The warning names the precision and scale Snowflake fixes.
 
 A nullable source column on a `NOT NULL` Snowflake column still fails, since Snowflake can reject the source's NULLs.
 
@@ -135,6 +135,14 @@ For configuration options and examples, see the [official documentation](https:/
 
 ## Changelog
 
+### v1.45.2
+
+**Bug fixes**
+
+- Fixed hybrid row validation reporting false mismatches for SQL Server `DATETIMEOFFSET` columns landed as `VARCHAR` in Iceberg v3 compatible tables.
+- Fixed schema validation failing an Oracle unconstrained `NUMBER` against a Snowflake `NUMBER(38,18)`; it now reports a warning.
+- Fixed Snowflake target connections not resolving from `connections.toml`.
+
 ### v1.45.1
 
 **Improvements**

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/bigquery/query/query_generator_bigquery.py

@@ -17,7 +17,9 @@ from __future__ import annotations
 
 import logging
 
-from shared.datatypes.bigquery import BigQueryType, serializes_exactly_through_to_json
+from typing import TYPE_CHECKING
+
+from shared.datatypes.bigquery import BigQueryType, field_wise_json_text, serializes_exactly_through_to_json
 from shared.datatypes.common import CommonType
 from shared.datatypes.snowflake import SnowflakeType
 from snowflake.snowflake_data_validation.query.decimal_text_normalization import (
@@ -51,6 +53,10 @@ from snowflake.snowflake_data_validation.validation.comparison_codec import (
 )
 
 
+if TYPE_CHECKING:  # pragma: no cover - used only for type hints.
+    from snowflake.snowflake_data_validation.utils.model.column_metadata import ColumnMetadata
+
+
 LOGGER = logging.getLogger(__name__)
 
 _WIDE_NUMERIC_BASE_TYPES = frozenset({BigQueryType.BIGNUMERIC, BigQueryType.BIGDECIMAL})
@@ -264,32 +270,63 @@ class QueryGeneratorBigQuery(QueryGeneratorBase):
                 raise ValueError(f"No normalization template found for data type {column.data_type} and no DEFAULT template available.")
         return normalization_template
 
+    def _field_wise_normalization(self, column: ColumnMetadata) -> str | None:
+        """Return the L3 text of an ARRAY / STRUCT mixing INT64 and decimals, else None.
+
+        Data migration writes such a column's JSON text field by field, so this hashes that
+        text, keys ordered by PARSE_JSON as for other nests. The text spells every declared
+        field name, and a name may hold a template placeholder, so it is written with the
+        column already in place and never rendered as a template.
+        """
+        column_ref = f"`{self._normalization_column_name(column)}`"
+        field_wise = field_wise_json_text(column.data_type, column_ref)
+        if field_wise is None:
+            return None
+        return f"NULLIF(TO_JSON_STRING(PARSE_JSON({field_wise})), 'null')"
+
+    def _column_normalization(
+        self,
+        column: ColumnMetadata,
+        table_context: TableContext,
+        column_normalization_map: dict[str, str] | None,
+    ) -> str:
+        """Return the column's rendered L3 normalization.
+
+        A user's normalization, a per-column rule or an override of the column's base type
+        (``STRUCT``, ``ARRAY``), wins over the built-in field-wise text.
+        """
+        field_wise = self._field_wise_normalization(column)
+        if field_wise is not None and not has_custom_column_normalization(
+            column.name,
+            self.normalize_bigquery_type(column.data_type),
+            column_normalization_map,
+            table_context.templates_loader_manager,
+        ):
+            return field_wise
+        normalization_template = self._resolve_datatype_normalization_template(
+            column,
+            table_context.templates_loader_manager.datatypes_normalization_templates,
+            table_context,
+        )
+        normalization_template = resolve_column_normalization_template(
+            column.name,
+            normalization_template,
+            column_normalization_map,
+        )
+        # Resolve ``{{ col_name }}`` and, for numeric types, the scale-aware
+        # ``{{ numeric_format_mask }}`` (BigQuery emits a printf ``%.Nf``).
+        return self._render_normalization_template(normalization_template, column)
+
     def _build_datatypes_normalization_renderer_templates(
         self,
         table_context: TableContext,
         column_codec_map: dict[str, ComparisonCodec] | None = None,
         column_normalization_map: dict[str, str] | None = None,
     ) -> dict[str, str]:
-        datatypes_normalization_templates = table_context.templates_loader_manager.datatypes_normalization_templates
         renderer_columns = self._row_md5_normalization_columns(table_context)
         renderer_templates: dict[str, str] = {}
         for column in renderer_columns:
-            normalization_template = self._resolve_datatype_normalization_template(
-                column,
-                datatypes_normalization_templates,
-                table_context,
-            )
-            normalization_template = resolve_column_normalization_template(
-                column.name,
-                normalization_template,
-                column_normalization_map,
-            )
-            # Resolve ``{{ col_name }}`` and, for numeric types, the scale-aware
-            # ``{{ numeric_format_mask }}`` (BigQuery emits a printf ``%.Nf``).
-            renderer_templates[column.name] = self._render_normalization_template(
-                normalization_template,
-                column,
-            )
+            renderer_templates[column.name] = self._column_normalization(column, table_context, column_normalization_map)
         renderer_templates = apply_text_codec_to_renderer_templates(
             self.platform,
             renderer_templates,

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/snowflake/connector/connector_snowflake.py

@@ -181,7 +181,13 @@ class ConnectorSnowflake(BaseConnector):
             raise ConnectionError(f"Failed to establish Snowflake connection: {e}") from e
 
     def _load_named_connection(self, connection_name: str) -> dict:
-        """Load connection parameters from config.toml or connections.toml file.
+        """Load connection parameters from connections.toml or config.toml.
+
+        Directories are searched in order (``~/.snowflake``, then the working
+        directory). Within one directory a ``connections.toml``, when it exists,
+        replaces ``config.toml``'s connections -- the rule
+        ``snowflake.connector`` and the Snow CLI apply -- so this opens the same
+        definition of a name as ``snow sql`` and the test-runner's resolver.
 
         Args:
             connection_name: Name of the connection in the config file
@@ -193,40 +199,39 @@ class ConnectorSnowflake(BaseConnector):
             typer.BadParameter: If connection not found or file doesn't exist
 
         """
-        # Check standard locations for config.toml (new) and connections.toml (legacy)
-        config_paths = [
-            Path.home() / ".snowflake" / "config.toml",
-            Path.home() / ".snowflake" / "connections.toml",
-            Path.cwd() / "config.toml",
-            Path.cwd() / "connections.toml",
-        ]
-
-        for config_path in config_paths:
-            if config_path.exists():
-                try:
-                    config = toml.load(config_path)
-                    # Check for nested structure (config.toml format): connections.name
-                    if "connections" in config and connection_name in config["connections"]:
-                        LOGGER.debug(
-                            "Loaded connection '%s' from %s (nested)",
-                            connection_name,
-                            config_path,
-                        )
-                        return config["connections"][connection_name]
-                    # Check for flat structure (legacy format): name
-                    elif connection_name in config:
-                        LOGGER.debug(
-                            "Loaded connection '%s' from %s (flat)",
-                            connection_name,
-                            config_path,
-                        )
-                        return config[connection_name]
-                except Exception as e:
-                    LOGGER.warning("Failed to load config from %s: %s", config_path, e)
+        config_dirs = [Path.home() / ".snowflake", Path.cwd()]
+        searched: list[Path] = []
+
+        for config_dir in config_dirs:
+            connections_path = config_dir / "connections.toml"
+            config_path = connections_path if connections_path.exists() else config_dir / "config.toml"
+            searched.append(config_path)
+            if not config_path.exists():
+                continue
+            try:
+                config = toml.load(config_path)
+                # Check for nested structure (config.toml format): connections.name
+                if "connections" in config and connection_name in config["connections"]:
+                    LOGGER.debug(
+                        "Loaded connection '%s' from %s (nested)",
+                        connection_name,
+                        config_path,
+                    )
+                    return config["connections"][connection_name]
+                # Check for flat structure (connections.toml format): name
+                elif connection_name in config:
+                    LOGGER.debug(
+                        "Loaded connection '%s' from %s (flat)",
+                        connection_name,
+                        config_path,
+                    )
+                    return config[connection_name]
+            except Exception as e:
+                LOGGER.warning("Failed to load config from %s: %s", config_path, e)
 
         raise typer.BadParameter(
-            f"Connection '{connection_name}' not found in config.toml or connections.toml. "
-            f"Searched locations: {', '.join(str(p) for p in config_paths)}"
+            f"Connection '{connection_name}' not found in connections.toml or config.toml. "
+            f"Searched locations: {', '.join(str(p) for p in searched)}"
         )
 
     def _get_default_connection_params(self) -> dict:

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_table_metadata_query.sql.j2

@@ -65,6 +65,9 @@ WITH rc_cte AS (
         END AS CHARACTER_MAXIMUM_LENGTH,
         CASE
             WHEN TRIM(C.ColumnType) IN ('I', 'I1', 'I2', 'I8') THEN 38  -- Integer types get precision 38
+            -- FLOAT, REAL and DOUBLE PRECISION are all an 8-byte IEEE double: 53 binary digits,
+            -- as Snowflake reports for FLOAT. Their scale stays NULL below.
+            WHEN TRIM(C.ColumnType) = 'F' THEN 53
             WHEN TRIM(C.ColumnType) IN ('D', 'N') THEN  -- Decimal/Numeric types
                 CASE
                     WHEN C.DecimalTotalDigits = -128 THEN 38  -- Use 38 when null (-128)

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/teradata/teradata_iso_normalization.py

@@ -19,7 +19,6 @@ from shared.datatypes.common import CommonType
 from shared.datatypes.snowflake import SnowflakeType
 from shared.datatypes.teradata import TeradataType
 from snowflake.snowflake_data_validation.utils.constants import (
-    COL_NAME_NO_QUOTES_PLACEHOLDER,
     COL_NAME_QUOTES_PLACEHOLDER,
     METRIC_QUERY_PLACEHOLDER,
     Platform,
@@ -192,7 +191,7 @@ def resolve_teradata_timestamp_normalization_template(
     source_data_type: str,
     target_snowflake_type: str | None,
     *,
-    col_placeholder: str = COL_NAME_NO_QUOTES_PLACEHOLDER,
+    col_placeholder: str = COL_NAME_QUOTES_PLACEHOLDER,
 ) -> str | None:
     """
     Resolve the Teradata ``TO_CHAR`` template for ISO timestamp DV compare.

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/utils/qvci_fallback.py

@@ -119,8 +119,9 @@ def should_apply_view_na_skip(
 ) -> bool:
     """Whether the Teradata-view NA-skip reconciliation should run.
 
-    Table-side FLOAT NA vs Snowflake 53 fails L1 today; that FAILURE is correct
-    and must be preserved. Only Teradata views get the reconciliation.
+    Only Teradata views get the reconciliation: ColumnsQV can return NULL
+    metadata for expression-backed view columns, while a table's NULL is a real
+    mismatch that L1 must still report.
     """
     return source_platform == Platform.TERADATA and object_type == ObjectType.VIEW
 

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/src/snowflake/snowflake_data_validation/validation/data_validator_base.py

@@ -277,6 +277,27 @@ def bignumeric_overflows_snowflake_number(
     return False
 
 
+def _maps_to_fixed_point_number(source_data_type: str | None, datatypes_mappings: dict[str, str]) -> bool:
+    """Return True when the source type maps to a Snowflake fixed-point NUMBER/NUMERIC/DECIMAL."""
+    mapped = mapped_target_type(source_data_type, datatypes_mappings)
+    if mapped is None:
+        return False
+    base, _, _ = parse_type_precision_scale(mapped)
+    return base in _NATIVE_NUMBER_TARGETS
+
+
+def _unconstrained_source_number_comment(criterion: str, target_number: float) -> str:
+    """Explain an unconstrained source precision or scale against Snowflake's fixed one.
+
+    The comment never carries the not-applicable marker: the report would replace
+    it with a generic "issue generating the metric" message.
+    """
+    return (
+        f"Source declares no {criterion} (unconstrained number); Snowflake fixes it at {target_number:g}, "
+        "so source values beyond the target's precision or scale may be rounded or rejected"
+    )
+
+
 _BIGNUMERIC_OVERFLOW_COMMENT = (
     "BigQuery BIGNUMERIC/BIGDECIMAL supports up to 76 digits; Snowflake DECFLOAT preserves 38 significant digits with no fixed scale"
 )
@@ -536,6 +557,29 @@ class DataValidatorBase:
             "NUMERIC_PRECISION",
             "NUMERIC_SCALE",
         }
+        # An unconstrained source number (Oracle's bare NUMBER declares neither)
+        # lands in a fixed Snowflake NUMBER(p,s). Values beyond it are rounded or
+        # rejected, so this is a capacity risk to report, not a mismatch to fail.
+        if (
+            column in warning_criteria
+            and source_value == NOT_APPLICABLE_CRITERIA_VALUE
+            and self.is_numeric(target_value)
+            and _maps_to_fixed_point_number(source_data_type, datatypes_mappings)
+        ):
+            return (
+                self.create_validation_row(
+                    validation_type=ValidationLevel.SCHEMA_VALIDATION.value,
+                    table_name=object_name,
+                    column_validated=source_validated_value,
+                    source_column_validated=source_column_validated,
+                    evaluation_criteria=column,
+                    source_value=source_value,
+                    snowflake_value=target_value,
+                    status=Result.WARNING.value,
+                    comments=_unconstrained_source_number_comment(column, float(target_value)),
+                ),
+                True,  # WARNING does not fail the column / L1 overall
+            )
         if column in warning_criteria and self.is_numeric(source_value):
             src_num = float(source_value)
             if bignumeric_overflows_snowflake_number(source_data_type, column, src_num):

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/tests/unit/Teradata/test_query_generator_teradata.py

@@ -440,3 +440,36 @@ def test_l3_time_template_follows_the_paired_target_type(source_type: str, targe
     rendered = QueryGeneratorTeradata()._build_datatypes_normalization_renderer_templates(table_context)
 
     assert rendered["TM"] == expected
+
+
+@pytest.mark.parametrize(
+    ("source_type", "target_type"),
+    [
+        ("TIMESTAMP(6)", "TIMESTAMP_NTZ(6)"),
+        ("TIMESTAMP(6) WITH TIME ZONE", "TIMESTAMP_TZ(6)"),
+        ("TIMESTAMP(6) WITH TIME ZONE", "TIMESTAMP_LTZ(6)"),
+        ("TIME(6) WITH TIME ZONE", "TIMESTAMP_TZ(6)"),
+    ],
+)
+def test_l3_paired_timestamp_template_quotes_the_column(source_type: str, target_type: str):
+    """A paired timestamp template must reference the column quoted, as the YAML templates do."""
+    from snowflake.snowflake_data_validation.utils.model.column_metadata import ColumnMetadata
+
+    column = ColumnMetadata(
+        name="Order Date",
+        data_type=source_type,
+        nullable=True,
+        is_primary_key=False,
+        calculated_column_size_in_bytes=8,
+        properties={},
+    )
+    table_context = Mock(spec=TableContext)
+    table_context.templates_loader_manager = Mock()
+    table_context.templates_loader_manager.datatypes_normalization_templates = _teradata_yaml_normalization_templates()
+    table_context.columns_to_validate = [column]
+    table_context.paired_target_column_types = {"Order Date": target_type}
+
+    rendered = QueryGeneratorTeradata()._build_datatypes_normalization_renderer_templates(table_context)
+
+    assert "CAST(\"Order Date\" AS" in rendered["Order Date"]
+    assert "CAST(Order Date" not in rendered["Order Date"]

snowflake_data_validation-1.45.2/tests/unit/Teradata/test_teradata_table_metadata_float_precision.py

@@ -0,0 +1,89 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Teradata L1 metadata reports FLOAT as a 53-bit binary precision with no scale.
+
+Teradata stores FLOAT, REAL and DOUBLE PRECISION alike as an 8-byte IEEE double
+(ColumnType 'F'), which Snowflake's FLOAT also is and reports as precision 53.
+These tests run the rendered L1 metadata query against a SQLite stand-in for the
+DBC catalog views and read what it returns, for tables and views alike.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+from contextlib import closing
+from pathlib import Path
+
+import pytest
+
+from snowflake.snowflake_data_validation.extractor.sql_queries_template_generator import (
+    SQLQueriesTemplateGenerator,
+)
+from snowflake.snowflake_data_validation.utils.constants import ObjectType, Platform
+
+
+_TERADATA_TEMPLATE_DIR = Path(__file__).resolve().parents[3] / "src/snowflake/snowflake_data_validation/teradata/extractor/templates"
+
+# What DBC holds for a column without declared digits, FLOAT included.
+_NULL_DIGITS = -128
+
+# (ColumnName, ColumnType, DecimalTotalDigits, DecimalFractionalDigits).
+# ColumnType is CHAR(2) in DBC, so one-letter codes come back padded.
+_CATALOG_ROWS = [
+    ("ID", "I ", _NULL_DIGITS, _NULL_DIGITS),
+    ("VAL", "F ", _NULL_DIGITS, _NULL_DIGITS),
+    ("AMOUNT", "D ", 18, 4),
+]
+
+_CATALOG_VIEW_FOR = {ObjectType.TABLE: "ColumnsV", ObjectType.VIEW: "ColumnsQV"}
+
+
+def _render_metadata_sql(object_type: ObjectType) -> str:
+    return SQLQueriesTemplateGenerator(str(_TERADATA_TEMPLATE_DIR)).generate_table_metadata_sql(
+        platform=Platform.TERADATA.value,
+        table_name="ORDERS",
+        schema_name="RETAIL",
+        database_name="RETAIL",
+        fully_qualified_name="RETAIL.ORDERS",
+        where_clause="",
+        has_where_clause=False,
+        columns=[],
+        is_temporary_table=False,
+        object_type=object_type,
+    )
+
+
+def _build_dbc_standin(connection: sqlite3.Connection, object_type: ObjectType) -> None:
+    catalog_view = _CATALOG_VIEW_FOR[object_type]
+    connection.execute("ATTACH DATABASE ':memory:' AS DBC")
+    connection.execute("ATTACH DATABASE ':memory:' AS RETAIL")
+    connection.execute("CREATE TABLE RETAIL.ORDERS (ID)")
+    connection.execute("CREATE TABLE DBC.TablesV (DatabaseName, TableName, TableKind)")
+    connection.execute(
+        f"CREATE TABLE DBC.{catalog_view} (DatabaseName, TableName, ColumnName, ColumnId, "
+        "ColumnType, ColumnUDTName, ColumnLength, DecimalTotalDigits, DecimalFractionalDigits, Nullable, "
+        "UpperCaseFlag)"
+    )
+    connection.executemany(
+        f"INSERT INTO DBC.{catalog_view} VALUES ('RETAIL', 'ORDERS', ?, ?, ?, NULL, 8, ?, ?, 'Y', 'N')",
+        [(name, position, code, total, fractional) for position, (name, code, total, fractional) in enumerate(_CATALOG_ROWS, 1)],
+    )
+
+
+def _precision_and_scale(object_type: ObjectType) -> dict[str, tuple[object, object]]:
+    sql = _render_metadata_sql(object_type)
+    # sqlite3's own context manager only ends the transaction; closing() releases the connection.
+    with closing(sqlite3.connect(":memory:")) as connection:
+        _build_dbc_standin(connection, object_type)
+        cursor = connection.execute(sql)
+        header = [description[0] for description in cursor.description]
+        name_at, precision_at, scale_at = (header.index(key) for key in ("COLUMN_VALIDATED", "NUMERIC_PRECISION", "NUMERIC_SCALE"))
+        return {row[name_at]: (row[precision_at], row[scale_at]) for row in cursor.fetchall()}
+
+
+@pytest.mark.parametrize("object_type", [ObjectType.TABLE, ObjectType.VIEW])
+def test_float_reports_binary_precision_53_and_no_scale(object_type: ObjectType) -> None:
+    """FLOAT reports precision 53 and NULL scale, so L1 matches Snowflake FLOAT."""
+    assert _precision_and_scale(object_type)["VAL"] == (53, None)

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/tests/unit/bigquery/test_query_generator_bigquery.py

@@ -588,3 +588,87 @@ class TestNestedTypeNormalization:
         rendered = generator._build_datatypes_normalization_renderer_templates(ctx)
 
         assert rendered["payload"] == "'USER_OVERRIDE'"
+
+    def test_struct_mixing_int64_and_numeric_hashes_the_text_data_migration_lands(self):
+        # Data migration now writes such a STRUCT field by field: the INT64 through TO_JSON
+        # (a number beyond 2^53), the NUMERIC through TO_JSON_STRING (its exact digits).
+        # The metadata query uppercases the declared type, so each key is read from the row
+        # to keep the source's case. PARSE_JSON then orders the keys as for every other
+        # nested column.
+        generator = QueryGeneratorBigQuery()
+        ctx = self._context([_column("payload", "STRUCT<ID INT64, AMOUNT NUMERIC(38, 9)>")])
+
+        rendered = generator._build_datatypes_normalization_renderer_templates(ctx)
+
+        assert rendered["payload"] == (
+            "NULLIF(TO_JSON_STRING(PARSE_JSON(IF(`payload` IS NULL, 'null', (SELECT CONCAT('{', "
+            "TO_JSON_STRING(COALESCE((SELECT field_key FROM UNNEST(__json_k1.row_keys) AS field_key "
+            "WHERE UPPER(field_key) = UPPER('AMOUNT') LIMIT 1), 'AMOUNT')), ':', "
+            "TO_JSON_STRING(`payload`.`AMOUNT`), ',', "
+            "TO_JSON_STRING(COALESCE((SELECT field_key FROM UNNEST(__json_k1.row_keys) AS field_key "
+            "WHERE UPPER(field_key) = UPPER('ID') LIMIT 1), 'ID')), ':', "
+            "TO_JSON_STRING(TO_JSON(`payload`.`ID`)), '}') "
+            "FROM UNNEST([STRUCT(ARRAY("
+            "SELECT IF(STARTS_WITH(row_key, '\"'), JSON_VALUE(PARSE_JSON(row_key)), row_key) "
+            "FROM UNNEST(JSON_KEYS(TO_JSON(`payload`), 1)) AS row_key) AS row_keys)]) AS __json_k1)))), 'null')"
+        )
+
+    def test_array_of_structs_mixing_int64_and_numeric_hashes_each_element_in_order(self):
+        # Data migration rebuilds each element of such an ARRAY<STRUCT> field by field, in
+        # array order, so the hash covers the same text.
+        generator = QueryGeneratorBigQuery()
+        ctx = self._context([_column("payload", "ARRAY<STRUCT<ID INT64, AMOUNT NUMERIC>>")])
+
+        rendered = generator._build_datatypes_normalization_renderer_templates(ctx)
+
+        assert rendered["payload"].startswith(
+            "NULLIF(TO_JSON_STRING(PARSE_JSON(IF(`payload` IS NULL, 'null', CONCAT('[', ARRAY_TO_STRING(ARRAY("
+        )
+        assert "TO_JSON_STRING(TO_JSON(__json_e1.`ID`))" in rendered["payload"]
+        assert "TO_JSON_STRING(__json_e1.`AMOUNT`)" in rendered["payload"]
+        assert "FROM UNNEST(`payload`) AS __json_e1 WITH OFFSET AS __json_o1 ORDER BY __json_o1" in rendered["payload"]
+
+    @pytest.mark.parametrize("field_name", ["{{ col_name }}", "{{ numeric_format_mask }}"])
+    def test_struct_field_named_like_a_template_placeholder_keeps_its_name(self, field_name):
+        # The field-wise text spells every declared field name, so it is written with the
+        # column already in place rather than rendered as a template whose placeholders a
+        # field name could hold.
+        generator = QueryGeneratorBigQuery()
+        ctx = self._context([_column("payload", f"STRUCT<`{field_name}` INT64, AMOUNT NUMERIC>")])
+
+        rendered = generator._build_datatypes_normalization_renderer_templates(ctx)
+
+        assert f"TO_JSON_STRING(TO_JSON(`payload`.`{field_name}`))" in rendered["payload"]
+        assert f"UPPER('{field_name}')" in rendered["payload"]
+
+    @pytest.mark.parametrize(
+        ("data_type", "overridden_type"),
+        [
+            ("STRUCT<ID INT64, AMOUNT NUMERIC>", "STRUCT"),
+            ("ARRAY<STRUCT<ID INT64, AMOUNT NUMERIC>>", "ARRAY"),
+        ],
+    )
+    def test_a_data_type_override_wins_over_the_field_wise_text(self, data_type, overridden_type):
+        # A workflow's datatype normalization (or a custom templates YAML) replaces the
+        # built-in hashing of every column of that type, field-wise text included.
+        generator = QueryGeneratorBigQuery()
+        ctx = self._context([_column("payload", data_type)])
+        loader = ctx.templates_loader_manager
+        loader.datatypes_normalization_templates[overridden_type] = "TO_JSON_STRING(`{{ col_name }}`)"
+        loader.overridden_normalization_types = {overridden_type}
+
+        rendered = generator._build_datatypes_normalization_renderer_templates(ctx)
+
+        assert rendered["payload"] == "TO_JSON_STRING(`payload`)"
+
+    def test_a_rule_for_another_column_leaves_the_field_wise_text(self):
+        generator = QueryGeneratorBigQuery()
+        ctx = self._context([_column("payload", "STRUCT<ID INT64, AMOUNT NUMERIC>")])
+
+        rendered = generator._build_datatypes_normalization_renderer_templates(
+            ctx,
+            column_normalization_map={"other": "TO_JSON_STRING(`{{ col_name }}`)"},
+        )
+
+        assert rendered["payload"] == generator._build_datatypes_normalization_renderer_templates(ctx)["payload"]
+        assert "TO_JSON_STRING(TO_JSON(`payload`.`ID`))" in rendered["payload"]

{snowflake_data_validation-1.45.1 → snowflake_data_validation-1.45.2}/tests/unit/test_connector_snowflake.py

@@ -514,3 +514,53 @@ class TestConnectorSnowflake:
             self.connector.execute_query("CREATE TABLE test_table (id INT)")
 
         assert CONNECTION_NOT_ESTABLISHED in str(exc_info.value)
+
+
+class TestLoadNamedConnectionFilePrecedence:
+    """Within one directory ``connections.toml`` replaces ``config.toml``.
+
+    That is the ``snowflake.connector`` / Snow CLI rule, so the connection
+    opened here matches the one ``snow sql`` opens for the same name.
+    """
+
+    @pytest.fixture()
+    def dirs(self, tmp_path, monkeypatch):
+        home = tmp_path / "home"
+        (home / ".snowflake").mkdir(parents=True)
+        cwd = tmp_path / "cwd"
+        cwd.mkdir()
+        monkeypatch.setattr(
+            "snowflake.snowflake_data_validation.snowflake.connector.connector_snowflake.Path.home",
+            lambda: home,
+        )
+        monkeypatch.chdir(cwd)
+        return home / ".snowflake", cwd
+
+    def test_connections_toml_wins_over_config_toml_in_the_same_directory(self, dirs):
+        sf_dir, _ = dirs
+        (sf_dir / "config.toml").write_text('[connections.e2e]\nschema = "STALE"\n')
+        (sf_dir / "connections.toml").write_text('[e2e]\nschema = "LIVE"\n')
+
+        assert ConnectorSnowflake()._load_named_connection("e2e") == {"schema": "LIVE"}
+
+    def test_config_toml_is_not_merged_when_connections_toml_exists(self, dirs):
+        sf_dir, _ = dirs
+        (sf_dir / "config.toml").write_text('[connections.only_in_config]\naccount = "x"\n')
+        (sf_dir / "connections.toml").write_text('[e2e]\naccount = "a"\n')
+
+        with pytest.raises(Exception) as exc_info:
+            ConnectorSnowflake()._load_named_connection("only_in_config")
+        assert str(sf_dir / "connections.toml") in str(exc_info.value)
+
+    def test_config_toml_used_without_connections_toml(self, dirs):
+        sf_dir, _ = dirs
+        (sf_dir / "config.toml").write_text('[connections.e2e]\nschema = "S"\n')
+
+        assert ConnectorSnowflake()._load_named_connection("e2e") == {"schema": "S"}
+
+    def test_falls_through_to_the_working_directory(self, dirs):
+        sf_dir, cwd = dirs
+        (sf_dir / "connections.toml").write_text('[other]\naccount = "a"\n')
+        (cwd / "connections.toml").write_text('[e2e]\nschema = "CWD"\n')
+
+        assert ConnectorSnowflake()._load_named_connection("e2e") == {"schema": "CWD"}