dblift 3.3.2__tar.gz → 3.3.4__tar.gz

{dblift-3.3.2 → dblift-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.3.2
+Version: 3.3.4
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -115,8 +115,8 @@ Dynamic: license-file
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.2 → dblift-3.3.4}/README.md

@@ -6,8 +6,8 @@
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.2 → dblift-3.3.4}/core/logger/_formatters.py

@@ -6,6 +6,7 @@ from ``core.logger.log`` for back-compat. JSON / HTML formatters live in
 """
 
 import logging
+import sys
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -15,6 +16,51 @@ from core.logger._levels import LogEvent, LogLevel
 _logger = logging.getLogger(__name__)
 
 
+def resolve_dblift_package_version() -> Optional[str]:
+    """Return the installed ``dblift`` distribution version for log banners.
+
+    Prefer ``importlib.metadata`` (correct for wheels and frozen binaries).
+    Avoid walking the filesystem first: under PyInstaller ``Path(__file__)``
+    can resolve to a unrelated ``__init__.py`` and print a stale version.
+    """
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+    except ImportError:  # pragma: no cover - Python <3.8
+        from importlib_metadata import PackageNotFoundError, version  # type: ignore
+
+    try:
+        return version("dblift")
+    except PackageNotFoundError:
+        pass
+    except Exception as e:
+        _logger.debug(f"Could not get dblift version from importlib.metadata: {e}")
+
+    try:
+        import dblift  # type: ignore[import-untyped]
+
+        ver = getattr(dblift, "__version__", None)
+        if ver:
+            return str(ver)
+    except (ImportError, AttributeError):
+        pass
+
+    # Dev checkouts only (skip when frozen — MEIPASS layout is not a git tree)
+    if not getattr(sys, "frozen", False):
+        try:
+            init_file = Path(__file__).parent.parent.parent / "__init__.py"
+            if init_file.exists():
+                with open(init_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        if line.startswith("__version__"):
+                            parts = line.split("=", 1)
+                            if len(parts) == 2:
+                                return parts[1].strip().strip('"').strip("'")
+        except Exception as e:
+            _logger.debug(f"Could not read version from __init__.py: {e}")
+
+    return None
+
+
 class LogFormatter:
     """Base class for all log formatters."""
 
@@ -74,44 +120,7 @@ class TextFormatter(LogFormatter):
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         lines.append(f"Timestamp: {current_time}")
 
-        # Add Dblift version if available
-        # Try multiple methods to get the version, prioritizing source code
-        version = None
-
-        # Method 1: Try to read from source __init__.py file (most reliable for development)
-        try:
-            # Path from core/logger/_formatters.py to root __init__.py: up 3 levels
-            init_file = Path(__file__).parent.parent.parent / "__init__.py"
-            if init_file.exists():
-                with open(init_file, "r", encoding="utf-8") as f:
-                    for line in f:
-                        if line.startswith("__version__"):
-                            # Extract version from: __version__ = "x.y.z"
-                            parts = line.split("=", 1)
-                            if len(parts) == 2:
-                                version = parts[1].strip().strip('"').strip("'")
-                                break
-        except Exception as e:
-            _logger.debug(f"Could not read version from __init__.py: {e}")
-
-        # Method 2: Try to import directly from package (if source is in path)
-        if not version:
-            try:
-                import dblift  # type: ignore[import-untyped]
-
-                version = getattr(dblift, "__version__", None)
-            except (ImportError, AttributeError):
-                pass
-
-        # Method 3: Fallback to pkg_resources (for installed packages)
-        if not version:
-            try:
-                import pkg_resources  # type: ignore[import-untyped]
-
-                version = pkg_resources.get_distribution("dblift").version
-            except Exception as e:
-                _logger.debug(f"Could not get version from pkg_resources: {e}")
-
+        version = resolve_dblift_package_version()
         if version:
             lines.append(f"Dblift version: {version}")
 

{dblift-3.3.2 → dblift-3.3.4}/core/logger/formatters/jsonformatter.py

@@ -128,43 +128,11 @@ class JsonFormatter:
 
     def _get_version_info(self) -> Dict[str, Any]:
         """Return a dict with log_format_version and dblift_version."""
-        dblift_version = None
-
-        # Method 1: Try to read from source __init__.py file (most reliable for development)
-        try:
-            init_file = Path(__file__).parent.parent.parent.parent / "__init__.py"
-            if init_file.exists():
-                with open(init_file, "r", encoding="utf-8") as f:
-                    for line in f:
-                        if line.startswith("__version__"):
-                            parts = line.split("=", 1)
-                            if len(parts) == 2:
-                                dblift_version = parts[1].strip().strip('"').strip("'")
-                                break
-        except Exception as e:
-            _logger.debug(f"Could not read version from __init__.py: {e}")
-
-        # Method 2: Try to import directly from package (if source is in path)
-        if not dblift_version:
-            try:
-                import dblift  # type: ignore[import-untyped]
-
-                dblift_version = getattr(dblift, "__version__", None)
-            except (ImportError, AttributeError):
-                pass
-
-        # Method 3: Fallback to pkg_resources (for installed packages)
-        if not dblift_version:
-            try:
-                import pkg_resources  # type: ignore[import-untyped]
-
-                dblift_version = pkg_resources.get_distribution("dblift").version
-            except Exception as e:
-                _logger.debug(f"Could not get version from pkg_resources: {e}")
+        from core.logger._formatters import resolve_dblift_package_version
 
         return {
             "log_format_version": "1.0",
-            "dblift_version": dblift_version,
+            "dblift_version": resolve_dblift_package_version(),
         }
 
     def _build_time_metadata(self, result: OperationResult) -> Dict[str, Any]:

{dblift-3.3.2 → dblift-3.3.4}/db/plugins/cockroachdb/__init__.py

@@ -1,5 +1,13 @@
 """CockroachDB database provider plugin (PostgreSQL-compatible)."""
 
+# Side-effect import: register the SQLAlchemy dialect so create_engine can
+# resolve cockroachdb+psycopg even if plugin.py was not loaded yet.
+from db.plugins.cockroachdb.sqlalchemy_dialect import (  # noqa: F401
+    register_cockroach_dialect,
+)
+
+register_cockroach_dialect()
+
 __plugin_name__ = "cockroachdb"
 __plugin_version__ = "1.0.0"
 __plugin_description__ = "CockroachDB database provider"

{dblift-3.3.2 → dblift-3.3.4}/db/plugins/cockroachdb/plugin.py

@@ -11,9 +11,13 @@ from __future__ import annotations
 
 from db.plugins.cockroachdb.provider import CockroachdbProvider
 from db.plugins.cockroachdb.quirks import CockroachdbQuirks
-from db.plugins.postgresql.sqlalchemy_url import build_sqlalchemy_url
+from db.plugins.cockroachdb.sqlalchemy_dialect import register_cockroach_dialect
+from db.plugins.cockroachdb.sqlalchemy_url import build_sqlalchemy_url
 from db.provider_registry import PluginInfo
 
+# Register before any create_engine call can race plugin discovery.
+register_cockroach_dialect()
+
 PLUGIN: PluginInfo = PluginInfo(
     name="cockroachdb",
     version="1.0.0",

dblift-3.3.4/db/plugins/cockroachdb/sqlalchemy_dialect.py

@@ -0,0 +1,124 @@
+"""SQLAlchemy dialect for CockroachDB (PostgreSQL wire, CRDB version banner).
+
+SQLAlchemy's stock PostgreSQL dialect requires a ``PostgreSQL X.Y`` (or
+``EnterpriseDB``) prefix from ``select version()``. CockroachDB returns banners
+like::
+
+    CockroachDB CCL v24.3.18 (x86_64-pc-linux-gnu, built 2025/08/07 22:44:01, go1.22.8 ...)
+
+which raise ``AssertionError: Could not determine version from string`` on every
+``create_engine`` connect. This dialect reuses the psycopg PostgreSQL dialect
+and only overrides server-version parsing so the product version ``vX.Y.Z`` is
+used — never the trailing ``go1.x.y`` fragment.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Optional, Tuple
+
+from sqlalchemy.dialects.postgresql.psycopg import PGDialect_psycopg
+
+# Prefer an explicit product "vMAJOR.MINOR[.PATCH]" token (CRDB's usual form).
+_CRDB_V_TOKEN = re.compile(r"\bv(\d+)\.(\d+)(?:\.(\d+))?\b", re.IGNORECASE)
+# Fallback when the banner omits the leading ``v`` (older strings).
+_CRDB_DOTTED = re.compile(
+    r"CockroachDB(?:\s+CCL)?\s+(\d+)\.(\d+)(?:\.(\d+))?",
+    re.IGNORECASE,
+)
+
+_registered = False
+
+
+def parse_cockroach_server_version(banner: str) -> Tuple[int, ...]:
+    """Return ``(major, minor[, patch])`` from a CockroachDB ``version()`` banner.
+
+    Raises:
+        AssertionError: when no product version can be extracted (same shape as
+            SQLAlchemy's PostgreSQL dialect failure).
+    """
+    text = banner or ""
+    match = _CRDB_V_TOKEN.search(text)
+    if match is None:
+        match = _CRDB_DOTTED.search(text)
+    if match is None:
+        raise AssertionError(f"Could not determine version from string '{banner}'")
+    major = int(match.group(1))
+    minor = int(match.group(2))
+    patch = match.group(3)
+    if patch is not None:
+        return (major, minor, int(patch))
+    return (major, minor)
+
+
+class CockroachDBDialect_psycopg(PGDialect_psycopg):
+    """PostgreSQL+psycopg dialect that accepts CockroachDB version banners."""
+
+    name = "cockroachdb"
+    driver = "psycopg"
+    # Inherit PG caching semantics; SQLAlchemy warns if a subclass omits this.
+    supports_statement_cache = True
+
+    def _get_server_version_info(self, connection: Any) -> Tuple[int, ...]:
+        raw = connection.exec_driver_sql("select version()").scalar()
+        return parse_cockroach_server_version(str(raw) if raw is not None else "")
+
+
+def register_cockroach_dialect() -> None:
+    """Register ``cockroachdb`` / ``cockroachdb.psycopg`` with SQLAlchemy once."""
+    global _registered
+    if _registered:
+        return
+    from sqlalchemy.dialects import registry
+
+    registry.register(
+        "cockroachdb",
+        "db.plugins.cockroachdb.sqlalchemy_dialect",
+        "CockroachDBDialect_psycopg",
+    )
+    registry.register(
+        "cockroachdb.psycopg",
+        "db.plugins.cockroachdb.sqlalchemy_dialect",
+        "CockroachDBDialect_psycopg",
+    )
+    _registered = True
+
+
+def ensure_cockroach_drivername(drivername: str) -> str:
+    """Map a PostgreSQL-family drivername onto ``cockroachdb+psycopg``.
+
+    Only the ``psycopg`` DBAPI is registered for CockroachDB. Bare
+    ``postgresql`` / ``postgres`` / ``cockroachdb`` names and ``+psycopg``
+    variants rewrite cleanly; any other driver suffix (e.g. ``asyncpg``)
+    raises so ``create_engine`` does not fail later with an unloadable dialect.
+    """
+    if drivername in (
+        "cockroachdb",
+        "cockroachdb+psycopg",
+        "postgresql",
+        "postgres",
+        "postgresql+psycopg",
+        "postgres+psycopg",
+    ):
+        return "cockroachdb+psycopg"
+    if drivername.startswith(("postgresql+", "postgres+", "cockroachdb+")):
+        suffix = drivername.split("+", 1)[1]
+        if suffix != "psycopg":
+            raise ValueError(
+                "CockroachDB native connections require the psycopg driver "
+                f"(got {drivername!r}); use cockroachdb+psycopg or "
+                "postgresql+psycopg"
+            )
+        return "cockroachdb+psycopg"
+    raise ValueError(
+        "CockroachDB native connections require a PostgreSQL/CockroachDB "
+        f"SQLAlchemy URL (got drivername {drivername!r})"
+    )
+
+
+__all__ = [
+    "CockroachDBDialect_psycopg",
+    "ensure_cockroach_drivername",
+    "parse_cockroach_server_version",
+    "register_cockroach_dialect",
+]

