snowflake-data-validation 1.9.0__tar.gz → 1.9.2__tar.gz

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/.gitignore

@@ -14,9 +14,9 @@ __pycache__/
 # C extensions
 *.so
 
-# Sphinx documentation
-docs/build/
-docs/source/**/_autosummary
+# Sphinx documentation (snowflake-data-validation package)
+snowflake-data-validation/docs/build/
+snowflake-data-validation/docs/source/**/_autosummary
 
 
 # Distribution / packaging

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-data-validation
-Version: 1.9.0
+Version: 1.9.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/
@@ -88,7 +88,7 @@ Description-Content-Type: text/markdown
 
 **Snowflake Data Validation** is a command-line tool and Python library for validating data migrations and ensuring data quality between source and target databases, with support for SQL Server, Redshift, Teradata, and Oracle as source systems.
 
-> 📖 **For detailed usage instructions, configuration examples, and CLI reference, please check the [official documentation](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).**
+> 📖 **For detailed usage instructions, configuration examples, and CLI reference, see the [official documentation](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).**
 
 ---
 
@@ -186,6 +186,17 @@ Performs row-by-row comparison:
 
 ---
 
+## CLI commands
+
+```bash
+snowflake-data-validation <source_dialect> <command> [options]
+# Short alias: sdv <source_dialect> <command> [options]
+```
+
+Supported dialects include `sqlserver`, `teradata`, `redshift`, and `oracle`. Common commands: `run-validation`, `run-async-validation`, `source-validate`, and `generate-validation-scripts`. The dialect must match `source_platform` in your configuration file.
+
+---
+
 ## 📚 Documentation
 
 For complete command reference, configuration options, and examples, see the [Data Validation CLI](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).
