collate-data-diff 0.11.9__tar.gz → 0.11.11__tar.gz

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collate-data-diff
-Version: 0.11.9
+Version: 0.11.11
 Summary: Command-line tool and Python library to efficiently diff rows across two different databases.
 License: MIT
 License-File: LICENSE
@@ -37,9 +37,9 @@ Provides-Extra: snowflake
 Provides-Extra: trino
 Provides-Extra: vertica
 Requires-Dist: attrs (>=23.1.0)
-Requires-Dist: click (>=8.1)
+Requires-Dist: click (>=8.3.3)
 Requires-Dist: clickhouse-driver ; extra == "clickhouse" or extra == "all-dbs"
-Requires-Dist: cryptography ; extra == "snowflake" or extra == "all-dbs"
+Requires-Dist: cryptography (>=46.0.5) ; extra == "snowflake" or extra == "all-dbs"
 Requires-Dist: dbt-core (>=1.0.0,<2.0.0)
 Requires-Dist: deepdiff (>=8.6.1,<9.0)
 Requires-Dist: dsnparse (<0.2.0)
@@ -52,15 +52,15 @@ Requires-Dist: oracledb ; extra == "oracle" or extra == "all-dbs"
 Requires-Dist: preql (>=0.2.19) ; extra == "preql" or extra == "all-dbs"
 Requires-Dist: presto-python-client ; extra == "presto" or extra == "all-dbs"
 Requires-Dist: psycopg2 ; extra == "postgresql" or extra == "redshift" or extra == "all-dbs"
-Requires-Dist: pydantic (>=1.10.12)
+Requires-Dist: pydantic (>=2.0,<3)
 Requires-Dist: pyodbc (>=4.0.39) ; extra == "mssql" or extra == "all-dbs"
 Requires-Dist: rich
-Requires-Dist: snowflake-connector-python (>=3.15.0,<4.0.0) ; (python_version >= "3.9") and (extra == "snowflake" or extra == "all-dbs")
+Requires-Dist: snowflake-connector-python (>=4.4.0,<5.0.0) ; (python_version >= "3.10") and (extra == "snowflake" or extra == "all-dbs")
 Requires-Dist: tabulate (>=0.9.0)
 Requires-Dist: toml (>=0.10.2)
 Requires-Dist: trino (>=0.314.0) ; extra == "trino" or extra == "all-dbs"
 Requires-Dist: typing-extensions (>=4.0.1)
-Requires-Dist: urllib3 (<2)
+Requires-Dist: urllib3 (>=2.7.0,<3)
 Requires-Dist: vertica-python ; extra == "vertica" or extra == "all-dbs"
 Project-URL: Repository, https://github.com/datafold/data-diff
 Description-Content-Type: text/markdown

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/__init__.py

