dblift 3.2.0__tar.gz → 3.3.0__tar.gz

{dblift-3.2.0 → dblift-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.2.0
+Version: 3.3.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{dblift-3.2.0 → dblift-3.3.0}/core/introspection/_column_enricher.py

@@ -16,7 +16,7 @@ The two helpers take the introspector instance as their first parameter
 from __future__ import annotations
 
 import traceback
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Any, List
 
 if TYPE_CHECKING:
     from core.introspection.schema_introspector import SchemaIntrospector
@@ -253,18 +253,101 @@ def enrich_columns_with_identity(
                     ),
                 }
 
+        # sql_variant columns (e.g. SQL Server's
+        # sys.identity_columns.seed_value/increment_value/last_value) can
+        # arrive via pymssql/FreeTDS as raw on-wire bytes rather than an int
+        # (e.g. the int 1 as b'\x01\x00\x00\x00'). Normalize those to a plain
+        # int here so every downstream consumer -- regardless of which
+        # dialect's driver quirks produced the raw value -- can rely on
+        # identity_seed/identity_increment/identity_last_value already being
+        # an int. Non-bytes values (str, int, None) pass through unchanged,
+        # exactly as before.
+        #
+        # Bytes are only decoded when their length matches a standard
+        # two's-complement integer width (1, 2, 4, or 8 bytes --
+        # tinyint/smallint/int/bigint). SQL Server also permits IDENTITY on
+        # decimal/numeric columns, whose sql_variant wire shape is a sign
+        # byte plus an *unsigned* magnitude -- not a plain two's-complement
+        # integer -- so decoding those the same way would silently produce a
+        # plausible-looking but wrong value. For any other byte length,
+        # refuse to guess and raise instead; the outer try/except around
+        # this whole enrichment pass logs a warning for it.
+        def _decode_sql_variant_int(column_name: str, field_name: str, value: Any) -> Any:
+            if not isinstance(value, bytes):
+                return value
+            if len(value) not in (1, 2, 4, 8):
+                raise ValueError(
+                    f"Column {column_name!r}: {field_name} arrived as "
+                    f"{len(value)} raw bytes, which is not a standard "
+                    f"two's-complement integer width (1, 2, 4, or 8 bytes). "
+                    f"This looks like a non-integer sql_variant encoding "
+                    f"(e.g. decimal/numeric IDENTITY) that isn't supported yet."
+                )
+            return int.from_bytes(value, byteorder="little", signed=True)
+
         # Enrich matching columns with detailed metadata
         for column in columns:
             identity_data = identity_map.get(column.name.upper())
             if identity_data:
-                # Mark as identity (may already be marked from the column query)
+                # Mark as identity (may already be marked from the column
+                # query) for now -- the except block below reverts this if
+                # decoding seed OR increment fails, since a column whose real
+                # identity parameters we can't decode must not still claim
+                # is_identity (see that block for why). last_value is decoded
+                # separately below and its failure does NOT revert this: it
+                # has no downstream DDL consumer, so losing it carries none
+                # of the "silently wrong seed/increment" risk the reset here
+                # exists to guard against.
                 column.is_identity = True