@@ -194,6 +205,18 @@ For complete command reference, configuration options, and examples, see the [Da
 
 ## Changelog
 
+### v1.9.2
+
+**Bug fixes**
+
+- Fixed L3 row hashing crash when source and target tables had different column counts under existing column-selection or column-mapping config.
+
+### v1.9.1
+
+**Bug fixes**
+
+- Fixed smart partition size calculation when using `targetWhereClause`.
+
 ### v1.9.0
 
 **New features**

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/README.md

@@ -5,7 +5,7 @@
 
 **Snowflake Data Validation** is a command-line tool and Python library for validating data migrations and ensuring data quality between source and target databases, with support for SQL Server, Redshift, Teradata, and Oracle as source systems.
 
-> 📖 **For detailed usage instructions, configuration examples, and CLI reference, please check the [official documentation](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).**
+> 📖 **For detailed usage instructions, configuration examples, and CLI reference, see the [official documentation](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).**
 
 ---
 
@@ -103,6 +103,17 @@ Performs row-by-row comparison:
 
 ---
 
+## CLI commands
+
+```bash
+snowflake-data-validation <source_dialect> <command> [options]
+# Short alias: sdv <source_dialect> <command> [options]
+```
+
+Supported dialects include `sqlserver`, `teradata`, `redshift`, and `oracle`. Common commands: `run-validation`, `run-async-validation`, `source-validate`, and `generate-validation-scripts`. The dialect must match `source_platform` in your configuration file.
+
+---
+
 ## 📚 Documentation
 
 For complete command reference, configuration options, and examples, see the [Data Validation CLI](https://docs.snowflake.com/en/migrations/snowconvert-docs/data-validation-cli/CLI_QUICK_REFERENCE).
@@ -111,6 +122,18 @@ For complete command reference, configuration options, and examples, see the [Da
 
 ## Changelog
 
+### v1.9.2
+
+**Bug fixes**
+
+- Fixed L3 row hashing crash when source and target tables had different column counts under existing column-selection or column-mapping config.
+
+### v1.9.1
+
+**Bug fixes**
+
+- Fixed smart partition size calculation when using `targetWhereClause`.
+
 ### v1.9.0
 
 **New features**

snowflake_data_validation-1.9.2/docs/README.md

@@ -0,0 +1,44 @@
+# Data Validations API Documentation 
+
+## How to build the API Reference documentation
+
+1. Create a Python virtual environment if you don't have one already and activate it:
+
+    ```shell
+    python3 -m venv .venv
+    source .venv/bin/activate
+    ```
+
+2. Install the required dependencies:
+
+    ```shell
+    pip install hatch
+    ```
+
+3. Build the documentation from the root of the repository using `hatch`:
+
+    If you are not in the root of the repository, navigate to it first:
+
+    ```bash
+    cd $(git rev-parse --show-toplevel)
+    ```  
+
+    Then, run the following command to build the documentation:
+
+    ```bash
+    hatch run docs:build
+    ```
+    
+    Alternatively, to build the documentation with a custom theme for testing purposes, you can run the following command:
+    
+    ```bash
+    hatch run docs:build_pretty
+    ```
+
+4. Open the file `snowflake-data-validation/docs/build/html/index.html` in a web browser.
+
+## Important files and directories
+
+* `snowflake-data-validation/docs/source/index.rst`: Specify which `.rst` to include in the `index.html` landing page.
+* `snowflake-data-validation/docs/source/conf.py`: The configuration parameters for Sphinx and autosummary.
+* `snowflake-data-validation/docs/source/_templates/`: Directory containing JINJA templates used by autosummary.

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/__version__.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "1.9.0"
+__version__ = "1.9.2"

snowflake_data_validation-1.9.2/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_datatypes_normalization_templates.yaml

@@ -0,0 +1,87 @@
+# PostgreSQL normalization expressions for row/cell validation (canonical text).
+# POINT maps to Snowflake GEOMETRY — emit OGC WKT (space-separated coords) to
+# align with ST_ASWKT on the Snowflake side. Native point uses subscripts;
+# PostGIS geometry/geography use ST_AsText when present.
+# CAST(... AS ...) is used instead of :: casts so YAML parses unambiguously.
+# BOOLEAN / BOOL: emit lowercase true/false to match Snowflake TO_CHAR(boolean).
+# NUMERIC / DECIMAL / approximate floats: align canonical text with Snowflake ``TO_CHAR`` on the
+# mirror (Snowflake normalization templates unchanged here — Postgres adjusts to match).
+# DECIMAL / NUMERIC columns round-trip through NUMERIC(38, 12) before TO_CHAR so Postgres output
+# matches Snowflake typed ``NUMBER(p,s)`` mirrors more closely (untyped ``CAST(... AS NUMERIC)``
+# diverged around literal ``0`` / ``0.0`` payloads). Float approximate types use NUMERIC(38, 12) after
+# IEEE ``±0`` canonicalization.
+# Shared ``TO_CHAR(..., 'FM999...9999.0000')`` trims insignificant fractional zeros (FM).
+# ``float8`` can carry IEEE ``-0`` — map ``±0`` to ``+0::double precision`` /
+# ``+0::real`` with ``IS NOT DISTINCT FROM`` (``NaN`` stays distinct from zero).
+# FM ``TO_CHAR`` can omit the digit before ``.`` (``.0000``). ``REGEXP_REPLACE(..., '^\\.', '0.')``
+# aligns that with Snowflake-ish ``0….`` strings. Exact numeric zeros (all types after the shared
+# ``numeric(38,12)`` / ``NUMBER(38,12)`` cast) normalize to literal ``0.0000`` so Snowflake ``FLOAT`` /
+# ``NUMBER`` payloads that stringify as bare ``0`` still match Postgres row-hash concat.
+# Datatype keys below are sorted lexicographically.
+
+ARRAY: CAST("{{ col_name }}" AS TEXT)
+BIGINT: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+BIGSERIAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+BIT: TRIM(CAST("{{ col_name }}" AS TEXT))
+BIT VARYING: TRIM(CAST("{{ col_name }}" AS TEXT))
+BOOL: TRIM(CASE WHEN "{{ col_name }}" IS TRUE THEN 'true' WHEN "{{ col_name }}" IS FALSE THEN 'false' END)
+BOOLEAN: TRIM(CASE WHEN "{{ col_name }}" IS TRUE THEN 'true' WHEN "{{ col_name }}" IS FALSE THEN 'false' END)
+BOX: TRIM(CAST("{{ col_name }}" AS TEXT))
+BPCHAR: TRIM("{{ col_name }}")
+# BYTEA: hex must match Snowflake BINARY canonicalization (TO_HEX-style uppercase).
+BYTEA: UPPER(ENCODE("{{ col_name }}", 'hex'))
+CHAR: TRIM("{{ col_name }}")
+CHARACTER: TRIM("{{ col_name }}")
+CHARACTER VARYING: TRIM("{{ col_name }}")
+CIDR: TRIM(CAST("{{ col_name }}" AS TEXT))
+CIRCLE: TRIM(CAST("{{ col_name }}" AS TEXT))
+DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
+DATERANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+DECIMAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+DEFAULT: TRIM(CAST("{{ col_name }}" AS TEXT))
+DOMAIN: TRIM(CAST("{{ col_name }}" AS TEXT))
+DOUBLE PRECISION: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN CAST("{{ col_name }}" AS DOUBLE PRECISION) IS NOT DISTINCT FROM 0::DOUBLE PRECISION THEN 0::DOUBLE PRECISION ELSE CAST("{{ col_name }}" AS DOUBLE PRECISION) END AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN CAST("{{ col_name }}" AS DOUBLE PRECISION) IS NOT DISTINCT FROM 0::DOUBLE PRECISION THEN 0::DOUBLE PRECISION ELSE CAST("{{ col_name }}" AS DOUBLE PRECISION) END AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+ENUM: TRIM(CAST("{{ col_name }}" AS TEXT))
+FLOAT: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN CAST("{{ col_name }}" AS DOUBLE PRECISION) IS NOT DISTINCT FROM 0::DOUBLE PRECISION THEN 0::DOUBLE PRECISION ELSE CAST("{{ col_name }}" AS DOUBLE PRECISION) END AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN CAST("{{ col_name }}" AS DOUBLE PRECISION) IS NOT DISTINCT FROM 0::DOUBLE PRECISION THEN 0::DOUBLE PRECISION ELSE CAST("{{ col_name }}" AS DOUBLE PRECISION) END AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+GEOGRAPHY: TRIM(ST_AsText("{{ col_name }}"))
+GEOMETRY: TRIM(ST_AsText("{{ col_name }}"))
+INET: TRIM(CAST("{{ col_name }}" AS TEXT))
+INT4RANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+INT8RANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+INTEGER: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+INTERVAL: TRIM(CAST("{{ col_name }}" AS TEXT))
+JSON: CAST("{{ col_name }}" AS TEXT)
+JSONB: CAST("{{ col_name }}" AS TEXT)
+LINE: TRIM(CAST("{{ col_name }}" AS TEXT))
+LSEG: TRIM(CAST("{{ col_name }}" AS TEXT))
+MACADDR: TRIM(CAST("{{ col_name }}" AS TEXT))
+MACADDR8: TRIM(CAST("{{ col_name }}" AS TEXT))
+MONEY: TRIM(CAST(CAST("{{ col_name }}" AS NUMERIC) AS TEXT))
+NAME: TRIM("{{ col_name }}")
+NUMERIC: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+NUMRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+OID: TRIM(CAST("{{ col_name }}" AS TEXT))
+PATH: TRIM(CAST("{{ col_name }}" AS TEXT))
+POINT: TRIM(FORMAT('POINT(%s %s)', ("{{ col_name }}")[0], ("{{ col_name }}")[1]))
+POLYGON: TRIM(CAST("{{ col_name }}" AS TEXT))
+REAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CAST(CASE WHEN CAST("{{ col_name }}" AS REAL) IS NOT DISTINCT FROM 0::REAL THEN 0::REAL ELSE CAST("{{ col_name }}" AS REAL) END AS DOUBLE PRECISION) AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CAST(CASE WHEN CAST("{{ col_name }}" AS REAL) IS NOT DISTINCT FROM 0::REAL THEN 0::REAL ELSE CAST("{{ col_name }}" AS REAL) END AS DOUBLE PRECISION) AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+SERIAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+SMALLINT: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+SMALLSERIAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMERIC(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+TEXT: TRIM("{{ col_name }}")
+TIME: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
+TIME WITH TIME ZONE: TO_CHAR(CAST("{{ col_name }}" AT TIME ZONE 'UTC' AS time), 'HH24:MI:SS')
+TIME WITHOUT TIME ZONE: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
+TIMESTAMP: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
+TIMESTAMP WITH TIME ZONE: TO_CHAR("{{ col_name }}" AT TIME ZONE 'UTC', 'YYYY-MM-DD-HH24:MI:SS')
+TIMESTAMP WITHOUT TIME ZONE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
+TIMESTAMPTZ: TO_CHAR("{{ col_name }}" AT TIME ZONE 'UTC', 'YYYY-MM-DD-HH24:MI:SS')
+TIMETZ: TO_CHAR(CAST("{{ col_name }}" AT TIME ZONE 'UTC' AS time), 'HH24:MI:SS')
+TSQUERY: TRIM(CAST("{{ col_name }}" AS TEXT))
+TSRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+TSTZRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
+TSVECTOR: TRIM(CAST("{{ col_name }}" AS TEXT))
+UUID: TRIM(CAST("{{ col_name }}" AS TEXT))
+VARBIT: TRIM(CAST("{{ col_name }}" AS TEXT))
+VARCHAR: TRIM("{{ col_name }}")
+XML: CAST("{{ col_name }}" AS TEXT)

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_get_columns_metadata.sql.j2

@@ -7,7 +7,11 @@ SELECT
     UPPER(c.data_type) AS data_type,
     CASE WHEN tc.constraint_type = 'PRIMARY KEY' THEN 1 ELSE 0 END AS is_primary_key,
     COALESCE(c.character_maximum_length, -1) AS character_length,
-    c.numeric_precision AS precision,
+    CASE
+        WHEN c.data_type IN ('real', 'double precision', 'float4', 'float8') THEN -1
+        WHEN c.data_type IN ('smallint', 'integer', 'bigint') THEN 38
+        ELSE c.numeric_precision
+    END AS precision,
     c.numeric_scale AS scale,
     -1 AS calculated_column_size_in_bytes
 FROM information_schema.columns c

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_row_md5_select.sql.j2

@@ -6,19 +6,19 @@ SELECT
     {% if use_column_groups %}
         {% for group in column_groups %}
             {% if not loop.first %} || {% endif %}
-            UPPER(MD5(TRIM(
+            UPPER(MD5(TRIM(CONCAT(
                 {% for col in group %}
                     CAST("{{ col.name }}" AS TEXT)
-                    {% if not loop.last %} || {% endif %}
+                    {% if not loop.last %}, {% endif %}
                 {% endfor %}
-            )))
+            ))))
         {% endfor %}
     {% else %}
-        TRIM(
+        TRIM(CONCAT(
         {% for column in column_collection %}
             CAST("{{ column.name }}" AS TEXT)
-            {% if not loop.last %} || {% endif %}
-        {% endfor %})
+            {% if not loop.last %}, {% endif %}
+        {% endfor %}))
     {% endif %}
     )) AS ROW_MD5
 FROM

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_table_metadata_query.sql.j2

@@ -13,6 +13,9 @@ SELECT
     END AS CHARACTER_MAXIMUM_LENGTH,
     CASE
         WHEN c.data_type IN ('real', 'double precision', 'float4', 'float8') THEN -1
+        -- Integral Postgres types expose bit-width precision (e.g. BIGINT=64); mirror as
+        -- NUMBER(38,0) semantics so Snowflake schema comparison matches.
+        WHEN c.data_type IN ('smallint', 'integer', 'bigint') THEN 38
         ELSE c.numeric_precision
     END AS NUMERIC_PRECISION,
     c.numeric_scale AS NUMERIC_SCALE,

snowflake_data_validation-1.9.2/src/snowflake/snowflake_data_validation/snowflake/extractor/templates/snowflake_datatypes_normalization_templates.yaml

@@ -0,0 +1,23 @@
+BOOLEAN: TO_CHAR("{{ col_name }}")
+DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
+# IEEE floats: ±0 coercion, CAST to NUMBER(38,12), FM TO_CHAR, leading "." fix, and exact-zero → "0.0000"
+# (parity with Postgres row-hash text and bare "0" / ".0000" Snowflake quirks).
+FLOAT: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+DOUBLE: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+DOUBLE PRECISION: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+FLOAT4: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+FLOAT8: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+REAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST(CASE WHEN ABS("{{ col_name }}") = 0 THEN 0 ELSE "{{ col_name }}" END AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+# Fixed-point NUMBER
+NUMBER: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+DECIMAL: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+NUMERIC: CASE WHEN "{{ col_name }}" IS NULL THEN NULL WHEN CAST("{{ col_name }}" AS NUMBER(38, 12)) = 0 THEN '0.0000' ELSE TRIM(REGEXP_REPLACE(TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMBER(38, 12)), 'FM9999999999999999999999999999.0000')), '^\\.', '0.')) END
+TIME: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
+TIMESTAMP_LTZ: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
+TIMESTAMP_NTZ: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
+TIMESTAMP_TZ: TO_CHAR(CONVERT_TIMEZONE('UTC', "{{ col_name }}"), 'YYYY-MM-DD-HH24:MI:SS')
+VARCHAR: TRIM("{{ col_name }}")
+GEOMETRY: TRIM(ST_ASWKT("{{ col_name }}"))
+GEOGRAPHY: TRIM(ST_ASWKT("{{ col_name }}"))
+
+DEFAULT: TO_VARCHAR("{{ col_name }}")

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_compute_md5_sql.j2