@@ -41,6 +41,7 @@ def connect_to_table(
 
     return TableSegment(db, table_name, key_columns, **kw)
 
+
 def _get_table_segment_args(**kwargs):
     accepted_kwargs = {
         "update_column",

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/__main__.py

@@ -253,14 +253,12 @@ click.Context.formatter_class = MyHelpFormatter
 )
 @click.option(
     "--select",
-    "-s",
     default=None,
     metavar="SELECTION or MODEL_NAME",
     help="--select dbt resources to compare using dbt selection syntax in dbt versions >= 1.5.\nIn versions < 1.5, it will naively search for a model with MODEL_NAME as the name.",
 )
 @click.option(
     "--state",
-    "-s",
     default=None,
     metavar="PATH",
     help="Specify manifest to utilize for 'prod' comparison paths instead of using configuration.",
@@ -611,7 +609,7 @@ def _data_diff(
         _print_result(stats, json_output, diff_iter)
 
     end = time.monotonic()
-    logging.info(f"Duration: {end-start:.2f} seconds.")
+    logging.info(f"Duration: {end - start:.2f} seconds.")
 
 
 if __name__ == "__main__":

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/cloud/datafold_api.py

@@ -103,8 +103,8 @@ class TCloudApiDataDiff(pydantic.BaseModel):
     pk_columns: List[str]
     filter1: Optional[str] = None
     filter2: Optional[str] = None
-    include_columns: Optional[List[str]]
-    exclude_columns: Optional[List[str]]
+    include_columns: Optional[List[str]] = None
+    exclude_columns: Optional[List[str]] = None
 
 
 class TCloudApiOrgMeta(pydantic.BaseModel):
@@ -150,10 +150,10 @@ class TSummaryResultDependencyDetails(pydantic.BaseModel):
 
 class TCloudApiDataDiffSummaryResult(pydantic.BaseModel):
     status: str
-    pks: Optional[TSummaryResultPrimaryKeyStats]
-    values: Optional[TSummaryResultValueStats]
-    schema_: Optional[TSummaryResultSchemaStats]
-    deps: Optional[TSummaryResultDependencyDetails]
+    pks: Optional[TSummaryResultPrimaryKeyStats] = None
+    values: Optional[TSummaryResultValueStats] = None
+    schema_: Optional[TSummaryResultSchemaStats] = None
+    deps: Optional[TSummaryResultDependencyDetails] = None
 
     @classmethod
     def from_orm(cls, obj: Any) -> Self:
@@ -179,7 +179,7 @@ class TCloudDataSourceTestResult(pydantic.BaseModel):
 class TCloudApiDataSourceTestResult(pydantic.BaseModel):
     name: str
     status: str
-    result: Optional[TCloudDataSourceTestResult]
+    result: Optional[TCloudDataSourceTestResult] = None
 
 
 @attrs.define(frozen=False)
@@ -223,7 +223,7 @@ class DatafoldAPI:
         return TCloudApiDataSource(**datasource)
 
     def create_data_source(self, config: TDsConfig) -> TCloudApiDataSource:
-        payload = config.dict()
+        payload = config.model_dump()
         if config.type == "bigquery":
             json_string = payload["options"]["jsonKeyFile"].encode("utf-8")
             payload["options"]["jsonKeyFile"] = base64.b64encode(json_string).decode("utf-8")
@@ -245,7 +245,7 @@ class DatafoldAPI:
         ]
 
     def create_data_diff(self, payload: TCloudApiDataDiff) -> int:
-        rv = self.make_post_request(url="api/v1/datadiffs", payload=payload.dict())
+        rv = self.make_post_request(url="api/v1/datadiffs", payload=payload.model_dump())
         return rv.json()["id"]
 
     def poll_data_diff_results(self, diff_id: int) -> TCloudApiDataDiffSummaryResult:

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/base.py

@@ -137,7 +137,7 @@ class Compiler(AbstractCompiler):
 
     def new_unique_table_name(self, prefix="tmp") -> DbPath:
         self._counter[0] += 1
-        table_name = f"{prefix}{self._counter[0]}_{'%x'%random.randrange(2**32)}"
+        table_name = f"{prefix}{self._counter[0]}_{'%x' % random.randrange(2**32)}"
         return self.database.dialect.parse_table_name(table_name)
 
     def add_table_context(self, *tables: Sequence, **kw) -> Self:
@@ -706,7 +706,7 @@ class BaseDialect(abc.ABC):
             return f"'{v.uuid}'"
         elif isinstance(v, decimal.Decimal):
             return str(v)
-        elif isinstance(v, bytearray):
+        elif isinstance(v, (bytes, bytearray)):
             return f"'{v.decode()}'"
         elif isinstance(v, Code):
             return v.code

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/bigquery.py

@@ -158,7 +158,7 @@ class Dialect(BaseDialect):
         return tuple(i for i in path if i is not None)
 
     def md5_as_int(self, s: str) -> str:
-        return f"cast(cast( ('0x' || substr(TO_HEX(md5({s})), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS})) as int64) as numeric) - {CHECKSUM_OFFSET}"
+        return f"cast(cast( ('0x' || substr(TO_HEX(md5({s})), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS})) as int64) as numeric) - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"
@@ -189,9 +189,7 @@ class Dialect(BaseDialect):
             return f"FORMAT_TIMESTAMP('%F %H:%M:%E6S', {value})"
 
         timestamp6 = f"FORMAT_TIMESTAMP('%F %H:%M:%E6S', {value})"
-        return (
-            f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS+coltype.precision}), {TIMESTAMP_PRECISION_POS+6}, '0')"
-        )
+        return f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS + coltype.precision}), {TIMESTAMP_PRECISION_POS + 6}, '0')"
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         return f"format('%.{coltype.precision}f', {value})"

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/databricks.py

