dblift 2.5.2__tar.gz → 2.6.0__tar.gz

{dblift-2.5.2 → dblift-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.5.2
+Version: 2.6.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -88,6 +88,8 @@ Requires-Dist: psycopg[binary]>=3.1; extra == "cockroachdb"
 Provides-Extra: redshift
 Requires-Dist: sqlalchemy-redshift>=1.0.0; extra == "redshift"
 Requires-Dist: redshift-connector>=2.1.0; extra == "redshift"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-sqlalchemy>=1.11.0; extra == "snowflake"
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.100; extra == "fastapi"
 Provides-Extra: flask
@@ -734,6 +736,7 @@ DBLift works with these databases:
 | PostgreSQL | `postgresql+psycopg://localhost:5432/mydb` | `dblift[postgresql]` |
 | CockroachDB | `postgresql+psycopg://localhost:26257/mydb` | `dblift[cockroachdb]` |
 | Redshift | `postgresql+psycopg://cluster.example.com:5439/dev` | `dblift[redshift]` |
+| Snowflake | `snowflake://user:password@account_identifier/database/schema?warehouse=WH&role=ROLE` | `dblift[snowflake]` |
 | SQL Server | `mssql+pymssql://localhost:1433/mydb` | `dblift[sqlserver]` |
 | Oracle | `oracle+oracledb://localhost:1521?sid=SID` | `dblift[oracle]` |
 | MySQL | `mysql+pymysql://localhost:3306/mydb` | `dblift[mysql]` |

{dblift-2.5.2 → dblift-2.6.0}/README.md

@@ -632,6 +632,7 @@ DBLift works with these databases:
 | PostgreSQL | `postgresql+psycopg://localhost:5432/mydb` | `dblift[postgresql]` |
 | CockroachDB | `postgresql+psycopg://localhost:26257/mydb` | `dblift[cockroachdb]` |
 | Redshift | `postgresql+psycopg://cluster.example.com:5439/dev` | `dblift[redshift]` |
+| Snowflake | `snowflake://user:password@account_identifier/database/schema?warehouse=WH&role=ROLE` | `dblift[snowflake]` |
 | SQL Server | `mssql+pymssql://localhost:1433/mydb` | `dblift[sqlserver]` |
 | Oracle | `oracle+oracledb://localhost:1521?sid=SID` | `dblift[oracle]` |
 | MySQL | `mysql+pymysql://localhost:3306/mydb` | `dblift[mysql]` |

dblift-2.6.0/db/plugins/snowflake/__init__.py

@@ -0,0 +1,12 @@
+"""Snowflake database provider plugin."""
+
+__plugin_name__ = "snowflake"
+__plugin_version__ = "1.0.0"
+__plugin_description__ = "Snowflake database provider"
+__plugin_dialects__ = ["snowflake"]
+__plugin_transport__ = "native"
+__plugin_class__ = "SnowflakeProvider"
+
+from .provider import SnowflakeProvider
+
+__all__ = ["SnowflakeProvider"]

dblift-2.6.0/db/plugins/snowflake/config.py

@@ -0,0 +1,67 @@
+"""Snowflake-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("snowflake")
+@dataclass
+class SnowflakeConfig(BaseDatabaseConfig):
+    """Configuration for Snowflake SQLAlchemy connections."""
+
+    account: Optional[str] = None
+    warehouse: Optional[str] = None
+    role: Optional[str] = None
+    authenticator: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        """Resolve account/database/schema from Snowflake URL fields."""
+        super().__post_init__()
+        # lint: allow-dialect-string: config type identity
+        self.type = "snowflake"
+
+        if not self.account and self.host:
+            self.account = str(self.host)
+
+        database_value = getattr(self, "database", None)
+        if database_value and "/" in str(database_value):
+            database, schema = str(database_value).split("/", 1)
+            self.database = database or None
+            if schema and not getattr(self, "schema", ""):
+                self.schema = schema
+
+    def build_connection_string(self) -> str:
+        """Build the Snowflake plugin-owned SQLAlchemy URL."""
+        return self.build_database_url()
+
+    def build_database_url(self) -> str:
+        """Build the Snowflake SQLAlchemy URL through the provider registry."""
+        from db.provider_registry import ProviderRegistry
+
+        url: str = ProviderRegistry.build_sqlalchemy_url(self)
+        return url
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary with Snowflake-specific parameters."""
+        result: Dict[str, Any] = super().to_dict()
+        result["account"] = self.account
+        result["warehouse"] = self.warehouse
+        result["role"] = self.role
+        result["authenticator"] = self.authenticator
+        return result
+
+    def get_connection_props(self) -> Dict[str, str]:
+        """Return Snowflake connection properties."""
+        props: Dict[str, str] = super().get_connection_props()
+        if self.account:
+            props["account"] = self.account
+        if self.warehouse:
+            props["warehouse"] = self.warehouse
+        if self.role:
+            props["role"] = self.role
+        if self.authenticator:
+            props["authenticator"] = self.authenticator
+        return props

dblift-2.6.0/db/plugins/snowflake/plugin.py

@@ -0,0 +1,22 @@
+"""Entry-point declaration for the Snowflake plugin."""
+
+from __future__ import annotations
+
+from db.plugins.snowflake.config import SnowflakeConfig
+from db.plugins.snowflake.provider import SnowflakeProvider
+from db.plugins.snowflake.quirks import SnowflakeQuirks
+from db.plugins.snowflake.sqlalchemy_url import build_sqlalchemy_url
+from db.provider_registry import PluginInfo
+
+PLUGIN: PluginInfo = PluginInfo(
+    name="snowflake",
+    version="1.0.0",
+    description="Snowflake database provider",
+    dialects=["snowflake"],
+    provider_class=SnowflakeProvider,
+    transport="native",
+    quirks_class=SnowflakeQuirks,
+    config_class=SnowflakeConfig,
+    sqlalchemy_url_builder=build_sqlalchemy_url,
+    native_driver_module="snowflake.connector",
+)

dblift-2.6.0/db/plugins/snowflake/provider.py

@@ -0,0 +1,449 @@
+"""Snowflake native provider backed by SQLAlchemy Core."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy.engine import Connection, Transaction
+
+from config import DbliftConfig
+from core.logger import Log
+from core.migration.clean_summary import CleanExecutionSummary
+from db.provider_interfaces import DroppableObject
+from db.sqlalchemy_provider import SqlAlchemyProvider
+
+
+def _quote_identifier(identifier: str) -> str:
+    return '"' + identifier.upper().replace('"', '""') + '"'
+
+
+def _is_lock_timeout_error(error: Exception) -> bool:
+    message = " ".join(
+        str(value or "").lower()
+        for value in (
+            getattr(error, "msg", None),
+            getattr(error, "raw_msg", None),
+            str(error),
+        )
+    )
+    markers = (
+        "lock timeout",
+        "lock wait timeout",
+        "waiting for this lock",
+        "waited too long for a lock",
+    )
+    return any(marker in message for marker in markers)
+
+
+class SnowflakeProvider(SqlAlchemyProvider):
+    """Snowflake provider using the Snowflake SQLAlchemy dialect."""
+
+    canonical_dialect_key = "snowflake"
+    MIGRATION_LOCK_TABLE = "DBLIFT_MIGRATION_LOCK"
+    _migration_lock_connection: Connection | None = None
+    _migration_lock_transaction: Transaction | None = None
+
+    def __init__(
+        self,
+        config: DbliftConfig,
+        log: Optional[Log] = None,
+    ) -> None:
+        super().__init__(config, log)
+
+    def execute_statement(
+        self,
+        sql: str,
+        schema: Optional[str] = None,
+        params: Optional[List[Any]] = None,
+    ) -> int:
+        """Execute a SQL statement, optionally preparing the schema first."""
+        if schema:
+            self.create_schema_if_not_exists(schema)
+            self.set_current_schema(schema)
+        rowcount: int = super().execute_statement(
+            sql,
+            schema=schema,
+            params=params,
+        )
+        return rowcount
+
+    def create_schema_if_not_exists(self, schema: str) -> None:
+        """Create a Snowflake schema if it is missing."""
+        schema_name = _quote_identifier(schema)
+        self.execute_statement(f"CREATE SCHEMA IF NOT EXISTS {schema_name}")
+
+    def table_exists(self, schema: str, table_name: str) -> bool:
+        """Return whether a table exists in the given schema."""
+        rows = self.execute_query(
+            """
+            SELECT 1 AS present
+            FROM INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_SCHEMA = UPPER(?)
+              AND TABLE_NAME = UPPER(?)
+            """,
+            [schema, table_name],
+        )
+        return bool(rows)
+
+    def get_database_version(self) -> str:
+        """Return Snowflake version information."""
+        rows = self.execute_query("SELECT CURRENT_VERSION() AS version")
+        if rows:
+            return f"Snowflake {rows[0]['version']}"
+        return "Unknown Snowflake Version"
+
+    def supports_transactional_ddl(self) -> bool:
+        """Snowflake DDL auto-commits."""
+        return False
+
+    def set_current_schema(self, schema: str) -> None:
+        """Set the current Snowflake schema for this session."""
+        super().execute_statement(f"USE SCHEMA {_quote_identifier(schema)}")
+
+    def get_schema_qualified_name(self, schema: str, object_name: str) -> str:
+        """Return a quoted schema-qualified object name."""
+        return f"{_quote_identifier(schema)}.{_quote_identifier(object_name)}"
+
+    def clean_schema(self, schema: str) -> CleanExecutionSummary:
+        """Drop Snowflake views, tables, and sequences in a schema."""
+        summary = self.get_clean_preview(schema)
+        for stmt in summary.statements:
+            self.execute_statement(stmt)
+        return summary
+
+    def get_clean_preview(self, schema: str) -> CleanExecutionSummary:
+        """Return Snowflake objects that clean would drop."""
+        summary = CleanExecutionSummary()
+
+        for view_name in self._object_names(_SNOWFLAKE_VIEWS_QUERY, schema):
+            qualified = self.get_schema_qualified_name(schema, view_name)
+            summary.record_drop(
+                f"DROP VIEW IF EXISTS {qualified}",
+                object_type="view",
+                name=view_name,
+                schema=schema,
+            )
+
+        for table_name in self._object_names(_SNOWFLAKE_TABLES_QUERY, schema):
+            qualified = self.get_schema_qualified_name(schema, table_name)
+            summary.record_drop(
+                f"DROP TABLE IF EXISTS {qualified} CASCADE",
+                object_type="table",
+                name=table_name,
+                schema=schema,
+            )
+
+        sequence_names = self._object_names(_SNOWFLAKE_SEQUENCES_QUERY, schema)
+        for sequence_name in sequence_names:
+            qualified = self.get_schema_qualified_name(schema, sequence_name)
+            summary.record_drop(
+                f"DROP SEQUENCE IF EXISTS {qualified}",
+                object_type="sequence",
+                name=sequence_name,
+                schema=schema,
+            )
+
+        return summary
+
+    def list_droppable_objects(self, schema: str) -> List[DroppableObject]:
+        """Return Snowflake clean candidates in preview order."""
+        summary = self.get_clean_preview(schema)
+        return [
+            DroppableObject(
+                name=obj.name,
+                object_type=obj.object_type,
+                drop_sql=drop_sql,
+            )
+            for obj, drop_sql in zip(summary.objects, summary.statements)
+        ]
+
+    def _object_names(self, query: str, schema: str) -> List[str]:
+        rows = self.execute_query(query, [schema])
+        return [
+            str(row.get("object_name") or row.get("OBJECT_NAME"))
+            for row in rows
+            if row.get("object_name") or row.get("OBJECT_NAME")
+        ]
+
+    def create_migration_lock_table_sql(self, schema: str) -> str:
+        """Return the Snowflake migration lock table DDL."""
+        qualified = self.get_schema_qualified_name(
+            schema,
+            self.MIGRATION_LOCK_TABLE,
+        )
+        return f"""
+            CREATE TABLE IF NOT EXISTS {qualified} (
+                lock_name VARCHAR(128) NOT NULL,
+                locked_at TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
+            )
+        """
+
+    def acquire_migration_lock_sql(self, schema: str) -> str:
+        """Return the DML statement holding the migration lock row."""
+        qualified = self.get_schema_qualified_name(
+            schema,
+            self.MIGRATION_LOCK_TABLE,
+        )
+        return (
+            f"UPDATE {qualified} "
+            "SET locked_at = CURRENT_TIMESTAMP() WHERE lock_name = 'migration'"
+        )
+
+    def create_migration_lock_table_if_not_exists(self, schema: str) -> None:
+        """Create and seed the Snowflake migration lock table."""
+        self.create_schema_if_not_exists(schema)
+        self.execute_statement(self.create_migration_lock_table_sql(schema))
+        lock_table = self.MIGRATION_LOCK_TABLE
+        qualified = self.get_schema_qualified_name(schema, lock_table)
+        # Snowflake accepts UNIQUE/PRIMARY KEY syntax on standard tables but
+        # does not enforce it, so seed the singleton lock row with one MERGE.
+        self.execute_statement(f"""
+            MERGE INTO {qualified} target
+            USING (
+                SELECT
+                    'migration' AS lock_name,
+                    CURRENT_TIMESTAMP() AS locked_at
+            ) source
+            ON target.lock_name = source.lock_name
+            WHEN NOT MATCHED THEN
+                INSERT (lock_name, locked_at)
+                VALUES (source.lock_name, source.locked_at)
+            """)
+
+    def acquire_migration_lock(
+        self,
+        schema: str,
+        wait_timeout_seconds: int = 60,
+    ) -> bool:
+        """Acquire the migration lock with a DML transaction."""
+        if self._migration_lock_transaction is not None:
+            return True
+
+        self.create_migration_lock_table_if_not_exists(schema)
+        connection = self.engine.connect()
+        try:
+            timeout = max(0, int(wait_timeout_seconds))
+            set_timeout = f"ALTER SESSION SET LOCK_TIMEOUT = {timeout}"
+            connection.exec_driver_sql(set_timeout)
+            connection.commit()
+            transaction = connection.begin()
+            connection.exec_driver_sql(self.acquire_migration_lock_sql(schema))
+        except Exception as exc:
+            try:
+                connection.rollback()
+            finally:
+                connection.close()
+            if _is_lock_timeout_error(exc):
+                return False
+            raise
+
+        self._migration_lock_connection = connection
+        self._migration_lock_transaction = transaction
+        return True
+
+    def release_migration_lock(self, schema: str) -> bool:
+        """Release the Snowflake migration lock by ending its transaction."""
+        transaction = self._migration_lock_transaction
+        connection = self._migration_lock_connection
+        if transaction is None or connection is None:
+            return True
+
+        try:
+            transaction.commit()
+            return True
+        except Exception:
+            try:
+                transaction.rollback()
+            except Exception:
+                pass
+            return False
+        finally:
+            try:
+                connection.close()
+            finally:
+                self._migration_lock_connection = None
+                self._migration_lock_transaction = None
+
+    def close(self) -> None:
+        """Close SQLAlchemy resources and release any held migration lock."""
+        try:
+            self.release_migration_lock("")
+        finally:
+            super().close()
+
+    def get_applied_migrations(
+        self, schema: str, table_name: str = "dblift_schema_history"
+    ) -> List[Dict[str, Any]]:
+        """Return applied migration rows from the history table."""
+        normalized_table = table_name.upper()
+        if not self.table_exists(schema, normalized_table):
+            return []
+        rows: List[Dict[str, Any]] = self.execute_query(f"""
+            SELECT *
+            FROM {self.get_schema_qualified_name(schema, normalized_table)}
+            ORDER BY installed_rank
+            """)
+        return rows
+
+    def create_migration_history_table_if_not_exists(
+        self,
+        schema: str,
+        create_schema: bool = False,
+        table_name: str = "dblift_schema_history",
+    ) -> None:
+        """Create the Snowflake migration history table if missing."""
+        normalized_table = table_name.upper()
+        if create_schema:
+            self.create_schema_if_not_exists(schema)
+        if self.table_exists(schema, normalized_table):
+            if create_schema:
+                self._check_baseline_safety(schema, normalized_table)
+            return
+        create_sql = self.create_history_table(schema, normalized_table)
+        self.execute_statement(create_sql)
+
+    def _check_baseline_safety(self, schema: str, table_name: str) -> None:
+        """Refuse baseline when history already contains migrations."""
+        qualified_table = self.get_schema_qualified_name(schema, table_name)
+        count_sql = f"SELECT COUNT(1) AS count FROM {qualified_table}"
+        rows = self.execute_query(count_sql)
+        migration_count = 0
+        if rows:
+            count = rows[0].get("count", rows[0].get("COUNT", 0))
+            migration_count = int(count or 0)
+        if migration_count > 0:
+            baseline_error = "Baseline cannot run with existing migrations."
+            raise RuntimeError(
+                f"Schema {schema} already contains a migration history table "
+                f"{table_name} with {migration_count} migration(s). "
+                f"{baseline_error}"
+            )
+
+    def record_migration(
+        self,
+        schema: str,
+        migration_info: Dict[str, Any],
+        table_name: str = "dblift_schema_history",
+    ) -> None:
+        """Insert a migration record into the Snowflake history table."""
+        normalized_table = table_name.upper()
+        self.create_migration_history_table_if_not_exists(
+            schema,
+            table_name=normalized_table,
+        )
+        qualified_table = self.get_schema_qualified_name(
+            schema,
+            normalized_table,
+        )
+        self.execute_statement(
+            f"""
+            INSERT INTO {qualified_table}
+                (version, description, type, script, checksum,
+                 installed_by, execution_time, success)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            params=[
+                migration_info.get("version"),
+                migration_info.get("description", ""),
+                migration_info.get("type", "SQL"),
+                migration_info.get("script", ""),
+                migration_info.get("checksum"),
+                migration_info.get("installed_by", "dblift"),
+                migration_info.get("execution_time", 0),
+                migration_info.get("success", True),
+            ],
+        )
+
+    def record_undo(
+        self,
+        schema: str,
+        version: str,
+        table_name: Optional[str] = None,
+        script_name: Optional[str] = None,
+    ) -> bool:
+        """Record a successful undo in Snowflake migration history."""
+        undo_script = script_name or f"UNDO_{version}.sql"
+        self.record_migration(
+            schema,
+            {
+                "version": version,
+                "description": f"Undo migration {version}",
+                "type": "UNDO_SQL",
+                "script": undo_script,
+                "checksum": 0,
+                "success": True,
+            },
+            table_name or "dblift_schema_history",
+        )
+        return True
+
+    def repair_migration_history(
+        self,
+        schema: str,
+        script_name: str,
+        checksum: Any,
+        table_name: str = "dblift_schema_history",
+        success_value: Optional[Any] = None,
+    ) -> bool:
+        """Update checksum and success state for an existing migration row."""
+        normalized_table = table_name.upper()
+        if not self.table_exists(schema, normalized_table):
+            return False
+        qualified_table = self.get_schema_qualified_name(
+            schema,
+            normalized_table,
+        )
+        result = self.execute_statement(
+            f"""
+            UPDATE {qualified_table}
+            SET checksum = ?, success = COALESCE(?, success)
+            WHERE script = ?
+            """,
+            params=[checksum, success_value, script_name],
+        )
+        return result > 0
+
+    def create_history_table(self, schema: str, table_name: str) -> str:
+        """Return SQL for the Snowflake migration history table."""
+        qualified_table = self.get_schema_qualified_name(schema, table_name)
+        return f"""
+            CREATE TABLE IF NOT EXISTS {qualified_table} (
+                installed_rank INTEGER AUTOINCREMENT
+                    START 1 INCREMENT 1 PRIMARY KEY,
+                version VARCHAR(50),
+                description VARCHAR(200) NOT NULL,
+                type VARCHAR(20) NOT NULL,
+                script VARCHAR(1000) NOT NULL,
+                checksum VARCHAR(64),
+                installed_by VARCHAR(100) NOT NULL,
+                installed_on TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP(),
+                execution_time INTEGER NOT NULL,
+                success BOOLEAN NOT NULL
+            )
+        """
+
+
+__all__ = ["SnowflakeProvider"]
+
+
+_SNOWFLAKE_VIEWS_QUERY = """
+    SELECT table_name AS object_name
+    FROM INFORMATION_SCHEMA.VIEWS
+    WHERE TABLE_SCHEMA = UPPER(?)
+    ORDER BY table_name
+"""
+
+_SNOWFLAKE_TABLES_QUERY = """
+    SELECT table_name AS object_name
+    FROM INFORMATION_SCHEMA.TABLES
+    WHERE TABLE_SCHEMA = UPPER(?)
+      AND TABLE_TYPE = 'BASE TABLE'
+    ORDER BY table_name
+"""
+
+_SNOWFLAKE_SEQUENCES_QUERY = """
+    SELECT sequence_name AS object_name
+    FROM INFORMATION_SCHEMA.SEQUENCES
+    WHERE SEQUENCE_SCHEMA = UPPER(?)
+    ORDER BY sequence_name
+"""