@@ -19,7 +19,7 @@ SELECT
                     {% endfor %}
                 ))) AS CHAR(32))
             {% endfor %}
-        AS VARCHAR(64000))
+        AS VARCHAR(32000))
     {% elif column_collection|length > 1 %}
         CAST(TRIM(
             {% for column in column_collection %}
@@ -30,9 +30,9 @@ SELECT
                 {% endif %}
                 {% if not loop.last %} || {% endif %}
             {% endfor %}
-        ) AS VARCHAR(64000))
+        ) AS VARCHAR(32000))
     {% else %}
-        CAST(TRIM({{ column_names_separate_by_comma }}) AS VARCHAR(64000))
+        CAST(TRIM({{ column_names_separate_by_comma }}) AS VARCHAR(32000))
     {% endif %}
 FROM
     (SELECT

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_create_row_concatenated.sql.j2

@@ -2,5 +2,5 @@ CREATE VOLATILE TABLE "ROW_CONCATENATED_{{ chunk_id }}_{{ table_id }}" (
     {% for index_column in index_column_collection %}
         "{{ index_column.name }}_IDX" {{ index_column.data_type }},
     {% endfor %}
-    ROW_CONCAT_VALUES VARCHAR(64000)
+    ROW_CONCAT_VALUES VARCHAR(32000)
 ) ON COMMIT PRESERVE ROWS;

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_datatypes_normalization_templates.yaml

@@ -1,17 +1,17 @@
-ARRAY: CAST("{{ col_name }}" AS VARCHAR(64000))
+ARRAY: CAST("{{ col_name }}" AS VARCHAR(32000))
 BIGINT: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
 BLOB: "{{ col_name }}"
-BYTE: TRIM(CAST("{{ col_name }}" AS VARCHAR(64000)))
+BYTE: TRIM(CAST("{{ col_name }}" AS VARCHAR(32000)))
 BYTEINT: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
 CHAR: TRIM("{{ col_name }}")
 CLOB: TRIM("{{ col_name }}")
-DATASET: CAST("{{ col_name }}".toJSON() AS VARCHAR(64000))
+DATASET: CAST("{{ col_name }}".toJSON() AS VARCHAR(32000))
 DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
 DECIMAL: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
 DEFAULT: TRIM(CAST("{{ col_name }}" AS VARCHAR(1000)))
 DOUBLE PRECISION: TRIM(TO_CHAR(CAST("{{ col_name }}" AS DECIMAL(28,4)), '99999999999990.0000'))
 FLOAT: TRIM(TO_CHAR(CAST("{{ col_name }}" AS DECIMAL(28,4)), '99999999999990.0000'))
-GRAPHIC: CAST("{{ col_name }}" AS VARCHAR(64000))
+GRAPHIC: CAST("{{ col_name }}" AS VARCHAR(32000))
 INTEGER: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
 INTERVAL DAY: TRIM(CAST("{{ col_name }}" AS VARCHAR(5)))
 INTERVAL DAY TO HOUR: TRIM(CAST("{{ col_name }}" AS VARCHAR(10)))
@@ -43,7 +43,7 @@ TIME WITH TIME ZONE: TO_CHAR("{{ col_name }}" AT TIME ZONE 'GMT', 'HH24:MI:SS')
 TIMESTAMP: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
 TIMESTAMP WITH TIME ZONE: TO_CHAR("{{ col_name }}" AT TIME ZONE 'GMT', 'YYYY-MM-DD-HH24:MI:SS')
 VARARRAY: ARRAY_TO_STRING("{{ col_name }}", ', ')
-VARBYTE: TRIM(CAST("{{ col_name }}" AS VARCHAR(64000)))
+VARBYTE: TRIM(CAST("{{ col_name }}" AS VARCHAR(32000)))
 VARCHAR: TRIM("{{ col_name }}")
 VARGRAPHIC: CAST("{{ col_name }}" AS CLOB)
 XML: CAST("{{ col_name }}" AS CLOB)

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/teradata/extractor/templates/teradata_row_md5_select.sql.j2

@@ -18,7 +18,7 @@ SELECT
                     {% endfor %}
                 ))) AS VARCHAR(32))
             {% endfor %}
