sqlalchemy-cubrid 0.7.1__py3-none-any.whl

sqlalchemy_cubrid/__init__.py

@@ -0,0 +1,85 @@
+# sqlalchemy_cubrid/__init__.py
+# Copyright (C) 2021-2026 by sqlalchemy-cubrid authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of sqlalchemy-cubrid and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""CUBRID dialect for SQLAlchemy.
+
+Each dialect provides the full set of typenames supported by that backend
+with its ``__all__`` collection.
+
+See: https://docs.sqlalchemy.org/en/20/core/type_basics.html#vendor-specific-types
+"""
+
+from __future__ import annotations
+
+from .types import (
+    BIGINT,
+    BIT,
+    BLOB,
+    CHAR,
+    CLOB,
+    DECIMAL,
+    DOUBLE,
+    DOUBLE_PRECISION,
+    FLOAT,
+    MONETARY,
+    MULTISET,
+    NCHAR,
+    NUMERIC,
+    NVARCHAR,
+    OBJECT,
+    REAL,
+    SEQUENCE,
+    SET,
+    SMALLINT,
+    STRING,
+    VARCHAR,
+)
+from .dml import insert, merge, replace
+from .trace import trace_query
+
+from sqlalchemy.sql.sqltypes import (
+    DATE,
+    DATETIME,
+    INTEGER,
+    TIME,
+    TIMESTAMP,
+)
+
+__version__ = "0.7.1"
+
+__all__ = (
+    "insert",
+    "merge",
+    "replace",
+    "trace_query",
+    "SMALLINT",
+    "INTEGER",
+    "BIGINT",
+    "NUMERIC",
+    "DECIMAL",
+    "FLOAT",
+    "REAL",
+    "DOUBLE",
+    "DOUBLE_PRECISION",
+    "MONETARY",
+    "DATE",
+    "TIME",
+    "TIMESTAMP",
+    "DATETIME",
+    "BIT",
+    "CHAR",
+    "VARCHAR",
+    "NCHAR",
+    "NVARCHAR",
+    "STRING",
+    "BLOB",
+    "CLOB",
+    "SET",
+    "MULTISET",
+    "SEQUENCE",
+    "OBJECT",
+)

sqlalchemy_cubrid/alembic_impl.py

@@ -0,0 +1,145 @@
+# sqlalchemy_cubrid/alembic_impl.py
+# Copyright (C) 2021-2026 by sqlalchemy-cubrid authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of sqlalchemy-cubrid and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""Alembic migration support for the CUBRID dialect.
+
+This module provides the Alembic ``DefaultImpl`` subclass that enables
+Alembic migrations against a CUBRID database.  It is registered as an
+entry-point under ``alembic.ddl`` so that Alembic auto-discovers it
+when the target database URL uses the ``cubrid://`` scheme.
+
+Usage::
+
+    # alembic.ini
+    [alembic]
+    sqlalchemy.url = cubrid://dba:password@localhost:33000/demodb
+
+    # That's it — Alembic will pick up the CUBRID implementation
+    # automatically via the ``alembic.ddl`` entry point.
+
+CUBRID-specific notes
+---------------------
+* **DDL is auto-committed** — CUBRID implicitly commits every DDL
+  statement, so ``transactional_ddl`` is set to ``False``.
+* **No ALTER COLUMN TYPE** — CUBRID does not support changing a
+  column's data type via ``ALTER TABLE … MODIFY``.  Alembic's
+  ``alter_column(type_=…)`` will raise.  Use ``batch_alter_table``
+  (table recreate) as a workaround.
+* **No RENAME COLUMN** — CUBRID ≤ 11.x does not support
+  ``ALTER TABLE … RENAME COLUMN``.  Alembic's ``alter_column(new_column_name=…)``
+  will raise.  Use ``batch_alter_table`` (table recreate) as a
+  workaround.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+import sqlalchemy as sa
+
+try:
+    from alembic.ddl.impl import DefaultImpl
+except ImportError:  # pragma: no cover — optional dependency
+    raise ImportError(
+        "Alembic is required for migration support. Install it with: pip install sqlalchemy-cubrid[alembic]"
+    ) from None
+
+if TYPE_CHECKING:
+    from typing import Protocol
+
+    from sqlalchemy.sql.type_api import TypeEngine
+
+    class AutogenContextLike(Protocol):
+        imports: set[str]
+
+
+class CubridImpl(DefaultImpl):
+    """Alembic migration implementation for CUBRID.
+
+    Registered via the ``alembic.ddl`` entry-point so Alembic
+    auto-discovers it for ``cubrid://`` URLs.
+
+    Attributes
+    ----------
+    __dialect__ : str
+        ``"cubrid"`` — matches the SQLAlchemy dialect name.
+    transactional_ddl : bool
+        ``False`` — CUBRID implicitly commits DDL statements.
+    """
+
+    __dialect__: str = "cubrid"
+    transactional_ddl: bool = False
+
+    _collection_type_names: set[str] = {"SET", "MULTISET", "SEQUENCE"}
+
+    @staticmethod
+    def _normalize_collection_value(value: object) -> str:
+        if isinstance(value, str):
+            return value.strip().lower()
+        if isinstance(value, sa.types.TypeEngine):
+            return value.__class__.__name__.lower()
+        return repr(value).strip().lower()
+
+    def render_type(
+        self, type_obj: TypeEngine[Any], autogen_context: AutogenContextLike
+    ) -> str | Literal[False]:
+        if type(type_obj).__module__ != "sqlalchemy_cubrid.types":
+            return False
+
+        type_name = type_obj.__class__.__name__
+        if type_name not in self._collection_type_names:
+            return False
+
+        values = getattr(type_obj, "_ddl_values", ())
+        rendered_values: list[str] = []
+
+        for value in values:
+            if isinstance(value, str):
+                rendered_values.append(repr(value))
+            elif isinstance(value, sa.types.TypeEngine):
+                rendered_values.append(value.__class__.__name__)
+            else:
+                rendered_values.append(repr(value))
+
+        autogen_context.imports.add("from sqlalchemy_cubrid import types as cubrid_types")
+        args = ", ".join(rendered_values)
+        return f"cubrid_types.{type_name}({args})"
+
+    def compare_type(
+        self, inspector_column: sa.Column[Any], metadata_column: sa.Column[Any]
+    ) -> bool:
+        inspector_type = inspector_column.type
+        metadata_type = metadata_column.type
+
+        inspector_name = inspector_type.__class__.__name__
+        metadata_name = metadata_type.__class__.__name__
+
+        is_inspector_collection = inspector_name in self._collection_type_names
+        is_metadata_collection = metadata_name in self._collection_type_names
+
+        if not is_inspector_collection and not is_metadata_collection:
+            return super().compare_type(inspector_column, metadata_column)
+
+        if is_inspector_collection != is_metadata_collection:
+            return True
+
+        if inspector_name != metadata_name:
+            return True
+
+        inspector_values = [
+            self._normalize_collection_value(value)
+            for value in getattr(inspector_type, "_ddl_values", ())
+        ]
+        metadata_values = [
+            self._normalize_collection_value(value)
+            for value in getattr(metadata_type, "_ddl_values", ())
+        ]
+
+        if inspector_name == "SEQUENCE":
+            return inspector_values != metadata_values
+
+        return set(inspector_values) != set(metadata_values)

sqlalchemy_cubrid/base.py

@@ -0,0 +1,428 @@
+# sqlalchemy_cubrid/base.py
+# Copyright (C) 2021-2026 by sqlalchemy-cubrid authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of sqlalchemy-cubrid and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""CUBRID identifier preparation, execution context, and reserved words."""
+
+from __future__ import annotations
+
+import re
+
+from sqlalchemy.engine import default
+from sqlalchemy.sql import compiler
+
+
+AUTOCOMMIT_REGEXP = re.compile(
+    r"\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|MERGE|TRUNCATE)", re.I | re.UNICODE
+)
+
+# CUBRID Reserved words
+# https://www.cubrid.org/manual/en/11.0/sql/keyword.html
+RESERVED_WORDS = frozenset(
+    {
+        "absolute",
+        "action",
+        "add",
+        "add_months",
+        "after",
+        "all",
+        "allocate",
+        "alter",
+        "and",
+        "any",
+        "are",
+        "as",
+        "asc",
+        "assertion",
+        "at",
+        "attach",
+        "attribute",
+        "avg",
+        "before",
+        "between",
+        "bigint",
+        "bit",
+        "bit_length",
+        "blob",
+        "boolean",
+        "both",
+        "breadth",
+        "by",
+        "call",
+        "cascade",
+        "cascaded",
+        "case",
+        "cast",
+        "catalog",
+        "change",
+        "char",
+        "character",
+        "check",
+        "class",
+        "classes",
+        "clob",
+        "close",
+        "coalesce",
+        "collate",
+        "collation",
+        "column",
+        "commit",
+        "connect",
+        "connect_by_iscycle",
+        "connect_by_isleaf",
+        "connect_by_root",
+        "connection",
+        "constraint",
+        "constraints",
+        "continue",
+        "convert",
+        "corresponding",
+        "count",
+        "create",
+        "cross",
+        "current",
+        "current_date",
+        "current_datetime",
+        "current_time",
+        "current_timestamp",
+        "current_user",
+        "cursor",
+        "cycle",
+        "data",
+        "data_type",
+        "database",
+        "date",
+        "datetime",
+        "day",
+        "day_hour",
+        "day_millisecond",
+        "day_minute",
+        "day_second",
+        "deallocate",
+        "dec",
+        "decimal",
+        "declare",
+        "default",
+        "deferrable",
+        "deferred",
+        "delete",
+        "depth",
+        "desc",
+        "describe",
+        "descriptor",
+        "diagnostics",
+        "difference",
+        "disconnect",
+        "distinct",
+        "distinctrow",
+        "div",
+        "do",
+        "domain",
+        "double",
+        "duplicate",
+        "drop",
+        "each",
+        "else",
+        "elseif",
+        "end",
+        "equals",
+        "escape",
+        "evaluate",
+        "except",
+        "exception",
+        "exec",
+        "execute",
+        "exists",
+        "external",
+        "extract",
+        "false",
+        "fetch",
+        "file",
+        "first",
+        "float",
+        "for",
+        "foreign",
+        "found",
+        "from",
+        "full",
+        "function",
+        "general",
+        "get",
+        "global",
+        "go",
+        "goto",
+        "grant",
+        "group",
+        "having",
+        "hour",
+        "hour_millisecond",
+        "hour_minute",
+        "hour_second",
+        "identity",
+        "if",
+        "ignore",
+        "immediate",
+        "in",
+        "index",
+        "indicator",
+        "inherit",
+        "initially",
+        "inner",
+        "inout",
+        "input",
+        "insert",
+        "int",
+        "integer",
+        "intersect",
+        "intersection",
+        "interval",
+        "into",
+        "is",
+        "isolation",
+        "join",
+        "key",
+        "language",
+        "last",
+        "leading",
+        "leave",
+        "left",
+        "less",
+        "level",
+        "like",
+        "limit",
+        "list",
+        "local",
+        "local_transaction_id",
+        "localtime",
+        "localtimestamp",
+        "loop",
+        "lower",
+        "match",
+        "max",
+        "method",
+        "millisecond",
+        "min",
+        "minute",
+        "minute_millisecond",
+        "minute_second",
+        "mod",
+        "modify",
+        "module",
+        "month",
+        "multiset",
+        "multiset_of",
+        "na",
+        "names",
+        "national",
+        "natural",
+        "nchar",
+        "next",
+        "no",
+        "none",
+        "not",
+        "null",
+        "nullif",
+        "numeric",
+        "object",
+        "octet_length",
+        "of",
+        "off",
+        "on",
+        "only",
+        "open",
+        "optimization",
+        "option",
+        "or",
+        "order",
+        "out",
+        "outer",
+        "output",
+        "overlaps",
+        "parameters",
+        "partial",
+        "position",
+        "precision",
+        "prepare",
+        "preserve",
+        "primary",
+        "prior",
+        "privileges",
+        "procedure",
+        "query",
+        "read",
+        "real",
+        "recursive",
+        "ref",
+        "references",
+        "referencing",
+        "relative",
+        "rename",
+        "replace",
+        "resignal",
+        "restrict",
+        "return",
+        "returns",
+        "revoke",
+        "right",
+        "role",
+        "rollback",
+        "rollup",
+        "routine",
+        "row",
+        "rownum",
+        "rows",
+        "savepoint",
+        "schema",
+        "scope",
+        "scroll",
+        "search",
+        "second",
+        "second_millisecond",
+        "section",
+        "select",
+        "sensitive",
+        "sequence",
+        "sequence_of",
+        "serializable",
+        "session",
+        "session_user",
+        "set",
+        "set_of",
+        "seteq",
+        "shared",
+        "siblings",
+        "signal",
+        "similar",
+        "size",
+        "smallint",
+        "some",
+        "sql",
+        "sqlcode",
+        "sqlerror",
+        "sqlexception",
+        "sqlstate",
+        "sqlwarning",
+        "statistics",
+        "string",
+        "subclass",
+        "subset",
+        "subseteq",
+        "substring",
+        "sum",
+        "superclass",
+        "superset",
+        "superseteq",
+        "sys_connect_by_path",
+        "sys_date",
+        "sys_datetime",
+        "sys_time",
+        "sys_timestamp",
+        "sysdate",
+        "sysdatetime",
+        "system_user",
+        "systime",
+        "table",
+        "temporary",
+        "then",
+        "time",
+        "timestamp",
+        "timezone_hour",
+        "timezone_minute",
+        "to",
+        "trailing",
+        "transaction",
+        "translate",
+        "translation",
+        "trigger",
+        "trim",
+        "true",
+        "truncate",
+        "under",
+        "union",
+        "unique",
+        "unknown",
+        "update",
+        "upper",
+        "usage",
+        "use",
+        "user",
+        "using",
+        "utime",
+        "value",
+        "values",
+        "varchar",
+        "variable",
+        "varying",
+        "vclass",
+        "view",
+        "when",
+        "whenever",
+        "where",
+        "while",
+        "with",
+        "without",
+        "work",
+        "write",
+        "xor",
+        "year",
+        "year_month",
+        "zone",
+    }
+)
+
+
+class CubridIdentifierPreparer(compiler.IdentifierPreparer):
+    """Quoting logic for CUBRID identifiers."""
+
+    reserved_words = RESERVED_WORDS
+
+    def __init__(
+        self,
+        dialect,
+        initial_quote='"',
+        final_quote=None,
+        escape_quote='"',
+        omit_schema=False,
+    ):
+        super().__init__(dialect, initial_quote, final_quote, escape_quote, omit_schema)
+
+    def _quote_free_identifiers(self, *ids):
+        """Unilaterally identifier-quote any number of strings."""
+        return tuple(self.quote_identifier(i) for i in ids if i is not None)
+
+
+class CubridExecutionContext(default.DefaultExecutionContext):
+    """Execution context for CUBRID connections."""
+
+    def should_autocommit_text(self, statement):
+        return AUTOCOMMIT_REGEXP.match(statement)
+
+    def get_lastrowid(self):
+        """Return the last inserted row ID.
+
+        CUBRID's Python driver does not expose ``cursor.lastrowid``.
+        Instead, the connection object provides ``get_last_insert_id()``.
+        We also fall back to ``SELECT LAST_INSERT_ID()`` if the method
+        is unavailable.
+        """
+        try:
+            # CUBRID Python driver exposes this on the raw connection
+            raw_conn = self.root_connection.connection.dbapi_connection
+            if hasattr(raw_conn, "get_last_insert_id"):
+                return raw_conn.get_last_insert_id()
+        except Exception:  # nosec B110 — fallback to SQL when driver lacks method
+            pass
+
+        # Fallback: use SQL function
+        cursor = self.create_server_side_cursor()
+        try:
+            cursor.execute("SELECT LAST_INSERT_ID()")
+            row = cursor.fetchone()
+            if row:
+                return int(row[0])
+        finally:
+            cursor.close()
+        return None