dblift 2.2.2__tar.gz → 2.4.0__tar.gz

{dblift-2.2.2 → dblift-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.2.2
+Version: 2.4.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -66,6 +66,23 @@ Requires-Dist: pymssql>=2.3; extra == "sqlserver"
 Provides-Extra: db2
 Requires-Dist: ibm_db>=3.2; extra == "db2"
 Requires-Dist: ibm_db_sa>=0.4; extra == "db2"
+Provides-Extra: duckdb
+Requires-Dist: duckdb>=1.0; extra == "duckdb"
+Requires-Dist: duckdb_engine>=0.13; extra == "duckdb"
+Provides-Extra: neon
+Requires-Dist: psycopg[binary]>=3.1; extra == "neon"
+Provides-Extra: supabase
+Requires-Dist: psycopg[binary]>=3.1; extra == "supabase"
+Provides-Extra: aurora-postgresql
+Requires-Dist: psycopg[binary]>=3.1; extra == "aurora-postgresql"
+Provides-Extra: alloydb
+Requires-Dist: psycopg[binary]>=3.1; extra == "alloydb"
+Provides-Extra: yugabytedb
+Requires-Dist: psycopg[binary]>=3.1; extra == "yugabytedb"
+Provides-Extra: timescaledb
+Requires-Dist: psycopg[binary]>=3.1; extra == "timescaledb"
+Provides-Extra: citus
+Requires-Dist: psycopg[binary]>=3.1; extra == "citus"
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.100; extra == "fastapi"
 Provides-Extra: flask
@@ -75,7 +92,7 @@ Requires-Dist: Django>=4.2; extra == "django"
 Provides-Extra: otel
 Requires-Dist: opentelemetry-api>=1.20; extra == "otel"
 Provides-Extra: all
-Requires-Dist: dblift[db2,mariadb,mysql,oracle,postgresql,sqlserver]; extra == "all"
+Requires-Dist: dblift[db2,duckdb,mariadb,mysql,oracle,postgresql,sqlserver]; extra == "all"
 Dynamic: license-file
 
 # DBLift — Database release safety for Python teams

{dblift-2.2.2 → dblift-2.4.0}/cli/main.py

@@ -145,6 +145,44 @@ class _CliContext:
     license_info: Optional[Any] = None
 
 
+def _format_version() -> str:
+    """Render the ``--version`` output.
+
+    The published ``dblift`` wheel is the OSS *core*. The paid tiers ship as
+    separate distributions (``dblift-pro`` / ``dblift-enterprise``) bundled into
+    the compiled binary, each on its own release lifecycle — so their versions
+    need not match the core's. Report the most-derived installed tier as the
+    headline (that is the product the user actually runs) and, when a paid tier
+    is present, list every component so a bare number is never ambiguous. In a
+    plain OSS install only the core is present, so the output stays a single
+    ``dblift version X`` line — unchanged from before.
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _version
+
+    def _get(dist: str) -> Optional[str]:
+        try:
+            return _version(dist)
+        except PackageNotFoundError:
+            return None
+
+    core = _get("dblift")
+    pro = _get("dblift-pro")
+    enterprise = _get("dblift-enterprise")
+
+    # Headline = most-derived installed tier (the product actually running).
+    product = enterprise or pro or core
+    lines = [f"dblift version {product}"]
+    # Component manifest only when a paid tier is present; OSS stays one line.
+    if pro or enterprise:
+        lines.append(f"  core (OSS):  {core}")
+        if pro:
+            lines.append(f"  pro:         {pro}")
+        if enterprise:
+            lines.append(f"  enterprise:  {enterprise}")
+    return "\n".join(lines)
+
+
 def main() -> None:
     """Main entry point for DBLift CLI application.
 
@@ -211,22 +249,14 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     if commands and commands[0] in terminal_commands:
         args = _build_terminal_args(commands[0], global_arguments, subcommand_args)
         if hasattr(args, "version") and args.version:
-            from importlib.metadata import version as _version
-
-            __version__ = _version("dblift")
-
-            print(f"dblift version {__version__}")  # lint: allow-print  --version terminal action
+            print(_format_version())  # lint: allow-print  --version terminal action
             sys.exit(0)
         sys.exit(terminal_commands[commands[0]](args))
 
     args, _unknown_args = _build_args_namespace(commands, global_arguments, subcommand_args)
 
     if hasattr(args, "version") and args.version:
-        from importlib.metadata import version as _version
-
-        __version__ = _version("dblift")
-
-        print(f"dblift version {__version__}")  # lint: allow-print  --version terminal action
+        print(_format_version())  # lint: allow-print  --version terminal action
         sys.exit(0)
 
     if not commands and (not hasattr(args, "command") or not args.command):

{dblift-2.2.2 → dblift-2.4.0}/core/migration/commands/repair_command.py

@@ -498,7 +498,23 @@ class RepairCommand(BaseCommand):
                     params=[script_name],
                 )
 