@@ -85,7 +85,7 @@ class Dialect(BaseDialect):
         return tuple(i for i in path if i is not None)
 
     def md5_as_int(self, s: str) -> str:
-        return f"cast(conv(substr(md5({s}), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}), 16, 10) as decimal(38, 0)) - {CHECKSUM_OFFSET}"
+        return f"cast(conv(substr(md5({s}), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}), 16, 10) as decimal(38, 0)) - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/duckdb.py

@@ -97,7 +97,7 @@ class Dialect(BaseDialect):
         return "current_timestamp"
 
     def md5_as_int(self, s: str) -> str:
-        return f"('0x' || SUBSTRING(md5({s}), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS},{CHECKSUM_HEXDIGITS}))::BIGINT - {CHECKSUM_OFFSET}"
+        return f"('0x' || SUBSTRING(md5({s}), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS},{CHECKSUM_HEXDIGITS}))::BIGINT - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"
@@ -105,9 +105,9 @@ class Dialect(BaseDialect):
     def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
         # It's precision 6 by default. If precision is less than 6 -> we remove the trailing numbers.
         if coltype.rounds and coltype.precision > 0:
-            return f"CONCAT(SUBSTRING(STRFTIME({value}::TIMESTAMP, '%Y-%m-%d %H:%M:%S.'),1,23), LPAD(((ROUND(strftime({value}::timestamp, '%f')::DECIMAL(15,7)/100000,{coltype.precision-1})*100000)::INT)::VARCHAR,6,'0'))"
+            return f"CONCAT(SUBSTRING(STRFTIME({value}::TIMESTAMP, '%Y-%m-%d %H:%M:%S.'),1,23), LPAD(((ROUND(strftime({value}::timestamp, '%f')::DECIMAL(15,7)/100000,{coltype.precision - 1})*100000)::INT)::VARCHAR,6,'0'))"
 
-        return f"rpad(substring(strftime({value}::timestamp, '%Y-%m-%d %H:%M:%S.%f'),1,{TIMESTAMP_PRECISION_POS+coltype.precision}),26,'0')"
+        return f"rpad(substring(strftime({value}::timestamp, '%Y-%m-%d %H:%M:%S.%f'),1,{TIMESTAMP_PRECISION_POS + coltype.precision}),26,'0')"
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         return self.to_string(f"{value}::DECIMAL(38, {coltype.precision})")
@@ -115,6 +115,11 @@ class Dialect(BaseDialect):
     def normalize_boolean(self, value: str, _coltype: Boolean) -> str:
         return self.to_string(f"{value}::INTEGER")
 
+    def type_repr(self, t) -> str:
+        if isinstance(t, TimestampTZ):
+            return "TIMESTAMP WITH TIME ZONE"
+        return super().type_repr(t)
+
 
 @attrs.define(frozen=False, init=False, kw_only=True)
 class DuckDB(Database):
@@ -166,16 +171,15 @@ class DuckDB(Database):
     def select_table_schema(self, path: DbPath) -> str:
         database, schema, table = self._normalize_table_path(path)
 
-        info_schema_path = ["information_schema", "columns"]
-
-        if database:
-            info_schema_path.insert(0, database)
-            dynamic_database_clause = f"'{database}'"
-        else:
-            dynamic_database_clause = "current_catalog()"
+        # Newer DuckDB rejects the <catalog>.information_schema.columns three
+        # part form that older versions accepted. Query the unqualified
+        # information_schema.columns view which already returns rows for every
+        # attached catalog and scope it with table_catalog.
+        dynamic_database_clause = f"'{database}'" if database else "current_catalog()"
 
         return (
-            f"SELECT column_name, data_type, datetime_precision, numeric_precision, numeric_scale FROM {'.'.join(info_schema_path)} "
+            "SELECT column_name, data_type, datetime_precision, numeric_precision, numeric_scale "
+            "FROM information_schema.columns "
             f"WHERE table_name = '{table}' AND table_schema = '{schema}' and table_catalog = {dynamic_database_clause}"
         )
 

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/mysql.py

@@ -100,7 +100,7 @@ class Dialect(BaseDialect):
         return "SET @@session.time_zone='+00:00'"
 
     def md5_as_int(self, s: str) -> str:
-        return f"conv(substring(md5({s}), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}), 16, 10) - {CHECKSUM_OFFSET}"
+        return f"conv(substring(md5({s}), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}), 16, 10) - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"
@@ -110,7 +110,9 @@ class Dialect(BaseDialect):
             return self.to_string(f"cast( cast({value} as datetime({coltype.precision})) as datetime(6))")
 
         s = self.to_string(f"cast({value} as datetime(6))")
-        return f"RPAD(RPAD({s}, {TIMESTAMP_PRECISION_POS+coltype.precision}, '.'), {TIMESTAMP_PRECISION_POS+6}, '0')"
+        return (
+            f"RPAD(RPAD({s}, {TIMESTAMP_PRECISION_POS + coltype.precision}, '.'), {TIMESTAMP_PRECISION_POS + 6}, '0')"
+        )
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         return self.to_string(f"cast({value} as decimal(38, {coltype.precision}))")

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/oracle.py

@@ -128,7 +128,7 @@ class Dialect(
     def md5_as_int(self, s: str) -> str:
         # standard_hash is faster than DBMS_CRYPTO.Hash
         # TODO: Find a way to use UTL_RAW.CAST_TO_BINARY_INTEGER ?
-        return f"to_number(substr(standard_hash({s}, 'MD5'), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}), 'xxxxxxxxxxxxxxx') - {CHECKSUM_OFFSET}"
+        return f"to_number(substr(standard_hash({s}, 'MD5'), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}), 'xxxxxxxxxxxxxxx') - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"standard_hash({s}, 'MD5')"
@@ -145,7 +145,7 @@ class Dialect(
             truncated = f"to_char({value}, 'YYYY-MM-DD HH24:MI:SS.FF{coltype.precision}')"
         else:
             truncated = f"to_char({value}, 'YYYY-MM-DD HH24:MI:SS.')"
-        return f"RPAD({truncated}, {TIMESTAMP_PRECISION_POS+6}, '0')"
+        return f"RPAD({truncated}, {TIMESTAMP_PRECISION_POS + 6}, '0')"
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         # FM999.9990

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/postgresql.py

@@ -105,14 +105,14 @@ class PostgresqlDialect(BaseDialect):
         return super().type_repr(t)
 
     def md5_as_int(self, s: str) -> str:
-        return f"('x' || substring(md5({s}), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}))::bit({_CHECKSUM_BITSIZE})::bigint - {CHECKSUM_OFFSET}"
+        return f"('x' || substring(md5({s}), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}))::bit({_CHECKSUM_BITSIZE})::bigint - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"
 
     def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
         def _add_padding(coltype: TemporalType, timestamp6: str):
-            return f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS+coltype.precision}), {TIMESTAMP_PRECISION_POS+6}, '0')"
+            return f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS + coltype.precision}), {TIMESTAMP_PRECISION_POS + 6}, '0')"
 
         try:
             is_date = coltype.is_date
@@ -143,7 +143,7 @@ class PostgresqlDialect(BaseDialect):
             timestamp = f"least('{max_timestamp}'::timestamp(6), {value}::timestamp(6))"
             timestamp = f"greatest('{min_timestamp}'::timestamp(6), {timestamp})"
 