dblift-3.3.4/db/plugins/cockroachdb/sqlalchemy_url.py

@@ -0,0 +1,93 @@
+"""SQLAlchemy URL construction for CockroachDB.
+
+Reuses the PostgreSQL URL shape (host/user/sslmode/search_path) but forces the
+``cockroachdb+psycopg`` drivername so SQLAlchemy loads
+:class:`CockroachDBDialect_psycopg` instead of the stock PostgreSQL dialect
+that cannot parse CockroachDB ``version()`` banners.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from sqlalchemy.engine import URL, make_url
+
+from db.plugins.cockroachdb.sqlalchemy_dialect import (
+    ensure_cockroach_drivername,
+    register_cockroach_dialect,
+)
+
+
+def _string_mapping(values: Any) -> Dict[str, str]:
+    if not isinstance(values, dict):
+        return {}
+    return {str(key): str(value) for key, value in values.items()}
+
+
+def _query_mapping(database_config: Any, base_query: Any = None) -> Dict[str, str]:
+    query = _string_mapping(base_query)
+    query.update(_string_mapping(getattr(database_config, "extra_params", None)))
+    query.update(_string_mapping(getattr(database_config, "options", None)))
+
+    connection_timeout = getattr(database_config, "connection_timeout", None)
+    if connection_timeout:
+        query["connect_timeout"] = str(connection_timeout)
+
+    ssl_mode = getattr(database_config, "ssl_mode", None)
+    if ssl_mode:
+        query["sslmode"] = str(ssl_mode)
+
+    schema = getattr(database_config, "schema", None)
+    if schema:
+        schema_option = f"-csearch_path={schema}"
+        query["options"] = (
+            f"{query['options']} {schema_option}" if query.get("options") else schema_option
+        )
+
+    return query
+
+
+def build_sqlalchemy_url(database_config: Any) -> str:
+    """Build a CockroachDB SQLAlchemy URL (psycopg driver, CRDB dialect)."""
+    register_cockroach_dialect()
+
+    raw_url = getattr(database_config, "url", None)
+    if isinstance(raw_url, str) and raw_url:
+        # Same scheme gate as the PostgreSQL builder, plus cockroachdb:// so a
+        # pre-rewritten URL still validates. Other schemes raise immediately.
+        if not raw_url.startswith(
+            (
+                "postgresql://",
+                "postgresql+",
+                "postgres://",
+                "postgres+",
+                "cockroachdb://",
+                "cockroachdb+",
+            )
+        ):
+            raise ValueError(
+                "CockroachDB native connections require a PostgreSQL/CockroachDB SQLAlchemy URL"
+            )
+        url = make_url(raw_url)
+        url = url.set(drivername=ensure_cockroach_drivername(url.drivername))
+        username = getattr(database_config, "username", None) or url.username or None
+        password = getattr(database_config, "password", None) or url.password or None
+        if username != url.username or password != url.password:
+            url = url.set(username=username, password=password)
+        query = _query_mapping(database_config, url.query)
+        if query != dict(url.query):
+            url = url.set(query=query)
+        return url.render_as_string(hide_password=False)
+
+    return URL.create(
+        "cockroachdb+psycopg",
+        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)
+
+
+__all__ = ["build_sqlalchemy_url"]

{dblift-3.3.2 → dblift-3.3.4}/db/plugins/duckdb/provider.py

@@ -27,12 +27,180 @@ class DuckDBProvider(SqlAlchemyProvider):
     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."""