-            if rows_affected > 0:
+            row_removed = rows_affected > 0
+            if (
+                rows_affected < 0
+                and not is_non_transactional
+                and hasattr(self.provider, "execute_query")
+            ):
+                # Some DBAPIs report an "unknown" rowcount of -1 for DML
+                # (e.g. duckdb_engine), so ``rows_affected > 0`` would wrongly
+                # read as "nothing removed". Verify the failed row is gone.
+                remaining = self.provider.execute_query(
+                    f"SELECT 1 FROM {qualified_table} "
+                    f"WHERE script = ? AND success = {false_literal}",
+                    [script_name],
+                )
+                row_removed = not remaining
+
+            if row_removed:
                 result.failed_migrations_removed = (
                     getattr(result, "failed_migrations_removed", 0) + 1
                 )

dblift-2.4.0/db/plugins/alloydb/__init__.py

@@ -0,0 +1,12 @@
+"""Google AlloyDB for PostgreSQL database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "alloydb"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Google AlloyDB for PostgreSQL database provider"
+__plugin_dialects__ = ["alloydb"]
+__plugin_transport__ = "native"
+__plugin_class__ = "AlloydbProvider"
+
+from .provider import AlloydbProvider
+
+__all__ = ["AlloydbProvider"]

dblift-2.4.0/db/plugins/alloydb/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Google AlloyDB for PostgreSQL plugin.
+
+Google AlloyDB for PostgreSQL is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: alloydb``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.alloydb.provider import AlloydbProvider
+from db.plugins.alloydb.quirks import AlloydbQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="alloydb",
+    version="1.0.0",
+    description="Google AlloyDB for PostgreSQL database provider",
+    dialects=["alloydb"],
+    provider_class=AlloydbProvider,
+    transport="native",
+    quirks_class=AlloydbQuirks,
+    config_dialect="postgresql",  # Google AlloyDB for PostgreSQL shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.0/db/plugins/alloydb/provider.py

@@ -0,0 +1,14 @@
+"""Google AlloyDB for PostgreSQL native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class AlloydbProvider(PostgreSqlProvider):
+    """Google AlloyDB for PostgreSQL — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "alloydb"
+
+
+__all__ = ["AlloydbProvider"]

dblift-2.4.0/db/plugins/alloydb/quirks.py

@@ -0,0 +1,32 @@
+"""Google AlloyDB for PostgreSQL :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class AlloydbQuirks(PostgresqlQuirks):
+    """Google AlloyDB for PostgreSQL quirks, inheriting every PostgreSQL quirk.
+
+    Google AlloyDB for PostgreSQL speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "alloydb") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["AlloydbQuirks"]

dblift-2.4.0/db/plugins/aurora_postgresql/__init__.py

@@ -0,0 +1,12 @@
+"""Amazon Aurora PostgreSQL database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "aurora-postgresql"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Amazon Aurora PostgreSQL database provider"
+__plugin_dialects__ = ["aurora-postgresql"]
+__plugin_transport__ = "native"
+__plugin_class__ = "AuroraPostgresqlProvider"
+
+from .provider import AuroraPostgresqlProvider
+
+__all__ = ["AuroraPostgresqlProvider"]