-            interval = format((0.5 * (10 ** (-coltype.precision))), f".{coltype.precision+1}f")
+            interval = format((0.5 * (10 ** (-coltype.precision))), f".{coltype.precision + 1}f")
 
             rounded_timestamp = (
                 f"left(to_char(least('{max_timestamp}'::timestamp, {timestamp})"
@@ -223,7 +223,7 @@ class PostgreSQL(ThreadedDatabase):
                             THEN coalesce(numeric_scale, {self.dialect.DEFAULT_NUMERIC_PRECISION})
                         ELSE numeric_scale
                     END AS numeric_scale
-                    FROM {'.'.join(info_schema_path)}
+                    FROM {".".join(info_schema_path)}
                     WHERE table_name = '{table}' AND table_schema = '{schema}'
             """
 

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/presto.py

@@ -113,13 +113,18 @@ class Dialect(BaseDialect):
         return super().parse_type(table_path, info)
 
     def set_timezone_to_utc(self) -> str:
-        return "SET TIME ZONE '+00:00'"
+        # PrestoDB has no SQL command to change the session timezone and no
+        # timezone session property. The session timezone is fixed at connect
+        # time. Raise so the connection setup logs and moves on, matching the
+        # base class pattern for databases without session timezone support.
+        # The Trino dialect overrides this since Trino does have SET TIME ZONE.
+        raise NotImplementedError("No support for session tz.")
 
     def current_timestamp(self) -> str:
         return "current_timestamp"
 
     def md5_as_int(self, s: str) -> str:
-        return f"cast(from_base(substr(to_hex(md5(to_utf8({s}))), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}), 16) as decimal(38, 0)) - {CHECKSUM_OFFSET}"
+        return f"cast(from_base(substr(to_hex(md5(to_utf8({s}))), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}), 16) as decimal(38, 0)) - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"to_hex(md5(to_utf8({s})))"
@@ -129,13 +134,15 @@ class Dialect(BaseDialect):
         return f"TRIM(CAST({value} AS VARCHAR))"
 
     def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
-        # TODO rounds
-        if coltype.rounds:
-            s = f"date_format(cast({value} as timestamp(6)), '%Y-%m-%d %H:%i:%S.%f')"
-        else:
-            s = f"date_format(cast({value} as timestamp(6)), '%Y-%m-%d %H:%i:%S.%f')"
-
-        return f"RPAD(RPAD({s}, {TIMESTAMP_PRECISION_POS+coltype.precision}, '.'), {TIMESTAMP_PRECISION_POS+6}, '0')"
+        # PrestoDB has no parameterized TIMESTAMP(p) type, only plain TIMESTAMP
+        # which is fixed at millisecond precision. Casting to TIMESTAMP(6) here
+        # fails with "Unknown type: timestamp(6)" on real PrestoDB even though
+        # Trino accepts it. The Trino dialect provides its own precision aware
+        # override so this only affects PrestoDB.
+        s = f"date_format(cast({value} as timestamp), '%Y-%m-%d %H:%i:%S.%f')"
+        return (
+            f"RPAD(RPAD({s}, {TIMESTAMP_PRECISION_POS + coltype.precision}, '.'), {TIMESTAMP_PRECISION_POS + 6}, '0')"
+        )
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         return self.to_string(f"cast({value} as decimal(38,{coltype.precision}))")
@@ -197,4 +204,8 @@ class Presto(Database):
 
     @property
     def is_autocommit(self) -> bool:
-        return False
+        # PrestoDB and Trino both run every statement in autocommit mode by
+        # default, with no implicit transaction. Emitting a bare COMMIT then
+        # fails with NOT_IN_TRANSACTION. Telling the base dialect that we are
+        # autocommit makes render_commit a no op so the COMMIT is never sent.
+        return True

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/redshift.py

@@ -50,7 +50,7 @@ class Dialect(PostgresqlDialect):
         return super().type_repr(t)
 
     def md5_as_int(self, s: str) -> str:
-        return f"strtol(substring(md5({s}), {1+MD5_HEXDIGITS-CHECKSUM_HEXDIGITS}), 16)::decimal(38) - {CHECKSUM_OFFSET}"
+        return f"strtol(substring(md5({s}), {1 + MD5_HEXDIGITS - CHECKSUM_HEXDIGITS}), 16)::decimal(38) - {CHECKSUM_OFFSET}"
 
     def md5_as_hex(self, s: str) -> str:
         return f"md5({s})"

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/trino.py

@@ -3,7 +3,7 @@ from typing import Any, ClassVar, Type
 import attrs
 from requests import Session
 
-from data_diff.abcs.database_types import TemporalType, ColType_UUID
+from data_diff.abcs.database_types import TemporalType, TimestampTZ, ColType_UUID
 from data_diff.databases import presto
 from data_diff.databases.base import import_helper
 from data_diff.databases.base import TIMESTAMP_PRECISION_POS, BaseDialect
@@ -19,12 +19,29 @@ def import_trino():
 class Dialect(presto.Dialect):
     name = "Trino"
 
-    def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
-        if coltype.rounds:
-            s = f"date_format(cast({value} as timestamp({coltype.precision})), '%Y-%m-%d %H:%i:%S.%f')"
-        else:
-            s = f"date_format(cast({value} as timestamp(6)), '%Y-%m-%d %H:%i:%S.%f')"
+    def set_timezone_to_utc(self) -> str:
+        # Trino has its own statement form that PrestoDB does not accept.
+        return "SET TIME ZONE 'UTC'"
+
+    def type_repr(self, t) -> str:
+        # The base dialect emits TIMESTAMP(p) for TimestampTZ, which Trino
+        # interprets as TIMESTAMP WITHOUT TIME ZONE. That silently drops the
+        # offset on insert, so be explicit and emit TIMESTAMP(p) WITH TIME ZONE.
+        if isinstance(t, TimestampTZ):
+            return f"TIMESTAMP({t.precision}) WITH TIME ZONE"
+        return super().type_repr(t)
 
+    def normalize_timestamp(self, value: str, coltype: TemporalType) -> str:
+        # Trino's date_format truncates fractional seconds to millisecond
+        # precision and loses any trailing microseconds. Casting the value to
+        # TIMESTAMP(p) and then to VARCHAR keeps the full precision. For
+        # TIMESTAMP WITH TIME ZONE columns the cast would preserve the source
+        # offset instead of using the session timezone, so apply
+        # AT TIME ZONE 'UTC' first to normalize.
+        inner_prec = coltype.precision if coltype.rounds else 6
+        if isinstance(coltype, TimestampTZ):
+            value = f"({value}) AT TIME ZONE 'UTC'"
+        s = f"CAST(CAST({value} AS TIMESTAMP({inner_prec})) AS VARCHAR)"
         return (
             f"RPAD(RPAD({s}, {TIMESTAMP_PRECISION_POS + coltype.precision}, '.'), {TIMESTAMP_PRECISION_POS + 6}, '0')"
         )
@@ -58,20 +75,15 @@ class Trino(presto.Presto):
 
         if auth:
             if auth.get("authType") == "basic":
-                kw["auth"] = trino.auth.BasicAuthentication(
-                    auth.get("username"),
-                    auth.get("password")
-                )
+                kw["auth"] = trino.auth.BasicAuthentication(auth.get("username"), auth.get("password"))
                 kw["http_scheme"] = "https"
 
             elif auth.get("authType") == "jwt":
-                kw["auth"] = trino.auth.JWTAuthentication(
-                    auth.get("jwt")
-                )
+                kw["auth"] = trino.auth.JWTAuthentication(auth.get("jwt"))
                 kw["http_scheme"] = "https"
 
             elif auth.get("authType") == "oauth2":
                 kw["auth"] = trino.auth.OAuth2Authentication()
                 kw["http_scheme"] = "https"
-                
+
         self._conn = trino.dbapi.connect(**kw)

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/databases/vertica.py

@@ -114,9 +114,7 @@ class Dialect(BaseDialect):
             return f"TO_CHAR({value}::TIMESTAMP({coltype.precision}), 'YYYY-MM-DD HH24:MI:SS.US')"
 
         timestamp6 = f"TO_CHAR({value}::TIMESTAMP(6), 'YYYY-MM-DD HH24:MI:SS.US')"
-        return (
-            f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS+coltype.precision}), {TIMESTAMP_PRECISION_POS+6}, '0')"
-        )
+        return f"RPAD(LEFT({timestamp6}, {TIMESTAMP_PRECISION_POS + coltype.precision}), {TIMESTAMP_PRECISION_POS + 6}, '0')"
 
     def normalize_number(self, value: str, coltype: FractionalType) -> str:
         return self.to_string(f"CAST({value} AS NUMERIC(38, {coltype.precision}))")
@@ -128,6 +126,17 @@ class Dialect(BaseDialect):
     def normalize_boolean(self, value: str, _coltype: Boolean) -> str:
         return self.to_string(f"cast ({value} as int)")
 
+    def timestamp_value(self, t) -> str:
+        # In the UNION ALL SELECT path emitted by constant_values, Vertica
+        # refuses to implicitly cast a varchar to TIMESTAMP. Emit a typed
+        # literal so the value is unambiguously a TIMESTAMP everywhere.
+        return f"TIMESTAMP '{t.isoformat()}'"
+
+    def constant_values(self, rows) -> str:
+        # Vertica before 11.0 does not accept multi-row INSERT ... VALUES (a), (b), (c).
+        # Emit UNION ALL SELECT instead, which is accepted by every Vertica version.
+        return " UNION ALL ".join("SELECT " + ", ".join(self._constant_value(v) for v in row) for row in rows)
+
 
 @attrs.define(frozen=False, init=False, kw_only=True)
 class Vertica(ThreadedDatabase):

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/dbt.py

@@ -116,9 +116,10 @@ def dbt_diff(
 
     futures = {}
 
-    with log_status_handler.status if log_status_handler else nullcontext(), ThreadPoolExecutor(
-        max_workers=dbt_parser.threads
-    ) as executor:
+    with (
+        log_status_handler.status if log_status_handler else nullcontext(),
+        ThreadPoolExecutor(max_workers=dbt_parser.threads) as executor,
+    ):
         for model in models:
             if log_status_handler:
                 log_status_handler.set_prefix(f"Diffing {model.alias} \n")

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/dbt_config_validators.py

@@ -5,13 +5,13 @@ from pydantic import BaseModel, Field
 
 class ManifestJsonConfig(BaseModel):
     class Metadata(BaseModel):
-        dbt_version: str = Field(..., regex=r"^\d+\.\d+\.\d+([a-zA-Z0-9]+)?$")
-        project_id: Optional[str]
-        user_id: Optional[str]
+        dbt_version: str = Field(..., pattern=r"^\d+\.\d+\.\d+([a-zA-Z0-9]+)?$")
+        project_id: Optional[str] = None
+        user_id: Optional[str] = None
 
     class Nodes(BaseModel):
-        class Config(BaseModel):
-            database: Optional[str]
+        class NodeConfig(BaseModel):
+            database: Optional[str] = None
             schema_: Optional[str] = Field(..., alias="schema")
             tags: List[str]
 
@@ -31,13 +31,13 @@ class ManifestJsonConfig(BaseModel):
         resource_type: str
         name: str
         alias: str
-        database: Optional[str]
+        database: Optional[str] = None
         schema_: str = Field(..., alias="schema")
-        columns: Optional[Dict[str, Column]]
+        columns: Optional[Dict[str, Column]] = None
         meta: Dict[str, Any]
-        config: Config
+        config: NodeConfig
         tags: List[str]
-        test_metadata: Optional[TestMetadata]
+        test_metadata: Optional[TestMetadata] = None
         depends_on: DependsOn
 
     metadata: Metadata
@@ -46,7 +46,7 @@ class ManifestJsonConfig(BaseModel):
 
 class RunResultsJsonConfig(BaseModel):
     class Metadata(BaseModel):
-        dbt_version: str = Field(..., regex=r"^\d+\.\d+\.\d+([a-zA-Z0-9]+)?$")
+        dbt_version: str = Field(..., pattern=r"^\d+\.\d+\.\d+([a-zA-Z0-9]+)?$")
 
     class Results(BaseModel):
         class Status(Enum):

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/dbt_parser.py

@@ -252,7 +252,7 @@ class DbtParser:
         with open(self.project_dir / RUN_RESULTS_PATH) as run_results:
             logger.info(f"Parsing file {RUN_RESULTS_PATH}")
             run_results_dict = json.load(run_results)
-        run_results_validated = RunResultsJsonConfig.parse_obj(run_results_dict)
+        run_results_validated = RunResultsJsonConfig.model_validate(run_results_dict)
 
         dbt_version = parse_version(run_results_validated.metadata.dbt_version)
 
@@ -279,7 +279,7 @@ class DbtParser:
         with open(path) as manifest:
             logger.info(f"Parsing file {path}")
             manifest_dict = json.load(manifest)
-            manifest_obj = ManifestJsonConfig.parse_obj(manifest_dict)
+            manifest_obj = ManifestJsonConfig.model_validate(manifest_dict)
         return manifest_obj
 
     def get_project_dict(self):

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/diff_tables.py

@@ -161,7 +161,7 @@ class DiffResultWrapper:
             string_output += f"{diff_stats.diff_by_sign['+']} rows exclusive to table B (not present in A)\n"
             string_output += f"{diff_stats.diff_by_sign['!']} rows updated\n"
             string_output += f"{diff_stats.unchanged} rows unchanged\n"
-            string_output += f"{100*diff_stats.diff_percent:.2f}% difference score\n"
+            string_output += f"{100 * diff_stats.diff_percent:.2f}% difference score\n"
 
             if self.stats:
                 string_output += "\nExtra-Info:\n"

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/parse_time.py

@@ -44,7 +44,7 @@ def parse_time_atom(count, unit):
     except KeyError:
         most_similar = max(TIME_UNITS, key=lambda k: string_similarity(k, unit))
         raise ParseError(
-            f"'{unit}' is not a recognized time unit. Did you mean '{most_similar}'?" f"\nSupported units: {UNITS_STR}"
+            f"'{unit}' is not a recognized time unit. Did you mean '{most_similar}'?\nSupported units: {UNITS_STR}"
         )
 
     if unit in EXTRAPOLATED:

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/data_diff/schema.py

@@ -47,6 +47,6 @@ def create_schema(db_name: str, table_path: DbPath, schema: dict, case_sensitive
         return CaseSensitiveDict(schema)
 
     if len({k.lower() for k in schema}) < len(schema):
-        logger.warning(f'Ambiguous schema for {db_name}:{".".join(table_path)} | Columns = {", ".join(list(schema))}')
+        logger.warning(f"Ambiguous schema for {db_name}:{'.'.join(table_path)} | Columns = {', '.join(list(schema))}")
         logger.warning("We recommend to disable case-insensitivity (set --case-sensitive).")
     return CaseInsensitiveDict(schema)

collate_data_diff-0.11.11/data_diff/version.py

@@ -0,0 +1 @@
+__version__ = "0.11.11"

{collate_data_diff-0.11.9 → collate_data_diff-0.11.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "collate-data-diff"
-version = "0.11.9"
+version = "0.11.11"
 description = "Command-line tool and Python library to efficiently diff rows across two different databases."
 authors = ["Collate <info@getcollate.io>", "Datafold <data-diff@datafold.com>"]
 license = "MIT"
@@ -21,10 +21,10 @@ classifiers = [
 ]
 packages = [{ include = "data_diff" }]
 [tool.poetry.dependencies]
-pydantic = ">=1.10.12"
+pydantic = ">=2.0,<3"
 python = ">=3.10,<4.0"
 dsnparse = "<0.2.0"
-click = ">=8.1"
+click = ">=8.3.3" # Security fix for CVE-2026-7246
 rich = "*"
 toml = ">=0.10.2"
 mysql-connector-python = [
@@ -33,9 +33,9 @@ mysql-connector-python = [
 ]
 psycopg2 = {version="*", optional=true}
 snowflake-connector-python = [
-    {version = ">=3.15.0,<4.0.0", python = ">=3.9", optional=true}
+    {version = ">=4.4.0,<5.0.0", python = ">=3.10", optional=true}
 ]
-cryptography = {version="*", optional=true}
+cryptography = {version=">=46.0.5", optional=true} # Security fix for CVE-2026-26007
 trino = {version=">=0.314.0", optional=true}
 presto-python-client = {version="*", optional=true}
 clickhouse-driver = {version="*", optional=true}
@@ -46,7 +46,7 @@ keyring = "*"
 tabulate = ">=0.9.0"
 preql = {version=">=0.2.19", optional=true}
 vertica-python = {version="*", optional=true}
-urllib3 = "<2"
+urllib3 = ">=2.7.0,<3" # Security fix for CVE-2026-44431, CVE-2026-21441, CVE-2025-66418, CVE-2025-66471
 oracledb = {version = "*", optional=true}
 pyodbc = {version=">=4.0.39", optional=true}
 typing-extensions = ">=4.0.1"
@@ -84,9 +84,9 @@ mysql-connector-python = [
 ]
 psycopg2 = "*"
 snowflake-connector-python = [
-    {version=">=3.13.1,<4.0.0", python = ">=3.9"}
+    {version=">=4.4.0,<5.0.0", python = ">=3.10"}
 ]
-cryptography = "*"
+cryptography = ">=46.0.5" # Security fix for CVE-2026-26007
 trino = ">=0.314.0"
 presto-python-client = ">=0.8.3"
 clickhouse-driver = "*"

collate_data_diff-0.11.9/data_diff/version.py

@@ -1 +0,0 @@
-__version__ = "0.11.1"