+        """Execute a SQL statement, optionally preparing the schema first.
+
+        DuckDB/SQLAlchemy often reports ``rowcount == -1`` for DML. For single
+        INSERT/UPDATE/DELETE statements without parameters, append
+        ``RETURNING 1`` so callers (e.g. data corrections ``expect=N``) get a
+        real affected-row count.
+        """
         if schema:
             self.create_schema_if_not_exists(schema)
             self.set_current_schema(schema)
+
+        if params is None:
+            counted = self._try_dml_rowcount_via_returning(sql)
+            if counted is not None:
+                return counted
         return super().execute_statement(sql, schema=schema, params=params)
 
+    def _try_dml_rowcount_via_returning(self, sql: str) -> Optional[int]:
+        """Return affected-row count using RETURNING, or None if not applicable.
+
+        Returns None only when the statement is not rewritten (caller falls back
+        to the default path). Once execution is attempted, errors propagate —
+        do not re-run a failed statement via super() (that masks the root cause
+        as a follow-on \"transaction is aborted\" error).
+        """
+        stripped = self._strip_sql_comments(sql.strip()).rstrip(";").strip()
+        if not stripped:
+            return None
+        # Already has a top-level RETURNING clause — do not double-append
+        if self._has_top_level_keyword(stripped, "RETURNING"):
+            return None
+        # Normalize whitespace for statement-type checks only
+        upper = " ".join(stripped.upper().split())
+        if not (
+            upper.startswith("INSERT ")
+            or upper.startswith("UPDATE ")
+            or upper.startswith("DELETE ")
+        ):
+            return None
+
+        # Multi-statement scripts: leave to super (no silent rewrite)
+        if self._has_top_level_semicolon(stripped):
+            return None
+
+        rewritten = f"{stripped} RETURNING 1"
+        conn = self._ensure_connection()
+        driver_sql = self._escape_driver_percent_literals(rewritten, conn.dialect.paramstyle)
+        result = conn.exec_driver_sql(driver_sql)
+        rows = result.fetchall()
+        if self._tx is None and not getattr(self, "_external_connection", False):
+            conn.commit()
+        return len(rows)
+
+    @staticmethod
+    def _strip_sql_comments(sql: str) -> str:
+        """Remove ``--`` / ``/* */`` comments (and blank lines).
+
+        Strips leading directives, full-line mid-statement comments, and
+        trailing *inline* ``--`` on DML lines so an appended ``RETURNING 1``
+        is not commented out and keyword detection is not confused by the
+        word ``returning`` inside comments.
+        """
+        s = sql.lstrip()
+        # Leading block comments only (line comments handled per-line below)
+        while s.startswith("/*"):
+            end = s.find("*/")
+            if end < 0:
+                return ""
+            s = s[end + 2 :].lstrip()
+
+        kept: List[str] = []
+        for raw in s.splitlines():
+            line = DuckDBProvider._strip_inline_trailing_comment(raw)
+            if not line or line.lstrip().startswith("--"):
+                continue
+            # Drop leftover full-line block comments
+            if line.lstrip().startswith("/*") and line.rstrip().endswith("*/"):
+                continue
+            kept.append(line)
+        return "\n".join(kept).strip()
+
+    @staticmethod
+    def _strip_inline_trailing_comment(line: str) -> str:
+        """Strip trailing ``--`` or ``/* … */`` outside string/identifier quotes."""
+        in_single = in_double = False
+        i = 0
+        n = len(line)
+        cut: Optional[int] = None
+        while i < n:
+            ch = line[i]
+            if ch == "'" and not in_double:
+                if in_single and i + 1 < n and line[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and line[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif not in_single and not in_double:
+                if ch == "-" and i + 1 < n and line[i + 1] == "-":
+                    cut = i
+                    break
+                if ch == "/" and i + 1 < n and line[i + 1] == "*":
+                    # Only treat as trailing comment if it runs to end of line
+                    close = line.find("*/", i + 2)
+                    if close >= 0 and line[close + 2 :].strip() == "":
+                        cut = i
+                        break
+            i += 1
+        if cut is not None:
+            return line[:cut].rstrip()
+        return line.rstrip()
+
+    @staticmethod
+    def _has_top_level_semicolon(sql: str) -> bool:
+        """True if ``sql`` contains a semicolon outside string/identifier quotes."""
+        in_single = in_double = False
+        i = 0
+        n = len(sql)
+        while i < n:
+            ch = sql[i]
+            if ch == "'" and not in_double:
+                # SQL escaped single quote ''
+                if in_single and i + 1 < n and sql[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and sql[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif ch == ";" and not in_single and not in_double:
+                return True
+            i += 1
+        return False
+
+    @staticmethod
+    def _has_top_level_keyword(sql: str, keyword: str) -> bool:
+        """True if ``keyword`` appears as a top-level token outside quotes.
+
+        Used instead of a raw substring search so values like
+        ``SET note = ' returning '`` or mid-line comments mentioning
+        ``returning`` do not skip the RETURNING rewrite.
+        """
+        kw = keyword.upper()
+        kw_len = len(kw)
+        in_single = in_double = False
+        i = 0
+        n = len(sql)
+        while i < n:
+            ch = sql[i]
+            if ch == "'" and not in_double:
+                if in_single and i + 1 < n and sql[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and sql[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif not in_single and not in_double:
+                if sql[i : i + kw_len].upper() == kw:
+                    before_ok = i == 0 or not (sql[i - 1].isalnum() or sql[i - 1] == "_")
+                    after = i + kw_len
+                    after_ok = after >= n or not (sql[after].isalnum() or sql[after] == "_")
+                    if before_ok and after_ok:
+                        return True
+            i += 1
+        return False
+
     def create_schema_if_not_exists(self, schema: str) -> None:
         """Create a DuckDB schema if it is missing."""
         rows = self.execute_query(

{dblift-3.3.2 → dblift-3.3.4}/dblift.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.3.2
+Version: 3.3.4
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -115,8 +115,8 @@ Dynamic: license-file
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.2 → dblift-3.3.4}/dblift.egg-info/SOURCES.txt

@@ -295,6 +295,8 @@ db/plugins/cockroachdb/__init__.py
 db/plugins/cockroachdb/plugin.py
 db/plugins/cockroachdb/provider.py
 db/plugins/cockroachdb/quirks.py
+db/plugins/cockroachdb/sqlalchemy_dialect.py
+db/plugins/cockroachdb/sqlalchemy_url.py
 db/plugins/cosmosdb/__init__.py
 db/plugins/cosmosdb/config.py
 db/plugins/cosmosdb/plugin.py

{dblift-3.3.2 → dblift-3.3.4}/pyproject.toml

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