-                # Add detailed metadata
-                column.identity_seed = identity_data["seed_value"]
-                column.identity_increment = identity_data["increment_value"]
-                # Note: last_value is not part of SQL Model, store as custom attribute if needed
-                if identity_data["last_value"] is not None:
-                    column.identity_last_value = identity_data["last_value"]  # type: ignore[attr-defined]
+                # A decode failure (see _decode_sql_variant_int above) is
+                # isolated to THIS column, not the whole table: without this,
+                # one decimal/numeric-typed IDENTITY column sitting alongside
+                # ordinary int-typed ones would raise past this loop into the
+                # table-level except below, silently losing seed/increment/
+                # last_value for every column processed after it too -- a
+                # wider blast radius than the single bad column the raise is
+                # actually about.
+                try:
+                    # Add detailed metadata
+                    column.identity_seed = _decode_sql_variant_int(
+                        column.name, "seed_value", identity_data["seed_value"]
+                    )
+                    column.identity_increment = _decode_sql_variant_int(
+                        column.name, "increment_value", identity_data["increment_value"]
+                    )
+                except ValueError as decode_error:
+                    si.log.warning(
+                        f"Could not decode identity metadata for column "
+                        f"{column.name!r} in {schema}.{table}: {decode_error}"
+                    )
+                    # A decode failure means we cannot reliably tell "seed
+                    # decoded fine, increment failed" apart from "failed
+                    # immediately" -- either way, downstream DDL rendering
+                    # must not mistake a leftover None for "never asked, use
+                    # SQL Server's own default". Reset is_identity and the
+                    # two fields render_identity_clause reads so the column
+                    # falls out of identity handling entirely rather than
+                    # rendering a guessed IDENTITY(1,1).
+                    column.is_identity = False
+                    column.identity_seed = None
+                    column.identity_increment = None
+                else:
+                    # seed/increment decoded fine -- only now attempt
+                    # last_value, in its own try/except so that a
+                    # last_value-only decode failure (e.g. a non-standard
+                    # byte width) doesn't discard the good seed/increment we
+                    # just stored. Note: last_value is not part of SQL Model,
+                    # store as custom attribute if needed.
+                    if identity_data["last_value"] is not None:
+                        try:
+                            column.identity_last_value = _decode_sql_variant_int(  # type: ignore[attr-defined]
+                                column.name, "last_value", identity_data["last_value"]
+                            )
+                        except ValueError as decode_error:
+                            si.log.warning(
+                                f"Could not decode identity metadata for column "
+                                f"{column.name!r} in {schema}.{table}: {decode_error}"
+                            )
 
         if identity_map:
             si.log.debug(

{dblift-3.2.0 → dblift-3.3.0}/core/introspection/base_introspector.py

@@ -387,19 +387,21 @@ class BaseIntrospector:
         # Delegate to index extractor
         return self._get_index_extractor().get_indexes(schema, table)
 
-    def get_all_indexes(self, schema: str) -> List[Index]:
+    def get_all_indexes(self, schema: str) -> Optional[List[Index]]:
         """
         Get all indexes for an entire schema in a single bulk query.
 
-        Delegates to IndexExtractor.get_all_indexes. Returns an empty list
-        if the dialect does not support bulk index retrieval.
+        Delegates to IndexExtractor.get_all_indexes and propagates its
+        three-way answer unchanged.
 
         Args:
             schema: Schema name
 
         Returns:
-            List of Index objects for the entire schema, or [] if the dialect
-            does not support bulk retrieval.
+            ``None`` if the dialect cannot answer in bulk, meaning the caller
+            must fall back to per-table retrieval. ``[]`` if the bulk query ran
+            and the schema genuinely has no indexes. Otherwise the list of
+            Index objects for the entire schema.
         """
         return self._get_index_extractor().get_all_indexes(schema)
 

{dblift-3.2.0 → dblift-3.3.0}/core/introspection/extractors/index_extractor.py

@@ -1,6 +1,6 @@
 """Index extraction from plugin-owned vendor metadata queries."""
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from core.introspection.extractors.base_extractor import BaseExtractor
 from core.sql_model.index import Index
@@ -42,7 +42,7 @@ class IndexExtractor(BaseExtractor):
         # Convert to Index objects
         return self._build_index_objects(schema, table, indexes_data)
 
-    def get_all_indexes(self, schema: str) -> List[Index]:
+    def get_all_indexes(self, schema: str) -> Optional[List[Index]]:
         """
         Get all indexes for an entire schema.
 
@@ -52,17 +52,25 @@ class IndexExtractor(BaseExtractor):
             schema: Schema name
 
         Returns:
-            List of Index objects for the entire schema
+            ``None`` if bulk retrieval is unavailable — either no vendor
+            queries exist for the dialect, or its bulk index query declines —
+            meaning the caller must ask table by table.  ``[]`` if the bulk
+            query ran and the schema genuinely has no indexes.  Otherwise the
+            list of Index objects for the entire schema.
         """
+        # Unlike ColumnExtractor and TableExtractor.get_tables, which raise
+        # RuntimeError when their query is unavailable, this refuses with
+        # None: those two have no fallback, so refusing is the only honest
+        # option, whereas a working per-table path exists here and None routes
+        # the caller to it.  Raising would break callers that legitimately
+        # have that fallback.
         if not self.vendor_queries:
-            return []
+            return None
 
         self.ensure_metadata()
         query_result = self.vendor_queries.get_all_indexes_query(schema)
         if query_result is None:
-            return (
-                []
-            )  # no bulk query; empty for this test path (per-table fallback would be used by callers)
+            return None
 
         query, params = query_result
         rows = self.provider.query_executor.execute_query(self.connection, query, params)

dblift-3.3.0/core/seams/feature_loading.py

@@ -0,0 +1,109 @@
+"""Load ``dblift.features`` entry points (tier feature registration).
+
+Each ``dblift.features`` entry point resolves to a no-arg callable that
+performs registrations against the neutral seams
+(:mod:`core.seams.runtime_checks`, :mod:`core.seams.tier_resolver`, ...).
+OSS ships none; installed higher tiers register their runtime checks and
+tier resolver here.
+
+Loading is idempotent via a module-level once-flag: entry points do not
+change at runtime, and both CLI startup and API-client construction invoke
+:func:`load_feature_extensions`, so double-loading is expected and cheap. An
+empty entry-point result latches immediately unless a known tier
+distribution (``dblift-pro``/``dblift-enterprise``) is installed but its
+entry point hasn't reached this process's metadata view yet, in which case
+it is retried on a later call instead of latched.
+
+``DBLIFT_DISABLE_CLI_EXTENSIONS=1`` skips feature loading entirely. This is
+an accepted, explicit operator opt-out: with higher-tier packages installed
+it also disables their registered runtime checks and tier resolution for
+API usage in the same process.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Callable
+from importlib.metadata import PackageNotFoundError, entry_points, version
+from typing import Protocol
+
+_log = logging.getLogger(__name__)
+
+FEATURE_ENTRY_POINT_GROUP = "dblift.features"
+
+# Feature registrations load in tier order (pro before enterprise, unknown
+# third parties in between, name as the tie-breaker) — the same ordering
+# contract as cli/extensions.py's command-extension loaders.
+_TIER_LOAD_ORDER = {"pro": 0, "enterprise": 2}
+_DEFAULT_TIER_LOAD_ORDER = 1
+
+_features_loaded = False
+
+# Must be updated if a tier package's distribution name changes in the
+# monorepo, or a new tier is added under a different name -- an unlisted
+# distribution is indistinguishable here from "not installed", so
+# _any_tier_distribution_installed silently reverts to the pre-fix
+# never-retries behavior for it.
+_KNOWN_TIER_DISTRIBUTIONS = ("dblift-pro", "dblift-enterprise")
+
+
+def _any_tier_distribution_installed() -> bool:
+    """Whether a known paid-tier package is installed as a distribution.
+
+    Checked independently of whether its ``dblift.features`` entry point has
+    become visible yet in this process's ``importlib.metadata`` view -- this
+    is what distinguishes "no dblift.features entry point will ever exist"
+    (pure OSS, no tier package installed at all -- the ordinary case) from
+    "one exists but hasn't reached this process's view of the metadata yet"
+    (the documented race an empty ``entry_points()`` result alone can't
+    rule out).
+    """
+    for name in _KNOWN_TIER_DISTRIBUTIONS:
+        try:
+            version(name)
+        except PackageNotFoundError:
+            continue
+        except Exception as exc:  # a broken distribution must not break startup
+            _log.warning("Could not check whether %r is installed: %s", name, exc)
+            continue
+        return True
+    return False
+
+
+class _FeatureEntryPoint(Protocol):
+    name: str
+
+    def load(self) -> Callable[[], object]:
+        pass
+
+
+def load_feature_extensions() -> None:
+    """Load every ``dblift.features`` entry point (idempotent, best-effort)."""
+    global _features_loaded
+    if _features_loaded or os.environ.get("DBLIFT_DISABLE_CLI_EXTENSIONS") == "1":
+        return
+    discovered_by_name: dict[str, _FeatureEntryPoint] = {
+        entry_point.name: entry_point
+        for entry_point in entry_points(group=FEATURE_ENTRY_POINT_GROUP)
+    }
+    ordered = sorted(
+        discovered_by_name.values(),
+        key=lambda ep: (_TIER_LOAD_ORDER.get(ep.name, _DEFAULT_TIER_LOAD_ORDER), ep.name),
+    )
+    for entry_point in ordered:
+        try:
+            register = entry_point.load()
+            register()
+        except Exception as exc:  # a bad plugin must not break startup
+            _log.warning("dblift.features '%s' failed to load: %s", entry_point.name, exc)
+    # Latch when something was actually found, OR when nothing was found but
+    # no tier package is installed at all -- an empty result is only the
+    # documented race (a paid package's dblift.features entry point not yet
+    # reaching this process's importlib.metadata view, needing a retry on a
+    # later call, exactly like the identical latch bug fixed in
+    # AlterGeneratorFactory._ensure_populated) when a tier distribution is
+    # actually installed. In pure OSS, with no tier package installed,
+    # OSS's own pyproject.toml declares the entry-points group empty, so an
+    # empty result is permanent and must latch immediately.
+    _features_loaded = bool(ordered) or not _any_tier_distribution_installed()

{dblift-3.2.0 → dblift-3.3.0}/core/seams/sql_generators.py

@@ -35,7 +35,7 @@ def attach_registered_sql_generators() -> None:
 def clear_sql_generator_registrars() -> None:
     """Test hook."""
     global _bootstrapped
-    import core.seams.feature_loading as feature_loading
+    from core.seams import feature_loading
 
     _registrars.clear()
     _bootstrapped = False

{dblift-3.2.0 → dblift-3.3.0}/core/sql_generator/alter/alter_generator_factory.py

@@ -46,7 +46,8 @@ class AlterGeneratorFactory:
         load_feature_extensions()
         attach_registered_sql_generators()
         ProviderRegistry.discover_plugins()
-        for plugin_info in ProviderRegistry.list_plugins():
+        plugin_list = ProviderRegistry.list_plugins()
+        for plugin_info in plugin_list:
             # Per-plugin fault isolation: a broken plugin must not
             # prevent the others from registering. (PR #241 Bugbot.)
             try:
@@ -62,7 +63,14 @@ class AlterGeneratorFactory:
                     plugin_info.name,
                     exc,
                 )
-        cls._populated = True
+        # Latch only when plugin discovery itself found something. An empty
+        # ``plugin_list`` is the documented race (entry points not yet wired
+        # up in this process) and must be retried on a later call. A
+        # non-empty ``plugin_list`` means discovery genuinely completed --
+        # even if every plugin's quirks raised or returned no ALTER
+        # generator class, that is a real, stable outcome and should latch
+        # rather than re-running full discovery on every subsequent call.
+        cls._populated = bool(plugin_list)
 
     @classmethod
     def create_generator(cls, dialect: str) -> BaseAlterGenerator:

{dblift-3.2.0 → dblift-3.3.0}/core/sql_model/view.py

@@ -298,7 +298,7 @@ class View(SqlObject):
         Returns:
             Dictionary with view attributes
         """
-        result = {
+        result: Dict[str, Any] = {
             "name": self.name,
             "schema": self.schema,
             "object_type": self.object_type.value,

{dblift-3.2.0 → dblift-3.3.0}/db/base_quirks.py

@@ -435,9 +435,15 @@ class BaseQuirks:
     #: Oracle requires ``FROM DUAL``.
     connection_probe_sql: str = "SELECT 1"
     #: ``SELECT … LIMIT N`` syntax is supported. PostgreSQL, MySQL and
-    #: SQLite accept ``LIMIT``; Oracle (``FETCH FIRST N ROWS ONLY``)
-    #: and DB2 (``FETCH FIRST N ROWS ONLY``) do not; SQL Server uses
-    #: ``TOP N`` instead. When False, post-commit verification queries
+    #: SQLite accept ``LIMIT``; Oracle (``FETCH FIRST N ROWS ONLY``) does
+    #: not; SQL Server uses ``TOP N`` instead. DB2's *preferred* rendering
+    #: is also ``FETCH FIRST N ROWS ONLY`` (see :attr:`row_limit_style`),
+    #: but DB2 additionally accepts a bare trailing ``LIMIT`` clause —
+    #: verified against a live db2 12.01.0500 server via the
+    #: capability-probe integration test
+    #: (``tests/integration/capabilities/test_engine_capabilities.py``) —
+    #: so it sets this True even though its declared ``row_limit_style``
+    #: is not ``"limit"``. When False, post-commit verification queries
     #: and similar probes omit the ``LIMIT`` clause.
     select_supports_limit: bool = True
     #: How a SELECT is bounded to N rows. One of:
@@ -461,12 +467,16 @@ class BaseQuirks:
     #: Read through :meth:`row_limit_clauses`, which renders the triple
     #: rather than making each caller re-derive the syntax. Distinct from
     #: :attr:`select_supports_limit`, which answers the coarser "may I
-    #: append ``LIMIT`` at all" question for optional probes — but the two
-    #: overlap in practice: every dialect that sets a non-default
-    #: ``row_limit_style`` (SQL Server, Oracle, DB2) also sets
-    #: ``select_supports_limit = False``, because none of them accept a bare
-    #: trailing ``LIMIT`` either. Nothing in the framework enforces that the
-    #: two stay consistent, so a new dialect could set one without the other;
+    #: append ``LIMIT`` at all" question for optional probes — the two
+    #: usually correlate (SQL Server and Oracle, which set a non-default
+    #: ``row_limit_style``, also set ``select_supports_limit = False``,
+    #: since neither accepts a bare trailing ``LIMIT``) but they are NOT
+    #: guaranteed to: DB2 is a documented exception — it declares
+    #: ``row_limit_style = "fetch_first"`` as its preferred rendering yet
+    #: sets ``select_supports_limit = True`` because the live engine also
+    #: accepts a bare trailing ``LIMIT`` (verified via the capability-probe
+    #: integration test). Nothing in the framework enforces that the two
+    #: stay consistent, so a new dialect could set one without the other;
     #: see the invariant test in ``tests/unit/db/test_dialect_capability_quirks.py``.
     row_limit_style: str = "limit"
     #: How an "insert or update on primary-key conflict" is expressed.

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/cosmosdb/cosmosdb/history_manager.py

@@ -419,7 +419,7 @@ class CosmosDbHistoryManager(DocumentHistoryManager):
         # row: a point delete addressed by the wrong partition key returns 404,
         # which would read as "already deleted" and remove nothing.
         query = "SELECT c.id, c.script, c.success, c.version FROM c WHERE c.script = @script"
-        parameters = [{"name": "@script", "value": script_name}]
+        parameters: List[Dict[str, object]] = [{"name": "@script", "value": script_name}]
         try:
             failed_docs = [
                 doc

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/cosmosdb/cosmosdb/query_executor.py

@@ -3,12 +3,15 @@ Cosmos DB query execution using the SQL API.
 
 The Cosmos DB SQL API is a read-only query language: this module runs
 ``SELECT`` against containers. Everything that changes state — containers,
-documents, throughput, indexing policy, TTL — is an Azure SDK call made
-from a Python migration, not SQL routed through a translator.
+documents, throughput, indexing policy, TTL — is an Azure SDK call, not SQL
+routed through a translator. That SDK call is made either from a
+user-authored Python migration (via ``context.db`` / ``context.raw_client``)
+or, for internal callers that are not a migration, through a native escape
+hatch exposed here (e.g. ``upsert_native_item``).
 """
 
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 
 from core.exceptions import NoSqlWriteNotSupportedError
 from core.logger import Log, NullLog
@@ -63,8 +66,11 @@ class CosmosDbQueryExecutor(BaseQueryExecutor):
         The Cosmos DB SQL API reads; it does not write. Containers and
         documents are changed through the Azure SDK, so a write statement
         reaching here is a mistake to surface rather than something to
-        translate. Python migrations get to the SDK through
-        ``context.db`` / ``context.raw_client``.
+        translate. User-authored Python migrations get to the SDK through
+        ``context.db`` / ``context.raw_client``; internal, non-migration
+        callers that need to write a single document use
+        :meth:`upsert_native_item` instead of building SQL for this method
+        to reject.
 
         Returns the number of rows a read produced (``0`` for the scalar
         liveness probe).
@@ -168,6 +174,51 @@ class CosmosDbQueryExecutor(BaseQueryExecutor):
             self.log.error(error_msg)
             raise
 
+    def upsert_native_item(self, container_name: str, document: Dict[str, Any]) -> Dict[str, Any]:
+        """Upsert a document directly through the Azure SDK, bypassing SQL.
+
+        ``execute_statement`` only accepts ``SELECT`` — the Cosmos DB SQL API
+        is read-only, and pretending otherwise (the pseudo-SQL emulator this
+        module used to have) was actively wrong, which is why the ADR
+        removing pseudo-SQL deleted it. Container *creation* was ported to a
+        native SDK call at the time (see
+        ``CosmosDbProvider.create_snapshot_table_if_not_exists``, which calls
+        ``CosmosDbSchemaOperations.create_container_if_not_exists`` instead of
+        rendering ``CREATE TABLE``), but the matching write for a single
+        document was missed: an internal caller such as the schema-snapshot
+        repository still built a plain SQL ``INSERT`` and routed it through
+        ``execute_statement``, which now raises
+        ``NoSqlWriteNotSupportedError`` for anything but a ``SELECT``. That
+        exception is swallowed by a best-effort event listener, so
+        ``migrate`` reports success while the snapshot document silently
+        never lands.
+
+        This method provides the native, non-SQL escape hatch a caller needs
+        to close that gap: it calls ``azure.cosmos.ContainerProxy.upsert_item``
+        directly instead of rendering anything this executor — or its
+        SELECT-only ``execute_statement`` — would have to parse as SQL. It is
+        meant for internal dblift callers that hold a provider/query-executor
+        reference and are not a user-authored migration; migrations already
+        reach the SDK through ``context.db`` / ``context.raw_client`` (see
+        ``execute_statement``'s docstring). This change adds the primitive
+        only — the schema-snapshot repository still needs to be updated, in
+        the sibling monorepo where it lives, to call this instead of
+        building an ``INSERT``; until that happens the gap above is not yet
+        closed end-to-end.
+
+        Args:
+            container_name: Name of the Cosmos DB container to upsert into.
+            document: The full document body to upsert. Must include
+                whatever field the container's partition key path points at.
+
+        Returns:
+            The document as returned by the SDK (typically the input body
+            plus Cosmos-assigned system properties such as ``_etag``,
+            ``_ts``, ``_self``).
+        """
+        container_client = self.connection_manager.get_container_client(container_name)
+        return cast(Dict[str, Any], container_client.upsert_item(body=document))
+
     def _normalize_cosmos_sql(self, sql: str, container_name: str) -> str:
         """Normalize Cosmos DB SQL query to use proper container alias.
 

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/cosmosdb/provider.py

@@ -75,6 +75,28 @@ class CosmosDbProvider(NativeProvider):
         connection = self._get_connection_or_raise()
         return self.query_executor.execute_query(connection, sql, params)
 
+    def upsert_native_item(self, container_name: str, document: Dict[str, Any]) -> Dict[str, Any]:
+        """Upsert a document straight through the Azure SDK, bypassing SQL.
+
+        Thin forward to :meth:`CosmosDbQueryExecutor.upsert_native_item` —
+        the same shape as :meth:`execute_statement` and :meth:`execute_query`
+        above, which forward to the query executor's SQL-shaped methods. This
+        one exists for callers (e.g. the schema-snapshot repository) that
+        need to write a single document and hold a provider reference rather
+        than a query-executor one; see
+        :meth:`CosmosDbQueryExecutor.upsert_native_item` for why a native
+        write path exists instead of routing an ``INSERT`` through
+        ``execute_statement``.
+
+        No connection guard here (unlike ``execute_statement`` /
+        ``execute_query``): the query executor reaches the container through
+        ``connection_manager.get_container_client`` rather than the
+        ``connection`` object, the same reason
+        ``create_snapshot_table_if_not_exists`` below calls into
+        ``schema_operations`` directly without fetching one.
+        """
+        return self.query_executor.upsert_native_item(container_name, document)
+
     def create_schema_if_not_exists(self, schema: str) -> None:
         """Create schema if it doesn't exist (Cosmos DB doesn't have schemas)."""
         connection = self._get_connection_or_raise()

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/db2/quirks.py

@@ -72,8 +72,10 @@ class Db2Quirks(BaseQuirks):
         return self.is_data_history_table_already_exists_error(error_message)
 
     connection_probe_sql = "SELECT 1 FROM SYSIBM.SYSDUMMY1"
-    select_supports_limit = False
-    # Trailing ``FETCH FIRST n ROWS ONLY``; no ``LIMIT``.
+    select_supports_limit = True
+    # Canonical rendering is trailing ``FETCH FIRST n ROWS ONLY``, but DB2
+    # also accepts a bare trailing ``LIMIT n`` (verified against a live
+    # db2 12.01.0500 server via the capability-probe integration test).
     row_limit_style = "fetch_first"
     unquoted_identifier_case = "uppercase"
     connection_identifier_attrs = ("url", "host", "database")

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/duckdb/parser/duckdb_regex_parser.py

@@ -5,7 +5,7 @@ so statement splitting only needs to respect string literals and comments
 around the ``;`` separator.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 from core.sql_model.base import SqlObject, SqlObjectType
 from core.sql_parser.enhanced_regex_parser import EnhancedRegexParser

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/redshift/sqlalchemy_url.py

@@ -1,6 +1,6 @@
 """SQLAlchemy URL construction for the Redshift plugin."""
 
-from typing import Any, Dict, cast
+from typing import Any, Dict
 
 from sqlalchemy.engine import URL, make_url
 
@@ -33,18 +33,15 @@ def build_sqlalchemy_url(database_config: Any) -> str:
             query = _query_mapping(database_config, url.query)
             if query != dict(url.query):
                 url = url.set(query=query)
-            return cast(str, url.render_as_string(hide_password=False))
+            return url.render_as_string(hide_password=False)
         raise ValueError("Redshift native connections require a SQLAlchemy URL")
 
-    return cast(
-        str,
-        URL.create(
-            "redshift+redshift_connector",
-            username=getattr(database_config, "username", None) or None,
-            password=getattr(database_config, "password", None) or None,
-            host=getattr(database_config, "host", None) or "localhost",
-            port=getattr(database_config, "port", None),
-            database=getattr(database_config, "database", None),
-            query=_query_mapping(database_config),
-        ).render_as_string(hide_password=False),
-    )
+    return URL.create(
+        "redshift+redshift_connector",
+        username=getattr(database_config, "username", None) or None,
+        password=getattr(database_config, "password", None) or None,
+        host=getattr(database_config, "host", None) or "localhost",
+        port=getattr(database_config, "port", None),
+        database=getattr(database_config, "database", None),
+        query=_query_mapping(database_config),
+    ).render_as_string(hide_password=False)

{dblift-3.2.0 → dblift-3.3.0}/db/plugins/sqlite/provider.py

@@ -432,17 +432,6 @@ class SQLiteProvider(NativeProvider):
             connection, schema, create_schema, table_name
         )
 
-    def supports_snapshots(self) -> bool:
-        """SQLite does not own schema snapshot persistence."""
-        return False
-
-    def create_snapshot_table_if_not_exists(
-        self, schema: str, table_name: str = "dblift_schema_snapshots"
-    ) -> None:
-        """Satisfy BaseProvider while leaving snapshot storage unsupported."""
-        _ = (schema, table_name)
-        raise NotImplementedError("SQLite provider does not support schema snapshot persistence")
-
     def is_connected(self) -> bool:
         """Return True when an active sqlite3 connection is held.
 

{dblift-3.2.0 → dblift-3.3.0}/dblift.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.2.0
+Version: 3.3.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{dblift-3.2.0 → dblift-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dblift"
-version = "3.2.0"
+version = "3.3.0"
 description = "A database migration tool that supports multiple databases with native Python drivers"
 readme = "README.md"
 requires-python = ">=3.11"