dblift-2.4.0/db/plugins/aurora_postgresql/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Amazon Aurora PostgreSQL plugin.
+
+Amazon Aurora PostgreSQL is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: aurora-postgresql``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.aurora_postgresql.provider import AuroraPostgresqlProvider
+from db.plugins.aurora_postgresql.quirks import AuroraPostgresqlQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="aurora-postgresql",
+    version="1.0.0",
+    description="Amazon Aurora PostgreSQL database provider",
+    dialects=["aurora-postgresql"],
+    provider_class=AuroraPostgresqlProvider,
+    transport="native",
+    quirks_class=AuroraPostgresqlQuirks,
+    config_dialect="postgresql",  # Amazon Aurora PostgreSQL shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.0/db/plugins/aurora_postgresql/provider.py

@@ -0,0 +1,14 @@
+"""Amazon Aurora PostgreSQL native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class AuroraPostgresqlProvider(PostgreSqlProvider):
+    """Amazon Aurora PostgreSQL — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "aurora-postgresql"
+
+
+__all__ = ["AuroraPostgresqlProvider"]

dblift-2.4.0/db/plugins/aurora_postgresql/quirks.py

@@ -0,0 +1,32 @@
+"""Amazon Aurora PostgreSQL :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class AuroraPostgresqlQuirks(PostgresqlQuirks):
+    """Amazon Aurora PostgreSQL quirks, inheriting every PostgreSQL quirk.
+
+    Amazon Aurora PostgreSQL speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "aurora-postgresql") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["AuroraPostgresqlQuirks"]

dblift-2.4.0/db/plugins/citus/__init__.py

@@ -0,0 +1,12 @@
+"""Citus (distributed PostgreSQL) database provider plugin (PostgreSQL-compatible)."""
+
+__plugin_name__ = "citus"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Citus (distributed PostgreSQL) database provider"
+__plugin_dialects__ = ["citus"]
+__plugin_transport__ = "native"
+__plugin_class__ = "CitusProvider"
+
+from .provider import CitusProvider
+
+__all__ = ["CitusProvider"]

dblift-2.4.0/db/plugins/citus/plugin.py

@@ -0,0 +1,28 @@
+"""Entry-point declaration for the Citus (distributed PostgreSQL) plugin.
+
+Citus (distributed PostgreSQL) is wire-compatible with PostgreSQL: this plugin reuses PostgreSQL's
+config class (``config_dialect="postgresql"``), SQLAlchemy URL builder, and
+``psycopg`` driver, attaching only a distinct identity + quirks subclass. Users
+keep their ``postgresql://`` connection string and select this engine via
+``type: citus``.
+"""
+
+from __future__ import annotations
+
+from db.plugins.citus.provider import CitusProvider
+from db.plugins.citus.quirks import CitusQuirks
+from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="citus",
+    version="1.0.0",
+    description="Citus (distributed PostgreSQL) database provider",
+    dialects=["citus"],
+    provider_class=CitusProvider,
+    transport="native",
+    quirks_class=CitusQuirks,
+    config_dialect="postgresql",  # Citus (distributed PostgreSQL) shares PostgreSQL's config class
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="psycopg",
+)

dblift-2.4.0/db/plugins/citus/provider.py

