dblift 2.2.2__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.2.2
+Version: 2.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
@@ -66,6 +66,9 @@ 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: fastapi
 Requires-Dist: fastapi>=0.100; extra == "fastapi"
 Provides-Extra: flask
@@ -75,7 +78,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.3.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.3.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.3.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.3.0/db/plugins/duckdb/parser/__init__.py

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

dblift-2.3.0/db/plugins/duckdb/parser/duckdb_regex_parser.py

@@ -0,0 +1,180 @@
+"""DuckDB-specific regex-based SQL parser.
+
+DuckDB has a non-procedural DDL surface (no stored procedures/PL blocks),
+so statement splitting only needs to respect string literals and comments
+around the ``;`` separator.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from core.sql_model.base import SqlObject, SqlObjectType
+from core.sql_parser.enhanced_regex_parser import EnhancedRegexParser
+from db.plugins.duckdb.parser.parser_config import DuckDBParserConfig
+
+
+class DuckDBRegexParser(EnhancedRegexParser):
+    """DuckDB-specific regex-based SQL parser."""
+
+    def __init__(self, config: Optional[DuckDBParserConfig] = None):
+        """Initialize the DuckDB regex parser."""
+        duckdb_config = config or DuckDBParserConfig()
+        self.config = duckdb_config  # type: ignore[assignment]
+        super().__init__(self.config)
+
+    def split_statements(self, sql_content: str, strict_tokenizer: bool = False) -> List[str]:
+        """Split SQL into statements, honouring string literals and comments."""
+        if not sql_content or not sql_content.strip():
+            return []
+
+        statements: List[str] = []
+        current: List[str] = []
+        in_string = False
+        in_ident = False  # inside a "double-quoted" identifier
+        in_block_comment = False
+        in_line_comment = False
+
+        i = 0
+        content = sql_content
+        length = len(content)
+        while i < length:
+            char = content[i]
+            nxt = content[i + 1] if i + 1 < length else ""
+
+            if (
+                not in_string
+                and not in_ident
+                and not in_line_comment
+                and char == "/"
+                and nxt == "*"
+            ):
+                in_block_comment = True
+                current.append(char)
+                current.append(nxt)
+                i += 2
+                continue
+            if in_block_comment:
+                current.append(char)
+                if char == "*" and nxt == "/":
+                    current.append(nxt)
+                    in_block_comment = False
+                    i += 2
+                    continue
+                i += 1
+                continue
+
+            if not in_string and not in_ident and char == "-" and nxt == "-":
+                in_line_comment = True
+                current.append(char)
+                i += 1
+                continue
+            if in_line_comment:
+                current.append(char)
+                if char in "\r\n":
+                    in_line_comment = False
+                i += 1
+                continue
+
+            # Double-quoted identifiers may contain ; and comment markers.
+            if char == '"' and not in_string and not in_ident:
+                in_ident = True
+                current.append(char)
+                i += 1
+                continue
+            if in_ident:
+                current.append(char)
+                if char == '"':
+                    if nxt == '"':  # escaped quote inside identifier
+                        current.append(nxt)
+                        i += 2
+                        continue
+                    in_ident = False
+                i += 1
+                continue
+
+            if char == "'" and not in_string:
+                in_string = True
+                current.append(char)
+                i += 1
+                continue
+            if in_string:
+                current.append(char)
+                if char == "'":
+                    if nxt == "'":  # escaped quote
+                        current.append(nxt)
+                        i += 2
+                        continue
+                    in_string = False
+                i += 1
+                continue
+
+            if char == ";":
+                current.append(char)
+                stmt = "".join(current).strip()
+                if stmt:
+                    statements.append(stmt)
+                current = []
+                i += 1
+                continue
+
+            current.append(char)
+            i += 1
+
+        final = "".join(current).strip()
+        if final:
+            statements.append(final)
+        return statements
+
+    def classify_statement(self, statement: str) -> str:
+        """Classify a SQL statement as DDL / DML / QUERY / TCL / UNKNOWN."""
+        if not statement:
+            return "UNKNOWN"
+        statement = statement.strip()
+        cfg = self.config
+        if cfg.is_ddl_statement(statement):  # type: ignore[attr-defined]
+            return "DDL"
+        if cfg.is_dml_statement(statement):  # type: ignore[attr-defined]
+            return "DML"
+        if cfg.is_query_statement(statement):  # type: ignore[attr-defined]
+            return "QUERY"
+        if statement.upper().startswith(("BEGIN", "COMMIT", "ROLLBACK", "ABORT", "START")):
+            return "TCL"
+        return "UNKNOWN"
+
+    def extract_objects(
+        self, sql_content: str, default_schema: Optional[str] = None
+    ) -> List[SqlObject]:
+        """Extract database objects from a statement via config object patterns."""
+        if not sql_content:
+            return []
+        objects: List[SqlObject] = []
+        statement = sql_content.strip()
+        for pattern_name, pattern in self.config.object_patterns.items():
+            match = pattern.search(statement)
+            if not match:
+                continue
+            non_none = [g for g in match.groups() if g is not None]
+            if not non_none:
+                continue
+            name = non_none[-1].strip('"')
+            schema = non_none[-2].strip('"') if len(non_none) >= 2 else None
+            objects.append(
+                SqlObject(
+                    name=name,
+                    object_type=self._object_type(pattern_name),
+                    schema=schema or default_schema,
+                )
+            )
+            break
+        return objects
+
+    @staticmethod
+    def _object_type(pattern_name: str) -> SqlObjectType:
+        mapping: Dict[str, SqlObjectType] = {
+            "create_table": SqlObjectType.TABLE,
+            "create_view": SqlObjectType.VIEW,
+            "create_index": SqlObjectType.INDEX,
+            "create_sequence": SqlObjectType.SEQUENCE,
+            "alter_table": SqlObjectType.TABLE,
+            "drop_table": SqlObjectType.TABLE,
+        }
+        return mapping.get(pattern_name, SqlObjectType.UNKNOWN)

dblift-2.3.0/db/plugins/duckdb/parser/parser_config.py

@@ -0,0 +1,203 @@
+"""DuckDB dialect configuration for regex-based parsing.
+
+DuckDB SQL is PostgreSQL-like but with a small, non-procedural surface:
+- No stored procedures / no PL blocks (user code lives outside the DB)
+- Real schemas and sequences
+- Double-quoted identifiers (no square brackets)
+"""
+
+import re
+from typing import Dict, List, Pattern, Set
+
+from core.sql_parser.dialects.base_config import DialectConfig
+
+_IDENT = r'(?:"[^"]*"|[a-zA-Z_][a-zA-Z0-9_]*)'
+_QUALIFIED = rf"(?:{_IDENT}\.)?{_IDENT}"
+
+
+class DuckDBParserConfig(DialectConfig):
+    """DuckDB dialect configuration for the regex parser framework."""
+
+    def __init__(self) -> None:
+        """Initialize DuckDB dialect configuration."""
+        super().__init__()  # type: ignore[no-untyped-call]
+
+        self.identifier_quote_char = '"'
+        self.string_quote_char = "'"
+        self.supports_bracket_identifiers = False
+        self.statement_separator = ";"
+        self.line_comment_prefix = "--"
+        self.block_comment_start = "/*"
+        self.block_comment_end = "*/"
+
+        self.supports_dollar_quoting = False
+        self.supports_copy_statements = True  # DuckDB COPY
+        self.supports_plpgsql_blocks = False
+        self.supports_cte_with_recursive = True
+        self.supports_on_conflict = True
+        self.supports_returning = True
+
+        self._compile_patterns()
+
+    def _compile_patterns(self) -> None:
+        def _create(kind: str) -> Pattern[str]:
+            return re.compile(
+                rf"\s*CREATE\s+(?:OR\s+REPLACE\s+)?{kind}\s+(?:IF\s+NOT\s+EXISTS\s+)?",
+                re.IGNORECASE,
+            )
+
+        def _drop(kind: str) -> Pattern[str]:
+            return re.compile(rf"\s*DROP\s+{kind}\s+(?:IF\s+EXISTS\s+)?", re.IGNORECASE)
+
+        self._ddl_patterns = {
+            "create_table": _create(r"(?:TEMP(?:ORARY)?\s+)?TABLE"),
+            "create_view": _create(r"(?:TEMP(?:ORARY)?\s+)?VIEW"),
+            "create_index": re.compile(
+                r"\s*CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?", re.IGNORECASE
+            ),
+            "create_sequence": _create(r"(?:TEMP(?:ORARY)?\s+)?SEQUENCE"),
+            "create_schema": _create(r"SCHEMA"),
+            "create_type": _create(r"TYPE"),
+            "create_macro": _create(r"(?:TEMP(?:ORARY)?\s+)?MACRO"),
+            "alter_table": re.compile(r"\s*ALTER\s+TABLE\s+", re.IGNORECASE),
+            "drop_table": _drop("TABLE"),
+            "drop_view": _drop("VIEW"),
+            "drop_index": _drop("INDEX"),
+            "drop_sequence": _drop("SEQUENCE"),
+            "drop_schema": _drop("SCHEMA"),
+            "drop_type": _drop("TYPE"),
+        }
+
+        self._dml_patterns = {
+            "insert": re.compile(
+                r"\s*INSERT\s+(?:OR\s+(?:REPLACE|IGNORE)\s+)?INTO\s+", re.IGNORECASE
+            ),
+            "update": re.compile(r"\s*UPDATE\s+", re.IGNORECASE),
+            "delete": re.compile(r"\s*DELETE\s+FROM\s+", re.IGNORECASE),
+            "copy": re.compile(r"\s*COPY\s+", re.IGNORECASE),
+        }
+
+        self._query_patterns = {
+            "select": re.compile(r"\s*SELECT\s+", re.IGNORECASE),
+            "with": re.compile(r"\s*WITH\s+(?:RECURSIVE\s+)?", re.IGNORECASE),
+            "values": re.compile(r"\s*VALUES\s+", re.IGNORECASE),
+            "explain": re.compile(r"\s*EXPLAIN\s+", re.IGNORECASE),
+        }
+
+    def get_ddl_keywords(self) -> Set[str]:
+        return {"CREATE", "ALTER", "DROP", "ATTACH", "DETACH", "PRAGMA"}
+
+    def get_dml_keywords(self) -> Set[str]:
+        return {"INSERT", "UPDATE", "DELETE", "COPY"}
+
+    def get_query_keywords(self) -> Set[str]:
+        return {"SELECT", "WITH", "VALUES", "EXPLAIN"}
+
+    def get_transaction_keywords(self) -> Set[str]:
+        return {"BEGIN", "COMMIT", "ROLLBACK", "ABORT", "TRANSACTION", "START"}
+
+    def get_identifier_pattern(self) -> re.Pattern[str]:
+        return re.compile(_IDENT, re.IGNORECASE)
+
+    def get_qualified_identifier_pattern(self) -> re.Pattern[str]:
+        return re.compile(_QUALIFIED, re.IGNORECASE)
+
+    def get_string_literal_pattern(self) -> re.Pattern[str]:
+        return re.compile(r"'(?:[^']|'')*'", re.IGNORECASE)
+
+    def get_comment_pattern(self) -> re.Pattern[str]:
+        return re.compile(r"(?:--[^\r\n]*|/\*.*?\*/)", re.DOTALL)
+
+    def get_statement_separator_pattern(self) -> re.Pattern[str]:
+        return re.compile(r";")
+
+    def _matches_any(self, patterns: Dict[str, Pattern[str]], statement: str) -> bool:
+        statement = statement.strip()
+        return bool(statement) and any(p.match(statement) for p in patterns.values())
+
+    def is_ddl_statement(self, statement: str) -> bool:
+        return self._matches_any(self._ddl_patterns, statement)
+
+    def is_dml_statement(self, statement: str) -> bool:
+        return self._matches_any(self._dml_patterns, statement)
+
+    def is_query_statement(self, statement: str) -> bool:
+        return self._matches_any(self._query_patterns, statement)
+
+    def get_batch_separator(self) -> str:
+        return ";"
+
+    def supports_block_comments(self) -> bool:
+        return True
+
+    def supports_line_comments(self) -> bool:
+        return True
+
+    def get_block_keywords_for_splitting(self) -> Set[str]:
+        # DuckDB DDL is non-procedural; only transaction control uses BEGIN/END.
+        return set()
+
+    def normalize_identifier(self, identifier: str, is_quoted: bool = False) -> str:
+        if not identifier:
+            return identifier
+        if identifier.startswith('"') and identifier.endswith('"'):
+            return identifier[1:-1]
+        return identifier
+
+    @property
+    def name(self) -> str:
+        return "duckdb"  # lint: allow-dialect-string: dialect dispatch
+
+    @property
+    def batch_separators(self) -> List[Pattern[str]]:
+        return [re.compile(r";")]
+
+    @property
+    def quoted_identifiers(self) -> List[Pattern[str]]:
+        return [re.compile(r'"[^"]*"')]
+
+    @property
+    def comment_patterns(self) -> List[Pattern[str]]:
+        return [re.compile(r"--[^\r\n]*"), re.compile(r"/\*.*?\*/", re.DOTALL)]
+
+    @property
+    def block_keywords(self) -> List[str]:
+        return ["CREATE", "ALTER", "DROP"]
+
+    @property
+    def ddl_patterns(self) -> Dict[str, Pattern[str]]:
+        return self._ddl_patterns
+
+    @property
+    def dml_patterns(self) -> Dict[str, Pattern[str]]:
+        return self._dml_patterns
+
+    @property
+    def query_patterns(self) -> Dict[str, Pattern[str]]:
+        return self._query_patterns
+
+    @property
+    def object_patterns(self) -> Dict[str, Pattern[str]]:
+        def _obj(kind: str) -> Pattern[str]:
+            return re.compile(
+                rf"CREATE\s+(?:OR\s+REPLACE\s+)?{kind}\s+(?:IF\s+NOT\s+EXISTS\s+)?"
+                rf"(?:({_IDENT})\.)?({_IDENT})",
+                re.IGNORECASE,
+            )
+
+        return {
+            "create_table": _obj(r"(?:TEMP(?:ORARY)?\s+)?TABLE"),
+            "create_view": _obj(r"(?:TEMP(?:ORARY)?\s+)?VIEW"),
+            "create_index": re.compile(
+                rf"CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?"
+                rf"(?:({_IDENT})\.)?({_IDENT})",
+                re.IGNORECASE,
+            ),
+            "create_sequence": _obj(r"(?:TEMP(?:ORARY)?\s+)?SEQUENCE"),
+            "alter_table": re.compile(
+                rf"ALTER\s+TABLE\s+(?:({_IDENT})\.)?({_IDENT})", re.IGNORECASE
+            ),
+            "drop_table": re.compile(
+                rf"DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:({_IDENT})\.)?({_IDENT})", re.IGNORECASE
+            ),
+        }

dblift-2.3.0/db/plugins/duckdb/plugin.py

@@ -0,0 +1,22 @@
+"""Entry-point declaration for the DuckDB plugin."""
+
+from __future__ import annotations
+
+from db.plugins.duckdb.config import DuckDBConfig
+from db.plugins.duckdb.provider import DuckDBProvider
+from db.plugins.duckdb.quirks import DuckDBQuirks
+from db.plugins.duckdb.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="duckdb",
+    version="1.0.0",
+    description="DuckDB database provider (SQLAlchemy via duckdb_engine)",
+    dialects=["duckdb"],
+    provider_class=DuckDBProvider,
+    transport="native",
+    quirks_class=DuckDBQuirks,
+    config_class=DuckDBConfig,
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="duckdb",
+)