sqlalchemy-cubrid 1.3.0__tar.gz → 1.4.1__tar.gz

{sqlalchemy_cubrid-1.3.0/sqlalchemy_cubrid.egg-info → sqlalchemy_cubrid-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-cubrid
-Version: 1.3.0
+Version: 1.4.1
 Summary: CUBRID dialect for SQLAlchemy
 Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>, Gyeongjun Paik <paikend@gmail.com>
 License-Expression: MIT
@@ -36,8 +36,8 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: ruff==0.15.8; extra == "dev"
-Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: ruff==0.15.11; extra == "dev"
+Requires-Dist: mypy==1.20.1; extra == "dev"
 Requires-Dist: bandit[toml]==1.9.4; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: tox; extra == "dev"
@@ -45,7 +45,7 @@ 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
@@ -58,6 +58,7 @@ Dynamic: license-file
 [![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-cubrid)](https://pypi.org/project/sqlalchemy-cubrid)
 [![python version](https://img.shields.io/pypi/pyversions/sqlalchemy-cubrid)](https://www.python.org)
 [![ci workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml)
+[![integration-full workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml)
 [![coverage](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid/branch/main/graph/badge.svg)](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid)
 [![license](https://img.shields.io/github/license/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid/blob/main/LICENSE)
 [![GitHub stars](https://img.shields.io/github/stars/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid)
@@ -72,12 +73,14 @@ Dynamic: license-file
 
 CUBRID is a high-performance open-source relational database, widely adopted in
 Korean public-sector and enterprise applications. Until now, there was no
-production-ready SQLAlchemy dialect that supports the modern 2.0–2.1 API.
+actively maintained 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**
-- **577 offline tests** with **99%+ code coverage** — no database required to run them
+- **619 offline tests** with **~98.26% 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
@@ -190,7 +193,7 @@ async with AsyncSession(engine) as session:
 - 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 (available since v1.1.0) — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+- Async support — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
 
 ## Known Limitations
 
@@ -199,7 +202,7 @@ async with AsyncSession(engine) as session:
 - **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
+- **Async requires pycubrid >= 1.2.0,<2.0** — the `cubrid+aiopycubrid://` driver needs the async-capable pycubrid package line currently supported by this project
 
 ## Documentation
 
@@ -225,8 +228,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 |
+| pycubrid (sync) | >=1.2.0,<2.0 |
+| pycubrid (async) | >=1.2.0,<2.0 |
 
 ## FAQ
 
@@ -268,7 +271,7 @@ stmt = insert(users).values(name="Alice").on_duplicate_key_update(name="Alice Up
 
 ### Does sqlalchemy-cubrid support async?
 
-Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.1.0`. All Core and ORM features work with `AsyncSession`.
+Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.2.0,<2.0`. All Core and ORM features work with `AsyncSession`.
 
 
 ## Related Projects

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/README.md

@@ -8,6 +8,7 @@
 [![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-cubrid)](https://pypi.org/project/sqlalchemy-cubrid)
 [![python version](https://img.shields.io/pypi/pyversions/sqlalchemy-cubrid)](https://www.python.org)
 [![ci workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml)
+[![integration-full workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml)
 [![coverage](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid/branch/main/graph/badge.svg)](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid)
 [![license](https://img.shields.io/github/license/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid/blob/main/LICENSE)
 [![GitHub stars](https://img.shields.io/github/stars/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid)
@@ -22,12 +23,14 @@
 
 CUBRID is a high-performance open-source relational database, widely adopted in
 Korean public-sector and enterprise applications. Until now, there was no
-production-ready SQLAlchemy dialect that supports the modern 2.0–2.1 API.
+actively maintained 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**
-- **577 offline tests** with **99%+ code coverage** — no database required to run them
+- **619 offline tests** with **~98.26% 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
@@ -140,7 +143,7 @@ async with AsyncSession(engine) as session:
 - 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 (available since v1.1.0) — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+- Async support — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
 
 ## Known Limitations
 
@@ -149,7 +152,7 @@ async with AsyncSession(engine) as session:
 - **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
+- **Async requires pycubrid >= 1.2.0,<2.0** — the `cubrid+aiopycubrid://` driver needs the async-capable pycubrid package line currently supported by this project
 
 ## Documentation
 
@@ -175,8 +178,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 |
+| pycubrid (sync) | >=1.2.0,<2.0 |
+| pycubrid (async) | >=1.2.0,<2.0 |
 
 ## FAQ
 
@@ -218,7 +221,7 @@ stmt = insert(users).values(name="Alice").on_duplicate_key_update(name="Alice Up
 
 ### Does sqlalchemy-cubrid support async?
 
-Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.1.0`. All Core and ORM features work with `AsyncSession`.
+Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.2.0,<2.0`. All Core and ORM features work with `AsyncSession`.
 
 
 ## Related Projects

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlalchemy-cubrid"
-version = "1.3.0"
+version = "1.4.1"
 description = "CUBRID dialect for SQLAlchemy"
 readme = "README.md"
 license = "MIT"
@@ -43,8 +43,8 @@ dev = [
     "pytest>=7.0",
     "pytest-cov",
     "pytest-asyncio",
-    "ruff==0.15.8",
-    "mypy==1.19.1",
+    "ruff==0.15.11",
+    "mypy==1.20.1",
     "bandit[toml]==1.9.4",
     "pre-commit",
     "tox",
@@ -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.3.0 → sqlalchemy_cubrid-1.4.1}/sqlalchemy_cubrid/__init__.py

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

sqlalchemy_cubrid-1.4.1/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.3.0 → sqlalchemy_cubrid-1.4.1}/sqlalchemy_cubrid/compiler.py

@@ -15,6 +15,14 @@ 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."""
@@ -82,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
@@ -168,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
@@ -208,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
@@ -246,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.3.0 → sqlalchemy_cubrid-1.4.1}/sqlalchemy_cubrid/dialect.py

@@ -273,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 -----
 

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/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
 

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1/sqlalchemy_cubrid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-cubrid
-Version: 1.3.0
+Version: 1.4.1
 Summary: CUBRID dialect for SQLAlchemy
 Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>, Gyeongjun Paik <paikend@gmail.com>
 License-Expression: MIT
@@ -36,8 +36,8 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: ruff==0.15.8; extra == "dev"
-Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: ruff==0.15.11; extra == "dev"
+Requires-Dist: mypy==1.20.1; extra == "dev"
 Requires-Dist: bandit[toml]==1.9.4; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: tox; extra == "dev"
@@ -45,7 +45,7 @@ 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
@@ -58,6 +58,7 @@ Dynamic: license-file
 [![PyPI version](https://img.shields.io/pypi/v/sqlalchemy-cubrid)](https://pypi.org/project/sqlalchemy-cubrid)
 [![python version](https://img.shields.io/pypi/pyversions/sqlalchemy-cubrid)](https://www.python.org)
 [![ci workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/ci.yml)
+[![integration-full workflow](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml/badge.svg)](https://github.com/cubrid-labs/sqlalchemy-cubrid/actions/workflows/integration-full.yml)
 [![coverage](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid/branch/main/graph/badge.svg)](https://codecov.io/gh/cubrid-labs/sqlalchemy-cubrid)
 [![license](https://img.shields.io/github/license/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid/blob/main/LICENSE)
 [![GitHub stars](https://img.shields.io/github/stars/cubrid-labs/sqlalchemy-cubrid)](https://github.com/cubrid-labs/sqlalchemy-cubrid)
@@ -72,12 +73,14 @@ Dynamic: license-file
 
 CUBRID is a high-performance open-source relational database, widely adopted in
 Korean public-sector and enterprise applications. Until now, there was no
-production-ready SQLAlchemy dialect that supports the modern 2.0–2.1 API.
+actively maintained 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**
-- **577 offline tests** with **99%+ code coverage** — no database required to run them
+- **619 offline tests** with **~98.26% 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
@@ -190,7 +193,7 @@ async with AsyncSession(engine) as session:
 - 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 (available since v1.1.0) — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
+- Async support — `create_async_engine("cubrid+aiopycubrid://...")` via pycubrid.aio
 
 ## Known Limitations
 
@@ -199,7 +202,7 @@ async with AsyncSession(engine) as session:
 - **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
+- **Async requires pycubrid >= 1.2.0,<2.0** — the `cubrid+aiopycubrid://` driver needs the async-capable pycubrid package line currently supported by this project
 
 ## Documentation
 
@@ -225,8 +228,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 |
+| pycubrid (sync) | >=1.2.0,<2.0 |
+| pycubrid (async) | >=1.2.0,<2.0 |
 
 ## FAQ
 
@@ -268,7 +271,7 @@ stmt = insert(users).values(name="Alice").on_duplicate_key_update(name="Alice Up
 
 ### Does sqlalchemy-cubrid support async?
 
-Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.1.0`. All Core and ORM features work with `AsyncSession`.
+Yes. Use `create_async_engine("cubrid+aiopycubrid://...")` with the pycubrid async driver. Requires `pycubrid>=1.2.0,<2.0`. All Core and ORM features work with `AsyncSession`.
 
 
 ## Related Projects

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/sqlalchemy_cubrid.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ LICENSE
 README.md
 pyproject.toml
 sqlalchemy_cubrid/__init__.py
+sqlalchemy_cubrid/_compat.py
 sqlalchemy_cubrid/aio_pycubrid_dialect.py
 sqlalchemy_cubrid/alembic_impl.py
 sqlalchemy_cubrid/base.py
@@ -29,10 +30,12 @@ test/test_dialect_offline.py
 test/test_dialects.py
 test/test_integration.py
 test/test_json.py
+test/test_logging.py
 test/test_packaging.py
 test/test_pycubrid_dialect.py
 test/test_requirements.py
 test/test_show_create_table.py
+test/test_stress_pool.py
 test/test_suite.py
 test/test_trace.py
 test/test_types.py

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/sqlalchemy_cubrid.egg-info/requires.txt

@@ -10,12 +10,12 @@ CUBRID-Python
 pytest>=7.0
 pytest-cov
 pytest-asyncio
-ruff==0.15.8
-mypy==1.19.1
+ruff==0.15.11
+mypy==1.20.1
 bandit[toml]==1.9.4
 pre-commit
 tox
 alembic>=1.7
 
 [pycubrid]
-pycubrid<2.0,>=1.0
+pycubrid<2.0,>=1.2.0

{sqlalchemy_cubrid-1.3.0 → sqlalchemy_cubrid-1.4.1}/test/test_compiler.py

@@ -9,9 +9,11 @@ from __future__ import annotations
 
 import pytest
 import sqlalchemy as sa
+from typing import Any, cast
 from sqlalchemy import Column, Integer, MetaData, String, Table, select
 from sqlalchemy.exc import CompileError
 
+from sqlalchemy_cubrid._compat import bind_with_type, is_literal_value
 from sqlalchemy_cubrid.dialect import CubridDialect
 
 
@@ -256,6 +258,24 @@ class TestLiteralValueCompilation:
         assert "\\\\" in sql
 
 
+class TestCompatHelpers:
+    def test_is_literal_value(self):
+        assert is_literal_value(1) is True
+        assert is_literal_value("value") is True
+        assert is_literal_value(users.c.name) is False
+        assert is_literal_value(sa.literal("value")) is False
+
+    def test_bind_with_type(self):
+        element = sa.bindparam("name", "value")
+        typed_element = bind_with_type(element, users.c.name.type)
+
+        assert typed_element is not element
+        assert typed_element.key == element.key
+        assert typed_element.value == element.value
+        assert typed_element.unique == element.unique
+        assert isinstance(typed_element.type, users.c.name.type.__class__)
+
+
 class TestFunctionCompilation:
     """Test function compilation (SYSDATE, UTC_TIMESTAMP)."""
 
@@ -508,7 +528,7 @@ class TestTypeCompilation:
         """Test OBJECT type compilation via mock type."""
         from sqlalchemy.sql import sqltypes
 
-        class MockObject(sqltypes.TypeEngine):
+        class MockObject(sqltypes.TypeEngine[Any]):
             __visit_name__ = "OBJECT"
 
         obj = MockObject()
@@ -527,7 +547,7 @@ class TestTypeCompilation:
         """Test MONETARY type compilation via mock type."""
         from sqlalchemy.sql import sqltypes
 
-        class MockMonetary(sqltypes.TypeEngine):
+        class MockMonetary(sqltypes.TypeEngine[Any]):
             __visit_name__ = "MONETARY"
 
         mon = MockMonetary()
@@ -538,7 +558,7 @@ class TestTypeCompilation:
         """Test visit_datetime (lowercase) for datetime types."""
         from sqlalchemy.sql import sqltypes
 
-        class MockDatetime(sqltypes.TypeDecorator):
+        class MockDatetime(sqltypes.TypeDecorator[Any]):
             impl = sqltypes.DateTime
             __visit_name__ = "datetime"
 
@@ -550,7 +570,7 @@ class TestTypeCompilation:
         """Test visit_DATETIME (uppercase) for DATETIME types."""
         from sqlalchemy.sql import sqltypes
 
-        class MockDATETIME(sqltypes.TypeEngine):
+        class MockDATETIME(sqltypes.TypeEngine[Any]):
             __visit_name__ = "DATETIME"
 
         dt = MockDATETIME()
@@ -566,10 +586,11 @@ class TestTypeCompilation:
 
         t = VARCHAR(length=100)
         # _get(key, type_, kw) should return kw[key] or type_.key
-        result = compiler._get("length", t, {})
+        get_method = getattr(compiler, "_get")
+        result = get_method("length", t, {})
         assert result == 100
         # Test with kw override
-        result = compiler._get("length", t, {"length": 200})
+        result = get_method("length", t, {"length": 200})
         assert result == 200
 
 
@@ -1343,12 +1364,12 @@ class TestCoverageEdgeCases:
 
         def patched_process(element, **kw):
             if element is mock_cast.typeclause:
-                return None
+                return cast(str, cast(object, None))
             if element is mock_self_group:
                 return "users.name"
             return original_process(element, **kw)
 
-        compiler_obj.process = patched_process
+        object.__setattr__(compiler_obj, "process", patched_process)
         result = compiler_obj.visit_cast(mock_cast)
         assert result == "users.name"
 
@@ -1397,7 +1418,8 @@ class TestCoverageEdgeCases:
         ) as mock_prop:
             mock_exec = MagicMock(spec=[])
             mock_prop.return_value = mock_exec
-            result = compiler_obj.visit_on_duplicate_key_update(on_dup)
+            visit_on_duplicate_key_update = getattr(compiler_obj, "visit_on_duplicate_key_update")
+            result = visit_on_duplicate_key_update(on_dup)
         assert result == "ON DUPLICATE KEY UPDATE"
 
     def test_on_duplicate_key_update_isnull_bind_param(self):
@@ -1445,11 +1467,11 @@ class TestCoverageEdgeCases:
         from sqlalchemy_cubrid.dml import Merge
 
         stmt = Merge.__new__(Merge)
-        stmt._target = None
-        stmt._using_source = users
-        stmt._on_condition = users.c.id == users.c.id
-        stmt._when_matched = {"values": {"name": "test"}}
-        stmt._when_not_matched = None
+        object.__setattr__(stmt, "_target", None)
+        object.__setattr__(stmt, "_using_source", users)
+        object.__setattr__(stmt, "_on_condition", users.c.id == users.c.id)
+        object.__setattr__(stmt, "_when_matched", {"values": {"name": "test"}})
+        object.__setattr__(stmt, "_when_not_matched", None)
         with pytest.raises(Exception, match="requires a target table"):
             _compile(stmt)
 
@@ -1503,6 +1525,7 @@ class TestCoverageEdgeCases:
         stmt = stmt.when_matched_then_update({users.c.name: source.c.name})
         # Inject a processable element with no .name attr: sa.text()
         text_element = sa.text("custom_col")
+        assert stmt._when_matched is not None
         stmt._when_matched["values"][text_element] = source.c.name
         sql = _compile(stmt)
         assert "WHEN MATCHED THEN UPDATE SET" in sql
@@ -1575,7 +1598,7 @@ class TestDmlCoverage:
         )
         stmt = insert(t).values(id=1, name="test")
         # table.c is a ReadOnlyColumnCollection, which is a ColumnCollection
-        stmt = stmt.on_duplicate_key_update(t.c)
+        stmt = stmt.on_duplicate_key_update(dict(t.c))
         sql = _compile(stmt)
         assert "ON DUPLICATE KEY UPDATE" in sql
 
@@ -1615,7 +1638,7 @@ class TestDmlCoverage:
         )
         stmt = merge(target).using(source).on(target.c.id == source.c.id)
         # Pass ColumnCollection (table.c) as values_dict_or_column_list
-        stmt = stmt.when_not_matched_then_insert(source.c)
+        stmt = stmt.when_not_matched_then_insert(list(source.c))
         sql = _compile(stmt)
         assert "WHEN NOT MATCHED THEN INSERT" in sql
 
@@ -1688,7 +1711,7 @@ class TestDialectReflectionExceptionPaths:
         result = dialect.get_columns(conn, "test_table", None)
         assert len(result) == 1
         assert result[0]["name"] == "id"
-        assert result[0]["comment"] is None
+        assert result[0].get("comment") is None
 
     def test_get_pk_constraint_exception(self):
         """dialect.py lines 303-304: Exception in constraint query is caught."""

sqlalchemy_cubrid-1.4.1/test/test_logging.py

@@ -0,0 +1,95 @@
+"""Tests for logging output in sqlalchemy-cubrid dialect modules."""
+
+from __future__ import annotations
+
+import logging
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sqlalchemy_cubrid.pycubrid_dialect import PyCubridDialect
+
+
+class TestPyCubridDialectLogging:
+    """Verify PyCubridDialect emits expected log messages."""
+
+    def test_import_dbapi_logs_version(self, caplog: pytest.LogCaptureFixture) -> None:
+        """import_dbapi() should log the loaded pycubrid version."""
+        fake_module = MagicMock()
+        fake_module.__version__ = "1.2.0"
+
+        with patch.dict("sys.modules", {"pycubrid": fake_module}):
+            with caplog.at_level(logging.DEBUG, logger="sqlalchemy_cubrid.pycubrid_dialect"):
+                result = PyCubridDialect.import_dbapi()
+
+        assert any("pycubrid" in m and "1.2.0" in m for m in caplog.messages)
+        assert result is fake_module
+
+    def test_create_connect_args_logs(self, caplog: pytest.LogCaptureFixture) -> None:
+        """create_connect_args() should log connection target."""
+        dialect = PyCubridDialect()
+        url = MagicMock()
+        url.translate_connect_args.return_value = {
+            "host": "myhost",
+            "port": 33000,
+            "database": "mydb",
+            "user": "dba",
+            "password": "secret",
+        }
+
+        with caplog.at_level(logging.DEBUG, logger="sqlalchemy_cubrid.pycubrid_dialect"):
+            dialect.create_connect_args(url)
+
+        log_text = "\n".join(caplog.messages)
+        assert "myhost" in log_text
+        assert "33000" in log_text or "mydb" in log_text
+        assert "secret" not in log_text
+
+    def test_on_connect_logs_isolation_level(self, caplog: pytest.LogCaptureFixture) -> None:
+        """on_connect() should log isolation level setting."""
+        dialect = PyCubridDialect()
+        dialect._isolation_level = "SERIALIZABLE"
+
+        fn = dialect.on_connect()
+        assert fn is not None
+
+        mock_conn = MagicMock()
+        with caplog.at_level(logging.DEBUG, logger="sqlalchemy_cubrid.pycubrid_dialect"):
+            fn(mock_conn)
+
+        assert any("isolation_level" in m for m in caplog.messages)
+
+
+class TestCubridDialectLogging:
+    """Verify CubridDialect emits expected log messages."""
+
+    def test_dialect_has_module_logger(self) -> None:
+        """CubridDialect module should have a logger configured."""
+        import sqlalchemy_cubrid.dialect as dialect_mod
+
+        assert hasattr(dialect_mod, "log")
+        assert dialect_mod.log.name == "sqlalchemy_cubrid.dialect"
+
+
+class TestLoggingDoesNotLeakCredentials:
+    """Ensure credentials never appear in dialect log output."""
+
+    def test_create_connect_args_no_password_in_logs(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Password must never appear in log messages."""
+        dialect = PyCubridDialect()
+        url = MagicMock()
+        url.translate_connect_args.return_value = {
+            "host": "localhost",
+            "port": 33000,
+            "database": "testdb",
+            "user": "admin",
+            "password": "my_secret_pass_xyz",
+        }
+
+        with caplog.at_level(logging.DEBUG, logger="sqlalchemy_cubrid.pycubrid_dialect"):
+            dialect.create_connect_args(url)
+
+        full_log = "\n".join(caplog.messages)
+        assert "my_secret_pass_xyz" not in full_log

sqlalchemy_cubrid-1.4.1/test/test_stress_pool.py

@@ -0,0 +1,260 @@
+"""Connection pool concurrency stress tests against a live CUBRID instance.
+
+Exercises QueuePool concurrent checkouts (threading + asyncio), pool
+overflow under burst load, and pool_recycle behavior.
+
+Skipped automatically when no CUBRID instance is available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import threading
+import time
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+
+import pytest
+from sqlalchemy import create_engine, text
+from sqlalchemy.exc import TimeoutError as SATimeoutError
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.pool import QueuePool
+
+
+_DEFAULT_URL = "cubrid+pycubrid://dba@localhost:33000/testdb"
+_DEFAULT_AURL = "cubrid+aiopycubrid://dba@localhost:33000/testdb"
+
+
+def _sync_url() -> str:
+    return os.environ.get("CUBRID_TEST_URL", _DEFAULT_URL)
+
+
+def _async_url() -> str:
+    return os.environ.get("CUBRID_TEST_AURL", _DEFAULT_AURL)
+
+
+def _can_connect() -> bool:
+    try:
+        engine = create_engine(_sync_url())
+        with engine.connect() as conn:
+            conn.execute(text("SELECT 1"))
+        engine.dispose()
+        return True
+    except Exception:
+        return False
+
+
+pytestmark = pytest.mark.skipif(
+    not _can_connect(),
+    reason="CUBRID instance not available (set CUBRID_TEST_URL)",
+)
+
+
+def _table() -> str:
+    return f"sa_stress_{uuid.uuid4().hex[:8]}"
+
+
+@pytest.fixture
+def shared_table():
+    table = _table()
+    engine = create_engine(_sync_url())
+    with engine.begin() as conn:
+        conn.execute(
+            text(f"CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, worker INT, n INT)")
+        )
+    engine.dispose()
+    yield table
+    cleanup = create_engine(_sync_url())
+    with cleanup.begin() as conn:
+        conn.execute(text(f"DROP TABLE IF EXISTS {table}"))
+    cleanup.dispose()
+
+
+class TestQueuePoolConcurrency:
+    def test_concurrent_checkouts_within_pool_size(self, shared_table: str) -> None:
+        engine = create_engine(
+            _sync_url(),
+            poolclass=QueuePool,
+            pool_size=8,
+            max_overflow=0,
+            pool_timeout=10,
+        )
+        try:
+            n_workers = 8
+            per_worker = 20
+            errors: list[BaseException] = []
+            lock = threading.Lock()
+
+            def worker(idx: int) -> int:
+                try:
+                    with engine.begin() as conn:
+                        for i in range(per_worker):
+                            conn.execute(
+                                text(f"INSERT INTO {shared_table} (worker, n) VALUES (:w, :n)"),
+                                {"w": idx, "n": i},
+                            )
+                    with engine.connect() as conn:
+                        return conn.execute(
+                            text(f"SELECT COUNT(*) FROM {shared_table} WHERE worker = :w"),
+                            {"w": idx},
+                        ).scalar_one()
+                except BaseException as exc:
+                    with lock:
+                        errors.append(exc)
+                    return -1
+
+            with ThreadPoolExecutor(max_workers=n_workers) as ex:
+                results = list(ex.map(worker, range(n_workers)))
+
+            assert not errors, f"worker errors: {errors!r}"
+            assert all(r == per_worker for r in results), results
+        finally:
+            engine.dispose()
+
+    def test_overflow_absorbs_burst_then_settles(self, shared_table: str) -> None:
+        engine = create_engine(
+            _sync_url(),
+            poolclass=QueuePool,
+            pool_size=4,
+            max_overflow=12,
+            pool_timeout=15,
+        )
+        try:
+            n_workers = 16
+            errors: list[BaseException] = []
+            lock = threading.Lock()
+            barrier = threading.Barrier(n_workers)
+
+            def worker(idx: int) -> int:
+                try:
+                    barrier.wait(timeout=10)
+                    with engine.begin() as conn:
+                        conn.execute(
+                            text(f"INSERT INTO {shared_table} (worker, n) VALUES (:w, 0)"),
+                            {"w": idx},
+                        )
+                    return 1
+                except BaseException as exc:
+                    with lock:
+                        errors.append(exc)
+                    return -1
+
+            with ThreadPoolExecutor(max_workers=n_workers) as ex:
+                results = list(ex.map(worker, range(n_workers)))
+
+            assert not errors, f"burst errors: {errors!r}"
+            assert sum(results) == n_workers
+
+            with engine.connect() as conn:
+                total = conn.execute(text(f"SELECT COUNT(*) FROM {shared_table}")).scalar_one()
+            assert total == n_workers
+
+            assert engine.pool.checkedout() == 0
+        finally:
+            engine.dispose()
+
+    def test_pool_timeout_raises_when_exhausted(self) -> None:
+        engine = create_engine(
+            _sync_url(),
+            poolclass=QueuePool,
+            pool_size=2,
+            max_overflow=0,
+            pool_timeout=1,
+        )
+        try:
+            held = [engine.connect() for _ in range(2)]
+            try:
+                with pytest.raises(SATimeoutError):
+                    engine.connect()
+            finally:
+                for c in held:
+                    c.close()
+        finally:
+            engine.dispose()
+
+    def test_pool_recycle_replaces_old_connection(self) -> None:
+        engine = create_engine(
+            _sync_url(),
+            poolclass=QueuePool,
+            pool_size=2,
+            max_overflow=0,
+            pool_recycle=1,
+            pool_pre_ping=False,
+        )
+        try:
+            with engine.connect() as conn:
+                first_raw = conn.connection.dbapi_connection
+                conn.execute(text("SELECT 1"))
+
+            time.sleep(1.5)
+
+            with engine.connect() as conn:
+                second_raw = conn.connection.dbapi_connection
+                conn.execute(text("SELECT 1"))
+
+            assert first_raw is not second_raw
+        finally:
+            engine.dispose()
+
+
+class TestAsyncPoolConcurrency:
+    @pytest.mark.asyncio
+    async def test_async_gather_within_pool_size(self, shared_table: str) -> None:
+        engine = create_async_engine(
+            _async_url(),
+            pool_size=8,
+            max_overflow=0,
+            pool_timeout=10,
+        )
+        try:
+            n = 8
+            per_task = 15
+
+            async def worker(idx: int) -> int:
+                async with engine.begin() as conn:
+                    for i in range(per_task):
+                        await conn.execute(
+                            text(f"INSERT INTO {shared_table} (worker, n) VALUES (:w, :n)"),
+                            {"w": idx, "n": i},
+                        )
+                async with engine.connect() as conn:
+                    result = await conn.execute(
+                        text(f"SELECT COUNT(*) FROM {shared_table} WHERE worker = :w"),
+                        {"w": idx},
+                    )
+                    return result.scalar_one()
+
+            results = await asyncio.gather(*(worker(i) for i in range(n)))
+            assert all(r == per_task for r in results), results
+        finally:
+            await engine.dispose()
+
+    @pytest.mark.asyncio
+    async def test_async_overflow_burst(self, shared_table: str) -> None:
+        engine = create_async_engine(
+            _async_url(),
+            pool_size=4,
+            max_overflow=12,
+            pool_timeout=15,
+        )
+        try:
+            n = 16
+
+            async def worker(idx: int) -> int:
+                async with engine.begin() as conn:
+                    await conn.execute(
+                        text(f"INSERT INTO {shared_table} (worker, n) VALUES (:w, 0)"),
+                        {"w": idx},
+                    )
+                return 1
+
+            results = await asyncio.gather(*(worker(i) for i in range(n)))
+            assert sum(results) == n
+
+            async with engine.connect() as conn:
+                result = await conn.execute(text(f"SELECT COUNT(*) FROM {shared_table}"))
+                total = result.scalar_one()
+            assert total == n
+        finally:
+            await engine.dispose()