-        AS VARCHAR(64000))
+        AS VARCHAR(32000))
     {% elif column_collection|length > 1 %}
         CAST(TRIM(
             {% for column in column_collection %}
@@ -29,9 +29,9 @@ SELECT
                 {% endif %}
                 {% if not loop.last %} || {% endif %}
             {% endfor %}
-        ) AS VARCHAR(64000))
+        ) AS VARCHAR(32000))
     {% else %}
-        CAST(TRIM({{ column_names_separate_by_comma }}) AS VARCHAR(64000))
+        CAST(TRIM({{ column_names_separate_by_comma }}) AS VARCHAR(32000))
     {% endif %}
     ))) AS VARCHAR(32)) AS ROW_MD5
 FROM

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/utils/column_grouping.py

@@ -217,3 +217,34 @@ def compute_unified_column_groups(
         return None
 
     return src_groups, tgt_groups
+
+
+def compute_teradata_row_md5_column_groups(
+    source_columns: list[ColumnMetadata],
+    target_columns: list[ColumnMetadata],
+) -> tuple[list[list[ColumnMetadata]], list[list[ColumnMetadata]]] | None:
+    """Force one validated column per ``HASH_MD5`` segment on Teradata row-hash SQL.
+
+    Multi-column ``TRIM(a || b || ...)`` nested inside ``HASH_MD5`` can raise
+    Teradata **3798** (*column or character expression is larger than the max size*)
+    because the engine widens concatenation results before narrower ``CAST`` bounds
+    apply. Segmenting MD5 so each non-key column is hashed alone (then concatenating
+    fixed-length hex fragments) matches the stable semantics of grouped hashing while
+    avoiding that evaluation order.
+
+    Returns parallel ``(source_groups, target_groups)``, or ``None`` when no
+    segmentation applies (fewer than two validated columns).
+
+    Raises:
+        ValueError: If source/target column lists are not aligned.
+
+    """
+    if len(source_columns) <= 1:
+        return None
+    if len(source_columns) != len(target_columns):
+        raise ValueError(
+            "compute_teradata_row_md5_column_groups requires aligned column lists "
+            f"of equal length, got source={len(source_columns)} vs "
+            f"target={len(target_columns)}"
+        )
+    return ([[c] for c in source_columns], [[c] for c in target_columns])

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/src/snowflake/snowflake_data_validation/utils/constants.py

@@ -266,8 +266,12 @@ TABLE_NOT_FOUND_ERROR_CODE_SQL_SERVER = "42S02"
 # columns into groups when the estimated concatenated string would exceed
 # the engine. See the documentation URL in the comment above each entry.
 MAX_CONCAT_LENGTH: dict[Platform, int] = {
-    # VARCHAR(n) up to 64,000 characters (LATIN/UNICODE).
-    Platform.TERADATA: 51_200,
+    # ~64K is roughly the largest VARCHAR(n) Teradata lets you declare; it is not how large every
+    # intermediate string expression may grow. Row MD5 concatenates many columns in one shot, and
+    # Teradata caps those intermediates/clients/smaller widths (often around 32K bytes in practice),
+    # which yields error 3798 long before inputs hit the 64K DDL ceiling. Generated row-hash SQL
+    # therefore uses VARCHAR(32000); this splitting budget mirrors that cast: floor(0.8 * 32000).
+    Platform.TERADATA: 25_600,
     # character varying(n): n may not exceed 10,485,760 characters.
     Platform.POSTGRESQL: 8_388_608,
     # VARCHAR width up to 65,535 bytes (64K − 1); limits are in bytes.

{snowflake_data_validation-1.9.0 → snowflake_data_validation-1.9.2}/tests/unit/test_column_grouping.py

@@ -16,6 +16,7 @@
 import pytest
 
 from snowflake.snowflake_data_validation.utils.column_grouping import (
+    compute_teradata_row_md5_column_groups,
     compute_unified_column_groups,
     estimate_normalized_column_length,
     group_columns_for_md5,
@@ -206,3 +207,26 @@ class TestComputeUnifiedColumnGroups:
         tgt = [_col("a", "NUMBER"), _col("b", "NUMBER")]
         result = compute_unified_column_groups(src, tgt, max_concat_length=100_000)
         assert result is None
+
+
+class TestComputeTeradataRowMd5ColumnGroups:
+    def test_one_column_returns_none(self) -> None:
+        src = [_col("x", "VARCHAR(10)")]
+        tgt = [_col("x", "VARCHAR(10)")]
+        assert compute_teradata_row_md5_column_groups(src, tgt) is None
+
+    def test_aligns_parallel_single_column_groups(self) -> None:
+        src = [_col("a", "INTEGER"), _col("b", "VARCHAR(5)")]
+        tgt = [_col("a", "NUMBER"), _col("b", "VARCHAR(5)")]
+        out = compute_teradata_row_md5_column_groups(src, tgt)
+        assert out is not None
+        src_g, tgt_g = out
+        assert src_g == [[src[0]], [src[1]]]
+        assert tgt_g == [[tgt[0]], [tgt[1]]]
+
+    def test_mismatched_lengths_raise(self) -> None:
+        with pytest.raises(ValueError, match="aligned column lists"):
+            compute_teradata_row_md5_column_groups(
+                [_col("a", "INT"), _col("b", "INT")],
+                [_col("a", "INT")],
+            )

snowflake_data_validation-1.9.0/src/snowflake/snowflake_data_validation/postgresql/extractor/templates/postgresql_datatypes_normalization_templates.yaml

@@ -1,73 +0,0 @@
-# PostgreSQL normalization expressions for row/cell validation (canonical text).
-# POINT maps to Snowflake GEOMETRY — emit OGC WKT (space-separated coords) to
-# align with ST_ASWKT on the Snowflake side. Native point uses subscripts;
-# PostGIS geometry/geography use ST_AsText when present.
-# CAST(... AS ...) is used instead of :: casts so YAML parses unambiguously.
-# BOOLEAN / BOOL: emit lowercase true/false to match Snowflake TO_CHAR(boolean).
-# Datatype keys below are sorted lexicographically.
-
-ARRAY: CAST("{{ col_name }}" AS TEXT)
-BIGINT: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-BIGSERIAL: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-BIT: TRIM(CAST("{{ col_name }}" AS TEXT))
-BIT VARYING: TRIM(CAST("{{ col_name }}" AS TEXT))
-BOOL: TRIM(CASE WHEN "{{ col_name }}" IS TRUE THEN 'true' WHEN "{{ col_name }}" IS FALSE THEN 'false' END)
-BOOLEAN: TRIM(CASE WHEN "{{ col_name }}" IS TRUE THEN 'true' WHEN "{{ col_name }}" IS FALSE THEN 'false' END)
-BOX: TRIM(CAST("{{ col_name }}" AS TEXT))
-BPCHAR: TRIM("{{ col_name }}")
-BYTEA: ENCODE("{{ col_name }}", 'hex')
-CHAR: TRIM("{{ col_name }}")
-CHARACTER: TRIM("{{ col_name }}")
-CHARACTER VARYING: TRIM("{{ col_name }}")
-CIDR: TRIM(CAST("{{ col_name }}" AS TEXT))
-CIRCLE: TRIM(CAST("{{ col_name }}" AS TEXT))
-DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
-DATERANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-DECIMAL: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-DEFAULT: TRIM(CAST("{{ col_name }}" AS TEXT))
-DOMAIN: TRIM(CAST("{{ col_name }}" AS TEXT))
-DOUBLE PRECISION: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(28,4)), '99999999999990.0000'))
-ENUM: TRIM(CAST("{{ col_name }}" AS TEXT))
-FLOAT: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(28,4)), '99999999999990.0000'))
-GEOGRAPHY: TRIM(ST_AsText("{{ col_name }}"))
-GEOMETRY: TRIM(ST_AsText("{{ col_name }}"))
-INET: TRIM(CAST("{{ col_name }}" AS TEXT))
-INT4RANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-INT8RANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-INTEGER: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-INTERVAL: TRIM(CAST("{{ col_name }}" AS TEXT))
-JSON: CAST("{{ col_name }}" AS TEXT)
-JSONB: CAST("{{ col_name }}" AS TEXT)
-LINE: TRIM(CAST("{{ col_name }}" AS TEXT))
-LSEG: TRIM(CAST("{{ col_name }}" AS TEXT))
-MACADDR: TRIM(CAST("{{ col_name }}" AS TEXT))
-MACADDR8: TRIM(CAST("{{ col_name }}" AS TEXT))
-MONEY: TRIM(CAST(CAST("{{ col_name }}" AS NUMERIC) AS TEXT))
-NAME: TRIM("{{ col_name }}")
-NUMERIC: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-NUMRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-OID: TRIM(CAST("{{ col_name }}" AS TEXT)
-PATH: TRIM(CAST("{{ col_name }}" AS TEXT))
-POINT: TRIM(FORMAT('POINT(%s %s)', ("{{ col_name }}")[0], ("{{ col_name }}")[1]))
-POLYGON: TRIM(CAST("{{ col_name }}" AS TEXT))
-REAL: TRIM(TO_CHAR(CAST("{{ col_name }}" AS NUMERIC(28,4)), '99999999999990.0000'))
-SERIAL: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-SMALLINT: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-SMALLSERIAL: TRIM(TO_CHAR("{{ col_name }}", '99999999999990.0000'))
-TEXT: TRIM("{{ col_name }}")
-TIME: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
-TIME WITH TIME ZONE: TO_CHAR(CAST("{{ col_name }}" AT TIME ZONE 'UTC' AS time), 'HH24:MI:SS')
-TIME WITHOUT TIME ZONE: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
-TIMESTAMP: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
-TIMESTAMP WITH TIME ZONE: TO_CHAR("{{ col_name }}" AT TIME ZONE 'UTC', 'YYYY-MM-DD-HH24:MI:SS')
-TIMESTAMP WITHOUT TIME ZONE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
-TIMESTAMPTZ: TO_CHAR("{{ col_name }}" AT TIME ZONE 'UTC', 'YYYY-MM-DD-HH24:MI:SS')
-TIMETZ: TO_CHAR(CAST("{{ col_name }}" AT TIME ZONE 'UTC' AS time), 'HH24:MI:SS')
-TSQUERY: TRIM(CAST("{{ col_name }}" AS TEXT))
-TSRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-TSTZRANGE: TRIM(CAST("{{ col_name }}" AS TEXT))
-TSVECTOR: TRIM(CAST("{{ col_name }}" AS TEXT))
-UUID: TRIM(CAST("{{ col_name }}" AS TEXT))
-VARBIT: TRIM(CAST("{{ col_name }}" AS TEXT))
-VARCHAR: TRIM("{{ col_name }}")
-XML: CAST("{{ col_name }}" AS TEXT)

snowflake_data_validation-1.9.0/src/snowflake/snowflake_data_validation/snowflake/extractor/templates/snowflake_datatypes_normalization_templates.yaml

@@ -1,13 +0,0 @@
-BOOLEAN: TO_CHAR("{{ col_name }}")
-DATE: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD')
-FLOAT: TO_CHAR("{{ col_name }}", 'FM9999999999999999999999999999.0000')
-NUMBER: TO_CHAR("{{ col_name }}", 'FM9999999999999999999999999999.0000')
-TIME: TO_CHAR("{{ col_name }}", 'HH24:MI:SS')
-TIMESTAMP_LTZ: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
-TIMESTAMP_NTZ: TO_CHAR("{{ col_name }}", 'YYYY-MM-DD-HH24:MI:SS')
-TIMESTAMP_TZ: TO_CHAR(CONVERT_TIMEZONE('UTC', "{{ col_name }}"), 'YYYY-MM-DD-HH24:MI:SS')
-VARCHAR: TRIM("{{ col_name }}")
-GEOMETRY: TRIM(ST_ASWKT("{{ col_name }}"))
-GEOGRAPHY: TRIM(ST_ASWKT("{{ col_name }}"))
-
-DEFAULT: TO_VARCHAR("{{ col_name }}")