@@ -0,0 +1,14 @@
+"""Citus (distributed PostgreSQL) native provider (PostgreSQL-compatible)."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.provider import PostgreSqlProvider
+
+
+class CitusProvider(PostgreSqlProvider):
+    """Citus (distributed PostgreSQL) — wire-compatible with PostgreSQL; reuses the PostgreSQL provider."""
+
+    canonical_dialect_key = "citus"
+
+
+__all__ = ["CitusProvider"]

dblift-2.4.0/db/plugins/citus/quirks.py

@@ -0,0 +1,32 @@
+"""Citus (distributed PostgreSQL) :class:`DialectQuirks` — inherits PostgreSQL behavior."""
+
+from __future__ import annotations
+
+from db.plugins.postgresql.quirks import PostgresqlQuirks
+
+
+class CitusQuirks(PostgresqlQuirks):
+    """Citus (distributed PostgreSQL) quirks, inheriting every PostgreSQL quirk.
+
+    Citus (distributed PostgreSQL) speaks the PostgreSQL wire protocol, so statement splitting,
+    rendering, comparison, and introspection all reuse PostgreSQL's behavior.
+    Only the ANSI-reference flag is overridden: exactly one registered plugin
+    (PostgreSQL) may be the reference dialect, so PostgreSQL-derived plugins
+    must not re-claim it. Engine-specific deviations land here if and when the
+    codebase needs them.
+    """
+
+    # Exactly one plugin owns the ANSI reference dialect (PostgreSQL); a
+    # PG-derived plugin that inherited ``True`` would break
+    # ``ProviderRegistry.reference_dialect_name`` (which requires a single
+    # winner), so reset it here.
+    is_ansi_reference_dialect = False
+    # PostgreSQL is likewise the single owner of the sqlglot read-dialect
+    # fallback; a PG-derived plugin must not claim it either.
+    is_default_sqlglot_read_fallback = False
+
+    def __init__(self, dialect_name: str = "citus") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+
+__all__ = ["CitusQuirks"]

dblift-2.4.0/db/plugins/duckdb/__init__.py

@@ -0,0 +1,12 @@
+"""DuckDB database provider plugin."""
+
+__plugin_name__ = "duckdb"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "DuckDB database provider (SQLAlchemy via duckdb_engine)"
+__plugin_dialects__ = ["duckdb"]
+__plugin_transport__ = "native"
+__plugin_class__ = "DuckDBProvider"
+
+from .provider import DuckDBProvider
+
+__all__ = ["DuckDBProvider"]

dblift-2.4.0/db/plugins/duckdb/config.py

@@ -0,0 +1,81 @@
+"""DuckDB-specific ``BaseDatabaseConfig`` subclass."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from config.database_config import BaseDatabaseConfig, register_database_type
+
+
+# lint: allow-dialect-string: config type registration
+@register_database_type("duckdb")
+@dataclass
+class DuckDBConfig(BaseDatabaseConfig):
+    """Configuration for DuckDB connections.
+
+    DuckDB is embedded/file-based (like SQLite): no server, no
+    credentials, ``"main"`` default schema. Connections resolve to a
+    file path (or ``:memory:``) rather than a host/port.
+    """
+
+    # DuckDB specific fields
+    path: Optional[str] = None  # Path to the DuckDB file (or :memory: for in-memory)
+
+    def __post_init__(self) -> None:
+        """Resolve the file path from path/url/database and apply defaults."""
+        super().__post_init__()
+
+        if not self.path:
+            if self.url:
+                url = self.url
+                if url.startswith("duckdb://"):
+                    # Match duckdb_engine's URL convention:
+                    #   duckdb:///rel.db   (3 slashes) -> relative "rel.db"
+                    #   duckdb:////abs.db  (4 slashes) -> absolute "/abs.db"
+                    #   duckdb:///:memory: -> ":memory:"
+                    self.path = url[len("duckdb://") :]
+                    if self.path in ("/:memory:", ":memory:"):
+                        self.path = ":memory:"
+                    elif self.path.startswith("//"):
+                        self.path = "/" + self.path.lstrip("/")
+                    elif self.path.startswith("/"):
+                        self.path = self.path[1:]
+                else:
+                    self.path = url
+            elif self.database:
+                self.path = self.database
+
+        if not self.path:
+            raise ValueError(
+                "Database path is required for DuckDB (use 'path' or 'database' field)"
+            )
+
+        # DuckDB's default schema is 'main'; no credentials required.
+        if not self.schema:
+            self.schema = "main"
+        if not self.username:
+            self.username = ""
+        if not self.password:
+            self.password = ""
+
+    def build_connection_string(self) -> str:
+        """Build a DuckDB connection string (file path)."""
+        return self.path or ""
+
+    def build_database_url(self) -> str:
+        """Build the DuckDB plugin-owned SQLAlchemy URL."""
+        from db.provider_registry import ProviderRegistry
+
+        return ProviderRegistry.build_sqlalchemy_url(self)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary with DuckDB specific parameters."""
+        result = super().to_dict()
+        result["path"] = self.path
+        return result
+
+    def get_connection_props(self) -> Dict[str, str]:
+        """Get connection properties for DuckDB connection."""
+        props: Dict[str, str] = {}
+        if self.path:
+            props["path"] = self.path
+        return props

dblift-2.4.0/db/plugins/duckdb/parser/__init__.py

@@ -0,0 +1,5 @@
+"""DuckDB SQL parser module."""
+
+from .duckdb_regex_parser import DuckDBRegexParser
+
+__all__ = ["DuckDBRegexParser"]