sqlalchemy-cubrid 1.2.3__tar.gz → 1.4.0__tar.gz

{sqlalchemy_cubrid-1.2.3/sqlalchemy_cubrid.egg-info → sqlalchemy_cubrid-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-cubrid
-Version: 1.2.3
+Version: 1.4.0
 Summary: CUBRID dialect for SQLAlchemy
 Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>, Gyeongjun Paik <paikend@gmail.com>
 License-Expression: MIT
@@ -10,7 +10,7 @@ Project-URL: Documentation, https://github.com/cubrid-labs/sqlalchemy-cubrid/tre
 Project-URL: Changelog, https://github.com/cubrid-labs/sqlalchemy-cubrid/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/cubrid-labs/sqlalchemy-cubrid/issues
 Keywords: SQLAlchemy,CUBRID,dialect
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -45,12 +45,12 @@ Requires-Dist: alembic>=1.7; extra == "dev"
 Provides-Extra: alembic
 Requires-Dist: alembic>=1.7; extra == "alembic"
 Provides-Extra: pycubrid
-Requires-Dist: pycubrid<2.0,>=1.0; extra == "pycubrid"
+Requires-Dist: pycubrid<2.0,>=1.2.0; extra == "pycubrid"
 Dynamic: license-file
 
 # sqlalchemy-cubrid
 
-**SQLAlchemy 2.0–2.1 dialect for the CUBRID database** — Python ORM, schema reflection, Alembic migrations, and full type system support.
+**SQLAlchemy 2.0–2.1 dialect for the CUBRID database** — Python ORM, schema reflection, Alembic migrations, and type mapping for SQLAlchemy and CUBRID-specific types.
 
 [🇰🇷 한국어](docs/README.ko.md) · [🇺🇸 English](README.md) · [🇨🇳 中文](docs/README.zh.md) · [🇮🇳 हिन्दी](docs/README.hi.md) · [🇩🇪 Deutsch](docs/README.de.md) · [🇷🇺 Русский](docs/README.ru.md)
 
@@ -66,6 +66,8 @@ Dynamic: license-file
 
 ---
 
+> **Status: Beta.** The core public API follows semantic versioning; minor releases may add features and bug fixes while the project remains under active development.
+
 ## Why sqlalchemy-cubrid?
 
 CUBRID is a high-performance open-source relational database, widely adopted in
@@ -75,7 +77,9 @@ production-ready SQLAlchemy dialect that supports the modern 2.0–2.1 API.
 **sqlalchemy-cubrid** bridges that gap:
 
 - Full SQLAlchemy 2.0–2.1 dialect with **statement caching** and **PEP 561 typing**
-- **426 offline tests** with **99%+ code coverage** — no database required to run them
+- **597 offline tests** with **99%+ code coverage** — no database required to run them
+- **Concurrency stress tests** — `QueuePool` sync threaded + asyncio.gather workloads validated against live CUBRID
+- **SQLAlchemy 2.2-ready compat shim** — private API access wrapped in `_compat.py` (still pinned `<2.2` until full SA 2.2 validation)
 - Tested against **4 CUBRID versions** (10.2, 11.0, 11.2, 11.4) across **Python 3.10 -- 3.14**
 - CUBRID-specific DML constructs: `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`
 - Alembic migration support out of the box
@@ -181,14 +185,23 @@ async with AsyncSession(engine) as session:
 
 ## Features
 
-- Complete type system -- numeric, string, date/time, bit, LOB, collection, and JSON types
+- Type mapping for SQLAlchemy standard and CUBRID-specific types — numeric, string, date/time, bit, LOB, collection, and JSON types
 - SQL compilation -- SELECT, JOIN, CAST, LIMIT/OFFSET, subqueries, CTEs, window functions
 - DML extensions -- `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`, `FOR UPDATE`, `TRUNCATE`
 - DDL support -- `COMMENT`, `IF NOT EXISTS` / `IF EXISTS`, `AUTO_INCREMENT`
 - Schema reflection -- tables, views, columns, PKs, FKs, indexes, unique constraints, comments
 - Alembic migrations via `CubridImpl` (auto-discovered entry point)
 - All 6 CUBRID isolation levels (dual-granularity: class-level + instance-level)
-- Async support — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+- Async support (available since v1.1.0) — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+
+## Known Limitations
+
+- **No `RETURNING`** — `INSERT/UPDATE/DELETE ... RETURNING` not supported; use `cursor.lastrowid` or `LAST_INSERT_ID()`
+- **No sequences** — CUBRID uses `AUTO_INCREMENT` only
+- **No multi-schema** — single schema per database
+- **DDL auto-commits** — migrations are not transactional (`transactional_ddl = False`)
+- **SQLAlchemy 2.0–2.1 only** — pinned to `<2.2` due to internal API dependencies ([details](docs/ARCHITECTURE.md))
+- **Async requires pycubrid ≥ 1.1.0** — the `cubrid+aiopycubrid://` driver needs the async-capable pycubrid
 
 ## Documentation
 
@@ -214,6 +227,8 @@ async with AsyncSession(engine) as session:
 | CUBRID | 10.2, 11.0, 11.2, 11.4 |
 | SQLAlchemy | 2.0–2.1 |
 | Alembic | >=1.7 |
+| pycubrid (sync) | >=1.2.0 |
+| pycubrid (async) | >=1.2.0 |
 
 ## FAQ
 

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/README.md

@@ -1,6 +1,6 @@
 # sqlalchemy-cubrid
 
-**SQLAlchemy 2.0–2.1 dialect for the CUBRID database** — Python ORM, schema reflection, Alembic migrations, and full type system support.
+**SQLAlchemy 2.0–2.1 dialect for the CUBRID database** — Python ORM, schema reflection, Alembic migrations, and type mapping for SQLAlchemy and CUBRID-specific types.
 
 [🇰🇷 한국어](docs/README.ko.md) · [🇺🇸 English](README.md) · [🇨🇳 中文](docs/README.zh.md) · [🇮🇳 हिन्दी](docs/README.hi.md) · [🇩🇪 Deutsch](docs/README.de.md) · [🇷🇺 Русский](docs/README.ru.md)
 
@@ -16,6 +16,8 @@
 
 ---
 
+> **Status: Beta.** The core public API follows semantic versioning; minor releases may add features and bug fixes while the project remains under active development.
+
 ## Why sqlalchemy-cubrid?
 
 CUBRID is a high-performance open-source relational database, widely adopted in
@@ -25,7 +27,9 @@ production-ready SQLAlchemy dialect that supports the modern 2.0–2.1 API.
 **sqlalchemy-cubrid** bridges that gap:
 
 - Full SQLAlchemy 2.0–2.1 dialect with **statement caching** and **PEP 561 typing**
-- **426 offline tests** with **99%+ code coverage** — no database required to run them
+- **597 offline tests** with **99%+ code coverage** — no database required to run them
+- **Concurrency stress tests** — `QueuePool` sync threaded + asyncio.gather workloads validated against live CUBRID
+- **SQLAlchemy 2.2-ready compat shim** — private API access wrapped in `_compat.py` (still pinned `<2.2` until full SA 2.2 validation)
 - Tested against **4 CUBRID versions** (10.2, 11.0, 11.2, 11.4) across **Python 3.10 -- 3.14**
 - CUBRID-specific DML constructs: `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`
 - Alembic migration support out of the box
@@ -131,14 +135,23 @@ async with AsyncSession(engine) as session:
 
 ## Features
 
-- Complete type system -- numeric, string, date/time, bit, LOB, collection, and JSON types
+- Type mapping for SQLAlchemy standard and CUBRID-specific types — numeric, string, date/time, bit, LOB, collection, and JSON types
 - SQL compilation -- SELECT, JOIN, CAST, LIMIT/OFFSET, subqueries, CTEs, window functions
 - DML extensions -- `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`, `FOR UPDATE`, `TRUNCATE`
 - DDL support -- `COMMENT`, `IF NOT EXISTS` / `IF EXISTS`, `AUTO_INCREMENT`
 - Schema reflection -- tables, views, columns, PKs, FKs, indexes, unique constraints, comments
 - Alembic migrations via `CubridImpl` (auto-discovered entry point)
 - All 6 CUBRID isolation levels (dual-granularity: class-level + instance-level)
-- Async support — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+- Async support (available since v1.1.0) — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+
+## Known Limitations
+
+- **No `RETURNING`** — `INSERT/UPDATE/DELETE ... RETURNING` not supported; use `cursor.lastrowid` or `LAST_INSERT_ID()`
+- **No sequences** — CUBRID uses `AUTO_INCREMENT` only
+- **No multi-schema** — single schema per database
+- **DDL auto-commits** — migrations are not transactional (`transactional_ddl = False`)
+- **SQLAlchemy 2.0–2.1 only** — pinned to `<2.2` due to internal API dependencies ([details](docs/ARCHITECTURE.md))
+- **Async requires pycubrid ≥ 1.1.0** — the `cubrid+aiopycubrid://` driver needs the async-capable pycubrid
 
 ## Documentation
 
@@ -164,6 +177,8 @@ async with AsyncSession(engine) as session:
 | CUBRID | 10.2, 11.0, 11.2, 11.4 |
 | SQLAlchemy | 2.0–2.1 |
 | Alembic | >=1.7 |
+| pycubrid (sync) | >=1.2.0 |
+| pycubrid (async) | >=1.2.0 |
 
 ## FAQ
 

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlalchemy-cubrid"
-version = "1.2.3"
+version = "1.4.0"
 description = "CUBRID dialect for SQLAlchemy"
 readme = "README.md"
 license = "MIT"
@@ -15,7 +15,7 @@ authors = [
 ]
 keywords = ["SQLAlchemy", "CUBRID", "dialect"]
 classifiers = [
-    "Development Status :: 5 - Production/Stable",
+    "Development Status :: 4 - Beta",
     "Environment :: Console",
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
@@ -54,7 +54,7 @@ alembic = [
     "alembic>=1.7",
 ]
 pycubrid = [
-    "pycubrid>=1.0,<2.0",
+    "pycubrid>=1.2.0,<2.0",
 ]
 
 [project.urls]

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/__init__.py

@@ -52,7 +52,7 @@ from sqlalchemy.sql.sqltypes import (
     TIMESTAMP,
 )
 
-__version__ = "1.2.3"
+__version__ = "1.4.0"
 
 __all__ = (
     "insert",

sqlalchemy_cubrid-1.4.0/sqlalchemy_cubrid/_compat.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy.sql import elements, visitors
+
+
+def is_literal_value(value: Any) -> bool:
+    """Check if value is a plain Python literal (not a SQL element or schema object)."""
+    if isinstance(value, visitors.Visitable):
+        return False
+    if hasattr(value, "__clause_element__"):
+        return False
+    return True
+
+
+def bind_with_type(element: elements.BindParameter[Any], type_: Any) -> elements.BindParameter[Any]:
+    """Create a new BindParameter preserving all flags but with the given type."""
+    return elements.BindParameter(
+        element.key,
+        element.value,
+        type_=type_,
+        unique=element.unique,
+        expanding=element.expanding,
+        literal_execute=element.literal_execute,
+        isoutparam=element.isoutparam,
+    )
+
+
+def get_for_update_arg(select: Any) -> Any | None:
+    return getattr(select, "_for_update_arg", None)
+
+
+def get_limit_clause(select: Any) -> Any | None:
+    return getattr(select, "_limit_clause", None)
+
+
+def get_offset_clause(select: Any) -> Any | None:
+    return getattr(select, "_offset_clause", None)

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/alembic_impl.py

@@ -158,6 +158,40 @@ class CubridImpl(DefaultImpl):
 
         return set(inspector_values) != set(metadata_values)
 
+    def alter_column(
+        self,
+        table_name: str,
+        column_name: str,
+        nullable: Any = None,
+        server_default: Any = False,
+        name: str | None = None,
+        type_: Any = None,
+        **kw: Any,
+    ) -> None:
+        if type_ is not None:
+            raise NotImplementedError(
+                f"CUBRID does not support ALTER COLUMN TYPE for column "
+                f"'{column_name}' on table '{table_name}'. "
+                f"Use batch_alter_table() as a workaround: "
+                f"https://alembic.sqlalchemy.org/en/latest/batch.html"
+            )
+        if name is not None:
+            raise NotImplementedError(
+                f"CUBRID does not support RENAME COLUMN for column "
+                f"'{column_name}' on table '{table_name}'. "
+                f"Use batch_alter_table() as a workaround: "
+                f"https://alembic.sqlalchemy.org/en/latest/batch.html"
+            )
+        super().alter_column(
+            table_name,
+            column_name,
+            nullable=nullable,
+            server_default=server_default,
+            name=name,
+            type_=type_,
+            **kw,
+        )
+
     @classmethod
     def _is_unbounded_string_match(
         cls, inspector_type: TypeEngine[Any], metadata_type: TypeEngine[Any]

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/base.py

@@ -9,13 +9,14 @@
 
 from __future__ import annotations
 
+import logging
 import re
 from typing import Any, cast
 
 from sqlalchemy.engine import default
 from sqlalchemy.sql import compiler
 
-
+log = logging.getLogger(__name__)
 AUTOCOMMIT_REGEXP = re.compile(
     r"\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|MERGE|TRUNCATE)", re.I | re.UNICODE
 )
@@ -416,7 +417,7 @@ class CubridExecutionContext(default.DefaultExecutionContext):
                 last_id = raw_conn.get_last_insert_id()
                 return cast(int, None) if last_id is None else int(last_id)  # pyright: ignore[reportInvalidCast]
         except Exception:  # nosec B110 — fallback to SQL when driver lacks method
-            pass
+            log.debug("get_last_insert_id via driver failed, falling back to SQL", exc_info=True)
 
         # Fallback: use SQL function
         cursor = self.create_server_side_cursor()

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/compiler.py

@@ -11,9 +11,18 @@ from __future__ import annotations
 
 from typing import Any
 
+from sqlalchemy.exc import CompileError
 from sqlalchemy.sql import compiler, elements
 from sqlalchemy.sql import sqltypes
 
+from sqlalchemy_cubrid._compat import (
+    bind_with_type,
+    get_for_update_arg,
+    get_limit_clause,
+    get_offset_clause,
+    is_literal_value,
+)
+
 
 class CubridCompiler(compiler.SQLCompiler):
     """SQLCompiler subclass for CUBRID."""
@@ -56,6 +65,8 @@ class CubridCompiler(compiler.SQLCompiler):
         **kwargs: Any,
     ) -> str:
         # https://www.cubrid.org/manual/en/11.0/sql/query/select.html#join-query
+        if getattr(join, "full", False):
+            raise CompileError("CUBRID does not support FULL OUTER JOIN")
         return "".join(
             (
                 self.process(join.left, asfrom=True, **kwargs),
@@ -66,6 +77,9 @@ class CubridCompiler(compiler.SQLCompiler):
             )
         )
 
+    def visit_lateral(self, lateral_: Any, **kw: Any) -> str:
+        raise CompileError("CUBRID does not support LATERAL")
+
     def for_update_clause(self, select: Any, **kw: Any) -> str:  # pyright: ignore[reportIncompatibleMethodOverride]
         """Render FOR UPDATE clause.
 
@@ -76,29 +90,30 @@ class CubridCompiler(compiler.SQLCompiler):
 
         CUBRID does NOT support NOWAIT or SKIP LOCKED.
         """
-        if select._for_update_arg is None:
+        for_update_arg = get_for_update_arg(select)
+        if for_update_arg is None:
             return ""
         text = " FOR UPDATE"
-        if select._for_update_arg.of:
-            text += " OF " + ", ".join(self.process(col, **kw) for col in select._for_update_arg.of)
+        if for_update_arg.of:
+            text += " OF " + ", ".join(self.process(col, **kw) for col in for_update_arg.of)
         return text
 
     def limit_clause(self, select: Any, **kw: Any) -> str:
         # https://www.cubrid.org/manual/en/11.0/sql/query/select.html#limit-clause
         # SA 2.0: _limit_clause / _offset_clause are ClauseElements, not raw ints.
-        limit_clause = select._limit_clause
-        offset_clause = select._offset_clause
+        limit_clause = get_limit_clause(select)
+        offset_clause = get_offset_clause(select)
         if limit_clause is None and offset_clause is None:
             return ""
-        elif limit_clause is None and offset_clause is not None:
+        if limit_clause is None:
+            assert offset_clause is not None
             return " \n LIMIT %s, 1073741823" % (self.process(offset_clause, **kw),)
-        elif offset_clause is not None:
+        if offset_clause is not None:
             return " \n LIMIT %s, %s" % (
                 self.process(offset_clause, **kw),
                 self.process(limit_clause, **kw),
             )
-        else:
-            return " \n LIMIT %s" % (self.process(limit_clause, **kw),)
+        return " \n LIMIT %s" % (self.process(limit_clause, **kw),)
 
     def update_limit_clause(self, update_stmt: Any) -> str | None:  # pyright: ignore[reportIncompatibleMethodOverride]
         # https://www.cubrid.org/manual/en/11.0/sql/query/update.html
@@ -162,14 +177,14 @@ class CubridCompiler(compiler.SQLCompiler):
 
         for column in (col for col in cols if col.key in on_duplicate_update):
             val = on_duplicate_update[column.key]
-            if coercions._is_literal(val):
+            if is_literal_value(val):
                 val = elements.BindParameter(None, val, type_=column.type)
                 value_text = self.process(val.self_group(), use_schema=False)
             else:
 
                 def replace(element: Any, captured_column: Any = column, **kw: Any) -> Any | None:
                     if isinstance(element, elements.BindParameter) and element.type._isnull:
-                        return element._with_binary_element_type(captured_column.type)
+                        return bind_with_type(element, captured_column.type)
                     elif (
                         isinstance(element, elements.ColumnClause)
                         and element.table is on_duplicate.inserted_alias
@@ -202,7 +217,7 @@ class CubridCompiler(compiler.SQLCompiler):
 
     def visit_merge(self, merge_stmt: Any, **kw: Any) -> str:
         from sqlalchemy import exc
-        from sqlalchemy.sql import coercions, elements
+        from sqlalchemy.sql import elements
 
         target = merge_stmt._target
         source = merge_stmt._using_source
@@ -240,7 +255,7 @@ class CubridCompiler(compiler.SQLCompiler):
             return self.process(column_key, **kw)
 
         def _render_value(value: Any, target_column: Any | None) -> str:
-            if coercions._is_literal(value):
+            if is_literal_value(value):
                 value = elements.BindParameter(
                     None,
                     value,

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/dialect.py

@@ -88,7 +88,9 @@ _RE_PRECISION_SCALE = re.compile(r"\((\d+)(?:,\s*(\d+))?\)")
 _RE_FOREIGN_KEY = re.compile(
     r"CONSTRAINT\s+\[(?P<name>[^\]]+)\]\s+FOREIGN\s+KEY\s*"
     r"\((?P<cols>[^)]+)\)\s+REFERENCES\s+"
-    r"\[(?P<ref_table>[^\]]+)\]\s*\((?P<ref_cols>[^)]+)\)",
+    r"\[(?P<ref_table>[^\]]+)\]\s*\((?P<ref_cols>[^)]+)\)"
+    r"(?:\s+ON\s+DELETE\s+(?P<ondelete>CASCADE|SET\s+NULL|NO\s+ACTION|RESTRICT))?"
+    r"(?:\s+ON\s+UPDATE\s+(?P<onupdate>CASCADE|SET\s+NULL|NO\s+ACTION|RESTRICT))?",
     re.IGNORECASE,
 )
 # Parses ``CONSTRAINT [name] UNIQUE KEY ([col1], [col2])`` from
@@ -195,6 +197,7 @@ class CubridDialect(default.DefaultDialect):
     supports_native_enum = False
     supports_native_boolean = False  # CUBRID uses SMALLINT for booleans
     supports_native_decimal = True
+    supports_native_lateral = False
 
     # Column options
     supports_sequences = False
@@ -270,6 +273,10 @@ class CubridDialect(default.DefaultDialect):
 
     def initialize(self, connection: Any) -> None:
         super().initialize(connection)
+        log.debug(
+            "CUBRID dialect initialized: server_version=%s",
+            self.server_version_info,
+        )
 
     # ----- Reflection methods -----
 
@@ -341,6 +348,7 @@ class CubridDialect(default.DefaultDialect):
             )
             comment_map = {row[0]: row[1] for row in comment_result}
         except Exception:
+            log.debug("Column comment query failed for %s", table_name, exc_info=True)
             comment_map = {}
 
         for column in columns:
@@ -380,7 +388,7 @@ class CubridDialect(default.DefaultDialect):
                 if row:
                     constraint_name = row[0]
             except Exception:  # nosec B110 — constraint name is optional metadata
-                pass
+                log.debug("PK constraint name query failed for %s", table_name, exc_info=True)
 
         return {
             "name": constraint_name,
@@ -409,6 +417,11 @@ class CubridDialect(default.DefaultDialect):
             result = connection.execute(text(f"SHOW CREATE TABLE {quoted}"))
             row = result.fetchone()
         except Exception:  # nosec B110 — graceful fallback when DDL unavailable
+            log.warning(
+                "SHOW CREATE TABLE failed for %s; foreign keys will be empty",
+                table_name,
+                exc_info=True,
+            )
             return foreign_keys
         if row is None:
             return foreign_keys
@@ -425,10 +438,16 @@ class CubridDialect(default.DefaultDialect):
             referred_columns = [
                 col.strip() for col in _RE_BRACKET_IDENT.findall(fk_match.group("ref_cols"))
             ]
+            options: dict[str, str] = {}
+            if fk_match.group("ondelete"):
+                options["ondelete"] = fk_match.group("ondelete").upper()
+            if fk_match.group("onupdate"):
+                options["onupdate"] = fk_match.group("onupdate").upper()
             foreign_keys.append(
                 {
                     "name": constraint_name,
                     "constrained_columns": constrained_columns,
+                    "options": options,
                     "referred_schema": schema,
                     "referred_table": ref_table,
                     "referred_columns": referred_columns,
@@ -553,6 +572,11 @@ class CubridDialect(default.DefaultDialect):
             result = connection.execute(text(f"SHOW CREATE TABLE {quoted}"))
             row = result.fetchone()
         except Exception:  # nosec B110 — graceful fallback when DDL unavailable
+            log.warning(
+                "SHOW CREATE TABLE failed for %s; unique constraints will be empty",
+                table_name,
+                exc_info=True,
+            )
             return unique_constraints
         if row is None:
             return unique_constraints
@@ -574,7 +598,9 @@ class CubridDialect(default.DefaultDialect):
         **kw: Any,
     ) -> list[ReflectedCheckConstraint]:
         """Return check constraints for *table_name*."""
-        # CUBRID does not expose check constraint expressions easily
+        # CUBRID parses CHECK constraint syntax but does not enforce them
+        # at runtime (official CUBRID behavior). Reflecting them would be
+        # misleading, so we return an empty list.
         return []
 
     @reflection.cache
@@ -624,14 +650,18 @@ class CubridDialect(default.DefaultDialect):
         schema: str | None = None,
         **kw: Any,
     ) -> bool:
-        """Check if an index exists on *table_name*."""
+        """Check if an index named *index_name* exists on *table_name*."""
         try:
             result = connection.execute(
-                text("SELECT COUNT(*) FROM _db_index WHERE index_name = :name"),
-                {"name": index_name},
+                text(
+                    "SELECT COUNT(*) FROM _db_index "
+                    "WHERE class_of.class_name = :table AND index_name = :name"
+                ),
+                {"table": table_name, "name": index_name},
             )
             return bool(result.scalar())
         except Exception:
+            log.debug("has_index query failed for %s.%s", table_name, index_name, exc_info=True)
             return False
 
     def has_sequence(
@@ -708,7 +738,7 @@ class CubridDialect(default.DefaultDialect):
         cursor.execute("SELECT X")
         row = cursor.fetchone()
         if row is None:
-            return "READ COMMITTED"
+            return "REPEATABLE READ SCHEMA, READ COMMITTED INSTANCES"
         val = row[0]
         cursor.close()
         # CUBRID returns numeric level; map to string for SA
@@ -755,10 +785,8 @@ class CubridDialect(default.DefaultDialect):
         cursor.close()
 
     def reset_isolation_level(self, dbapi_conn: DBAPIConnection) -> None:
-        """Revert isolation level to the default."""
-        # CUBRID server default is typically level 4
-        # (REPEATABLE READ SCHEMA, READ COMMITTED INSTANCES)
-        self.set_isolation_level(dbapi_conn, "READ COMMITTED")
+        """Revert isolation level to the CUBRID default (level 4)."""
+        self.set_isolation_level(dbapi_conn, "REPEATABLE READ SCHEMA, READ COMMITTED INSTANCES")
 
     def do_release_savepoint(self, connection: Any, name: str) -> None:
         """CUBRID does not support RELEASE SAVEPOINT; no-op."""

{sqlalchemy_cubrid-1.2.3 → sqlalchemy_cubrid-1.4.0}/sqlalchemy_cubrid/pycubrid_dialect.py

@@ -9,6 +9,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Callable, cast
 
 from sqlalchemy.engine.interfaces import DBAPIConnection, DBAPIModule, ConnectArgsType
@@ -17,6 +18,8 @@ from sqlalchemy.engine.url import URL
 from sqlalchemy_cubrid.base import CubridExecutionContext
 from sqlalchemy_cubrid.dialect import CubridDialect
 
+log = logging.getLogger(__name__)
+
 
 class PyCubridExecutionContext(CubridExecutionContext):
     """Execution context for pycubrid connections.
@@ -70,6 +73,7 @@ class PyCubridDialect(CubridDialect):
             import pycubrid as dbapi_module
         except ImportError as e:
             raise e
+        log.debug("Loaded pycubrid DBAPI (version %s)", getattr(dbapi_module, "__version__", "?"))
         return cast(DBAPIModule, dbapi_module)  # pyright: ignore[reportInvalidCast]
 
     # Keep legacy dbapi() for SA 1.x compat
@@ -88,13 +92,21 @@ class PyCubridDialect(CubridDialect):
             raise ValueError("Unexpected database URL format")
 
         opts = url.translate_connect_args(username="user", database="database")
-        return (), {
+        kwargs = {
             "host": opts.get("host", "localhost"),
             "port": opts.get("port", 33000),
             "database": opts.get("database", ""),
             "user": opts.get("user", "dba"),
             "password": opts.get("password", ""),
         }
+        log.debug(
+            "connect args: host=%s port=%s database=%s user=%s",
+            kwargs["host"],
+            kwargs["port"],
+            kwargs["database"],
+            kwargs["user"],
+        )
+        return (), kwargs
 
     def on_connect(self) -> Callable[[Any], None] | None:
         """Return a callable to set up a new pycubrid connection.
@@ -108,6 +120,7 @@ class PyCubridDialect(CubridDialect):
             conn.autocommit = False
             if isolation_level is not None:
                 self.set_isolation_level(conn, isolation_level)
+            log.debug("on_connect: autocommit=False isolation_level=%s", isolation_level)
 
         return connect