dblift-2.6.0/db/plugins/snowflake/quirks.py

@@ -0,0 +1,70 @@
+"""Snowflake :class:`DialectQuirks`."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+from db.base_quirks import BaseQuirks
+
+if TYPE_CHECKING:
+    from core.sql_generator.alter.base_alter_generator import (
+        BaseAlterGenerator,
+    )
+    from core.sql_generator.base_generator import BaseSqlGenerator
+
+
+class SnowflakeQuirks(BaseQuirks):
+    """Snowflake-specific dialect behaviour."""
+
+    supports_transactions = True
+    supports_transactional_ddl = False
+    schema_required = True
+    uppercase_identifiers = True
+    clean_strategy = "native"
+    sqlglot_dialect = "snowflake"
+    default_schema_name = "PUBLIC"
+    drop_supports_if_exists = True
+    table_drop_style = "if_exists_cascade"
+    unquoted_identifier_case = "uppercase"
+    quote_qualified_folds_to_uppercase = True
+    connection_identifier_attrs = ("url", "account")
+    missing_connection_identifier_hint = "Snowflake requires url or account"
+    native_url_schema_params = ("schema",)
+    native_driver_display = "snowflake-connector-python"
+    pygments_lexer = "sql"
+
+    def __init__(self, dialect_name: str = "snowflake") -> None:
+        super().__init__(dialect_name=dialect_name)
+
+    def has_connection_identifier(self, database_config: Any) -> bool:
+        """Snowflake accepts a URL or an account identifier."""
+        if isinstance(database_config, dict):
+            url = database_config.get("url")
+            account = database_config.get("account")
+            if not account:
+                account = database_config.get("host")
+        else:
+            url = getattr(database_config, "url", None)
+            account = getattr(database_config, "account", None) or getattr(
+                database_config, "host", None
+            )
+        return bool(str(url or "").strip() or str(account or "").strip())
+
+    def ddl_generator_class(self) -> Optional[Type["BaseSqlGenerator"]]:
+        """Snowflake rich DDL generation is registered by higher tiers."""
+        return None
+
+    def alter_generator_class(self) -> Optional[Type["BaseAlterGenerator"]]:
+        """Snowflake ALTER generation is registered by higher tiers."""
+        return None
+
+    def introspector_class(self) -> Optional[Type[Any]]:
+        """Snowflake rich introspection is registered by higher tiers."""
+        return None
+
+    def vendor_queries_class(self) -> Optional[Type[Any]]:
+        """Snowflake metadata queries are registered by higher tiers."""
+        return None
+
+
+__all__ = ["SnowflakeQuirks"]