snowflake-data-validation 1.24.2__tar.gz → 1.25.0__tar.gz

{snowflake_data_validation-1.24.2 → snowflake_data_validation-1.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-data-validation
-Version: 1.24.2
+Version: 1.25.0
 Summary: Snowflake Data Validation
 Project-URL: Bug Tracker, https://github.com/snowflake-eng/migrations-data-validation/issues
 Project-URL: Source code, https://github.com/snowflake-eng/migrations-data-validation/
@@ -218,6 +218,18 @@ For complete command reference, configuration options, and examples, see the [Da
 
 ## Changelog
 
+### v1.25.0
+
+**New features**
+
+- Added automatic primary key inference for SQL Server, Teradata, and Redshift.
+- Added BigQuery support for cloud Data Validation (L1/L2/L3).
+- Added Redshift data type coverage for data migration and validation.
+
+**Improvements**
+
+- Improved numeric canonical rendering with scale-aware precision for Oracle, Teradata, Redshift, and PostgreSQL.
+
 ### v1.24.2
 
 **New features**

{snowflake_data_validation-1.24.2 → snowflake_data_validation-1.25.0}/README.md

@@ -132,6 +132,18 @@ For complete command reference, configuration options, and examples, see the [Da
 
 ## Changelog
 
+### v1.25.0
+
+**New features**
+
+- Added automatic primary key inference for SQL Server, Teradata, and Redshift.
+- Added BigQuery support for cloud Data Validation (L1/L2/L3).
+- Added Redshift data type coverage for data migration and validation.
+
+**Improvements**
+
+- Improved numeric canonical rendering with scale-aware precision for Oracle, Teradata, Redshift, and PostgreSQL.
+
 ### v1.24.2
 
 **New features**

{snowflake_data_validation-1.24.2 → snowflake_data_validation-1.25.0}/src/snowflake/snowflake_data_validation/__init__.py

@@ -98,6 +98,7 @@ import snowflake.snowflake_data_validation.snowflake as snowflake
 import snowflake.snowflake_data_validation.sqlserver as sqlserver
 import snowflake.snowflake_data_validation.redshift as redshift
 import snowflake.snowflake_data_validation.oracle as oracle
+import snowflake.snowflake_data_validation.bigquery as bigquery
 import snowflake.snowflake_data_validation.public as public
 import logging
 
@@ -119,6 +120,7 @@ __all__ = [
     "sqlserver",
     "redshift",
     "oracle",
+    "bigquery",
     "public",
 ]
 

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/__init__.py

@@ -0,0 +1,29 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Snowflake Data Validation BigQuery
+=====================================
+
+This package provides BigQuery-specific query generation for data validation.
+
+BigQuery participates as a *source* platform whose row extraction is driven by
+the Data Exchange Agent (DEA). The desktop package only owns the query
+generator and the SQL/YAML templates required to produce parity-preserving
+BigQuery SQL for L1 (schema), L2 (metrics) and L3 (row-hash) validation against
+a Snowflake target. It does not open BigQuery connections itself.
+
+Main Components
+----------------
+- QueryGeneratorBigQuery: BigQuery-specific SQL generation (inline SELECT path).
+- extractor/templates: BigQuery normalization, metrics and metadata templates.
+"""
+
+from snowflake.snowflake_data_validation.bigquery.query.query_generator_bigquery import (
+    QueryGeneratorBigQuery,
+)
+
+
+__all__ = [
+    "QueryGeneratorBigQuery",
+]

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/extractor/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2026 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""BigQuery extractor templates (normalization, metrics, metadata)."""

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/extractor/templates/bigquery_cell_validation_data_select.sql.j2

@@ -0,0 +1,16 @@
+{% import 'query_modifiers.sql.j2' as qm with context %}
+{{ qm.locking_prefix(query_modifiers) }}SELECT
+{% for column in column_collection %}
+    {% if column.nullable %}
+        RTRIM(COALESCE({{ datatypes_normalization_renderer_templates[column.name] }}, '{{ null_hashing_sentinel }}')) AS `{{ column.name }}`{% if not loop.last %},{% endif %}
+    {% else %}
+        RTRIM({{ datatypes_normalization_renderer_templates[column.name] }}) AS `{{ column.name }}`{% if not loop.last %},{% endif %}
+    {% endif %}
+{% endfor %}
+FROM (
+    SELECT * {{ qm.render_from_clause(query_modifiers, fully_qualified_name, 't') }}
+    {% if has_where_clause %} WHERE {{ where_clause }} {% endif %}
+    {% if order_by_columns %}
+    ORDER BY {% for c in order_by_columns %} `{{ c }}`{% if not loop.last %}, {% endif %}{% endfor %}
+    {% endif %}
+) __ordered

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/extractor/templates/bigquery_column_metrics_templates.yaml

@@ -0,0 +1,395 @@
+# BigQuery column metrics templates (L1/L2 validation).
+#
+# Keys are BigQuery *base* types (parameters/parametrization stripped by
+# QueryGeneratorBigQuery.normalize_bigquery_type -> _resolve_metrics_col_type).
+# `{{ col_name }}` is replaced with the backtick-quoted column name at render time.
+#
+# Notes:
+#   - COUNTIF(<bool>) is used for conditional counts.
+#   - sum/avg/stddev cast to FLOAT64 to avoid INT64 overflow and to give a single
+#     stable aggregate type across INT64/NUMERIC/BIGNUMERIC. Log-scale BIGNUMERIC
+#     metrics are a documented follow-on (out of epic v1).
+#   - ARRAY/STRUCT/JSON/GEOGRAPHY/RANGE/INTERVAL are count-only: MIN/MAX/SUM and
+#     COUNT(DISTINCT) are not meaningful (or not allowed) for these types in BigQuery.
+
+# ----- Integer types -----
+INT64:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: INT64
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+INTEGER:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: INT64
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+# ----- Floating point -----
+FLOAT64:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: FLOAT64
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: FLOAT64
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(<expr>, N) by
+  # QueryGeneratorBigQuery to match the Snowflake target's `col % N`. MOD rejects
+  # FLOAT64, so the column is widened to BIGNUMERIC first (see the generator).
+  avg:
+    metric_query: AVG(CAST(CAST(`{{ col_name }}` AS BIGNUMERIC){{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(CAST(`{{ col_name }}` AS BIGNUMERIC){{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(CAST(`{{ col_name }}` AS BIGNUMERIC){{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+# ----- Decimal types -----
+NUMERIC:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: NUMERIC
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: NUMERIC
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+DECIMAL:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: NUMERIC
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: NUMERIC
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+BIGNUMERIC:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: BIGNUMERIC
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: BIGNUMERIC
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+BIGDECIMAL:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: BIGNUMERIC
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: BIGNUMERIC
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+  count_zero:
+    metric_query: COUNTIF(`{{ col_name }}` = 0)
+    metric_return_datatype: INT64
+  # {{ modifier }} is the overflow-guard modulo, rendered as MOD(`col`, N) by
+  # QueryGeneratorBigQuery so sum/avg/stddev match the Snowflake target's
+  # `col % N` (BigQuery GoogleSQL has no `%` operator).
+  avg:
+    metric_query: AVG(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  sum:
+    metric_query: SUM(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+  stddev:
+    metric_query: STDDEV_POP(CAST(`{{ col_name }}`{{ modifier }} AS FLOAT64))
+    metric_return_datatype: FLOAT64
+    metric_column_modifier: "% 2097143"
+
+# ----- Boolean -----
+BOOL:
+  count_true:
+    metric_query: COUNTIF(`{{ col_name }}` IS TRUE)
+    metric_return_datatype: INT64
+  count_false:
+    metric_query: COUNTIF(`{{ col_name }}` IS FALSE)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+BOOLEAN:
+  count_true:
+    metric_query: COUNTIF(`{{ col_name }}` IS TRUE)
+    metric_return_datatype: INT64
+  count_false:
+    metric_query: COUNTIF(`{{ col_name }}` IS FALSE)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# ----- String -----
+STRING:
+  min:
+    metric_query: MIN(LENGTH(`{{ col_name }}`))
+    metric_return_datatype: INT64
+  max:
+    metric_query: MAX(LENGTH(`{{ col_name }}`))
+    metric_return_datatype: INT64
+  avg:
+    metric_query: AVG(CAST(LENGTH(`{{ col_name }}`) AS FLOAT64))
+    metric_return_datatype: FLOAT64
+  count_empty:
+    metric_query: COUNTIF(`{{ col_name }}` = '')
+    metric_return_datatype: INT64
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# ----- Bytes -----
+BYTES:
+  min:
+    metric_query: MIN(BYTE_LENGTH(`{{ col_name }}`))
+    metric_return_datatype: INT64
+  max:
+    metric_query: MAX(BYTE_LENGTH(`{{ col_name }}`))
+    metric_return_datatype: INT64
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# ----- Date and time -----
+DATE:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: DATE
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: DATE
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+TIME:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: TIME
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: TIME
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# DATETIME maps to Snowflake TIMESTAMP_NTZ, whose min/max metric canonical is
+# TO_CHAR(x, 'YYYY-MM-DD"T"HH24:MI:SS.FF9'). Emit the SAME canonical text (T
+# separator, 9 fractional digits, no zone) so L2 min/max strings match the
+# target byte-for-byte; without this BigQuery returns "YYYY-MM-DD HH:MM:SS" with
+# microsecond precision and the comparison fails.
+DATETIME:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: DATETIME
+    metric_normalization: FORMAT_DATETIME('%E4Y-%m-%dT%H:%M:%E9S', {{ metric_query }})
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: DATETIME
+    metric_normalization: FORMAT_DATETIME('%E4Y-%m-%dT%H:%M:%E9S', {{ metric_query }})
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# TIMESTAMP maps to Snowflake TIMESTAMP_TZ, whose min/max metric canonical ends
+# in the "+00:00" UTC offset. Mirror the L3 row-hash format (%Ez over UTC) so the
+# L2 min/max strings match the target byte-for-byte.
+TIMESTAMP:
+  min:
+    metric_query: MIN(`{{ col_name }}`)
+    metric_return_datatype: TIMESTAMP
+    metric_normalization: FORMAT_TIMESTAMP('%E4Y-%m-%dT%H:%M:%E9S%Ez', {{ metric_query }}, 'UTC')
+  max:
+    metric_query: MAX(`{{ col_name }}`)
+    metric_return_datatype: TIMESTAMP
+    metric_normalization: FORMAT_TIMESTAMP('%E4Y-%m-%dT%H:%M:%E9S%Ez', {{ metric_query }}, 'UTC')
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+# ----- Complex / semi-structured (count-only) -----
+ARRAY:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+STRUCT:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+JSON:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+GEOGRAPHY:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+INTERVAL:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+RANGE:
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64
+
+DEFAULT:
+  count_distinct:
+    metric_query: COUNT(DISTINCT `{{ col_name }}`)
+    metric_return_datatype: INT64
+  count_null:
+    metric_query: COUNTIF(`{{ col_name }}` IS NULL)
+    metric_return_datatype: INT64

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/extractor/templates/bigquery_datatypes_normalization_templates.yaml

@@ -0,0 +1,86 @@
+# BigQuery datatype normalization templates (L3 row-hash + cell validation).
+#
+# Each expression must produce the SAME canonical text as the Snowflake target
+# normalization for identical values, so that UPPER(TO_HEX(MD5(...))) on the
+# BigQuery source equals UPPER(MD5(...)) on the Snowflake target.
+#
+# Keys are BigQuery *base* types (parameters/parametrization stripped by
+# QueryGeneratorBigQuery.normalize_bigquery_type). `{{ col_name }}` is replaced
+# with the (backtick-quoted) column name at render time.
+#
+# Canonical formats (mirroring snowflake_datatypes_normalization_templates.yaml):
+#   number   -> fixed 4 decimals, no leading zero for |value| < 1
+#   date     -> YYYY-MM-DD
+#   time     -> HH:MM:SS
+#   datetime -> YYYY-MM-DDTHH:MM:SS.fffffffff (9 fractional digits)
+#   timestamp-> YYYY-MM-DDTHH:MM:SS.fffffffff+00:00 (UTC instant)
+#   binary   -> <UPPER HEX> (matches Snowflake HEX_ENCODE, no 0x prefix)
+#
+# Phase 5 POC parity results (SNOW-3641471), BQ_DV_ALL_TYPES 130-row seed vs Snowflake:
+#   PASS (130/130): INT64, STRING, BYTES, BOOL, DATE, TIME, DATETIME, TIMESTAMP,
+#                   JSON, ARRAY<INT64>, STRUCT, GEOGRAPHY, INTERVAL, RANGE.
+#     STRUCT/JSON parity achieved by round-tripping through PARSE_JSON, which sorts
+#     object keys alphabetically (recursively) exactly like Snowflake OBJECT/VARIANT.
+#   PARTIAL: FLOAT64/NUMERIC/BIGNUMERIC match except the extreme boundary rows
+#     (double-max, 1e29, 1e38) where the SHARED Snowflake target format
+#     'FM....0000' (28 integer digits) overflows to '#'. This is a target-format
+#     limitation shared by all source platforms, not BigQuery-specific.
+
+# Scale-aware numeric parity: the Snowflake target renders NUMBER as
+# TO_CHAR(col, 'FM999...990.00...0') with the column's exact scale, so BigQuery
+# emits FORMAT('%.<scale>f', ...) with the SAME scale. The mask
+# ``{{ numeric_format_mask }}`` is resolved to a printf spec (e.g. ``%.2f``) at
+# render time from the column's declared NUMERIC_SCALE / (p, s). Integers cast to
+# NUMERIC because BigQuery FORMAT('%f', ...) rejects INT64. Both sides keep the
+# single leading zero for |value| < 1 (e.g. 0 -> "0.00"), so they hash identically.
+INT64: FORMAT('{{ numeric_format_mask }}', CAST(`{{ col_name }}` AS NUMERIC))
+INTEGER: FORMAT('{{ numeric_format_mask }}', CAST(`{{ col_name }}` AS NUMERIC))
+
+# FLOAT64 maps to Snowflake FLOAT, which normalizes via TO_CHAR(col, 'TME')
+# (16-significant-figure normalized scientific notation). The shim renders the
+# same shape from BigQuery FORMAT('%.15e', ...). See
+# QueryGeneratorBigQuery.build_float_tme_shim.
+FLOAT64: '{{ float_tme_shim }}'
+
+# NUMERIC/BIGNUMERIC map to Snowflake NUMBER, which renders scale-aware via
+# TO_CHAR(col, 'FM...0.00..0'). BigQuery mirrors that scale with the resolved
+# printf mask ``{{ numeric_format_mask }}`` (e.g. NUMBER(38,9) -> '%.9f'), so a
+# bounded BIGNUMERIC(p, s) that fits NUMBER hashes identically. (A bare
+# BIGNUMERIC (76, 38) cannot map to NUMBER and fails L1 before L2/L3.)
+NUMERIC: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
+DECIMAL: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
+BIGNUMERIC: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
+BIGDECIMAL: FORMAT('{{ numeric_format_mask }}', `{{ col_name }}`)
+
+# Snowflake BOOLEAN normalizes to uppercase 'TRUE'/'FALSE' (see
+# snowflake_datatypes_normalization_templates.yaml); match it so the row hashes agree.
+BOOL: CASE WHEN `{{ col_name }}` THEN 'TRUE' WHEN NOT `{{ col_name }}` THEN 'FALSE' END
+BOOLEAN: CASE WHEN `{{ col_name }}` THEN 'TRUE' WHEN NOT `{{ col_name }}` THEN 'FALSE' END
+
+STRING: RTRIM(`{{ col_name }}`)
+# Snowflake BINARY normalizes via HEX_ENCODE (uppercase hex, no 0x prefix); match
+# it exactly so the row hashes agree.
+BYTES: UPPER(TO_HEX(`{{ col_name }}`))
+
+# %E4Y zero-pads the year to 4 digits so year 1 renders "0001" (matches Snowflake YYYY).
+DATE: FORMAT_DATE('%E4Y-%m-%d', `{{ col_name }}`)
+TIME: FORMAT_TIME('%H:%M:%S', `{{ col_name }}`)
+DATETIME: FORMAT_DATETIME('%E4Y-%m-%dT%H:%M:%E9S', `{{ col_name }}`)
+TIMESTAMP: FORMAT_TIMESTAMP('%E4Y-%m-%dT%H:%M:%E9S%Ez', `{{ col_name }}`, 'UTC')
+
+# Semi-structured parity: Snowflake OBJECT/VARIANT serialize with keys sorted
+# alphabetically (recursively) and collapse a JSON `null` to SQL NULL. BigQuery's
+# JSON type does the SAME canonicalization, so round-tripping through PARSE_JSON
+# (re-serialized with TO_JSON_STRING) yields identical text to Snowflake. NULLIF on
+# 'null' maps a SQL-NULL/JSON-null value to the hashing sentinel like Snowflake does.
+ARRAY: NULLIF(TO_JSON_STRING(PARSE_JSON(TO_JSON_STRING(`{{ col_name }}`))), 'null')
+STRUCT: NULLIF(TO_JSON_STRING(PARSE_JSON(TO_JSON_STRING(`{{ col_name }}`))), 'null')
+JSON: NULLIF(TO_JSON_STRING(PARSE_JSON(TO_JSON_STRING(`{{ col_name }}`))), 'null')
+# BigQuery ST_ASTEXT emits ", " between vertices; Snowflake ST_ASWKT uses ",". Collapse
+# the space so multi-vertex geometries (LINESTRING/POLYGON) hash identically.
+GEOGRAPHY: TRIM(REGEXP_REPLACE(ST_ASTEXT(`{{ col_name }}`), r', ', r','))
+
+INTERVAL: CAST(`{{ col_name }}` AS STRING)
+RANGE: CAST(`{{ col_name }}` AS STRING)
+
+DEFAULT: CAST(`{{ col_name }}` AS STRING)

snowflake_data_validation-1.25.0/src/snowflake/snowflake_data_validation/bigquery/extractor/templates/bigquery_get_columns_metadata.sql.j2

@@ -0,0 +1,44 @@
+{% import 'query_modifiers.sql.j2' as qm with context %}
+{{ qm.locking_prefix(query_modifiers) }}
+SELECT
+    UPPER('{{ database_name | escape_sql_literal }}') AS database_name,
+    UPPER(c.table_schema) AS schema_name,
+    UPPER(c.table_name) AS table_name,
+    UPPER(c.column_name) AS column_name,
+    CASE
+        WHEN c.is_nullable = 'YES' THEN true
+        ELSE false
+    END AS nullable,
+    UPPER(c.data_type) AS data_type,
+    0 AS is_primary_key,
+    CAST(NULL AS INT64) AS character_length,
+    -- BigQuery INFORMATION_SCHEMA carries NUMERIC/BIGNUMERIC precision/scale only
+    -- inside the parameterized type string (e.g. NUMERIC(10, 2)); a bare NUMERIC
+    -- defaults to (38, 9) and BIGNUMERIC to (76, 38). Resolve (p, s) here so the
+    -- scale-aware numeric mask renders with the column's real scale on both the
+    -- source and the mirrored Snowflake target (identical -> hashes match).
+    CASE
+        WHEN STARTS_WITH(UPPER(c.data_type), 'BIGNUMERIC') OR STARTS_WITH(UPPER(c.data_type), 'BIGDECIMAL')
+            THEN COALESCE(CAST(REGEXP_EXTRACT(c.data_type, r'\((\d+)') AS INT64), 76)
+        WHEN STARTS_WITH(UPPER(c.data_type), 'NUMERIC') OR STARTS_WITH(UPPER(c.data_type), 'DECIMAL')
+            THEN COALESCE(CAST(REGEXP_EXTRACT(c.data_type, r'\((\d+)') AS INT64), 38)
+        WHEN UPPER(c.data_type) IN ('INT64', 'INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'TINYINT', 'BYTEINT')
+            THEN 38
+        ELSE NULL
+    END AS precision,
+    CASE
+        WHEN STARTS_WITH(UPPER(c.data_type), 'BIGNUMERIC') OR STARTS_WITH(UPPER(c.data_type), 'BIGDECIMAL')
+            THEN COALESCE(
+                CAST(REGEXP_EXTRACT(c.data_type, r'\(\d+\s*,\s*(\d+)\)') AS INT64),
+                CASE WHEN REGEXP_CONTAINS(c.data_type, r'\(\d+\)') THEN 0 ELSE 38 END)
+        WHEN STARTS_WITH(UPPER(c.data_type), 'NUMERIC') OR STARTS_WITH(UPPER(c.data_type), 'DECIMAL')
+            THEN COALESCE(
+                CAST(REGEXP_EXTRACT(c.data_type, r'\(\d+\s*,\s*(\d+)\)') AS INT64),
+                CASE WHEN REGEXP_CONTAINS(c.data_type, r'\(\d+\)') THEN 0 ELSE 9 END)
+        WHEN UPPER(c.data_type) IN ('INT64', 'INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'TINYINT', 'BYTEINT')
+            THEN 0
+        ELSE NULL
+    END AS scale,
+    -1 AS calculated_column_size_in_bytes
+FROM `{{ database_name }}`.`{{ schema_name }}`.INFORMATION_SCHEMA.COLUMNS c
+WHERE c.table_name = '{{ table_name | escape_sql_literal }}';