sqlspec 0.44.0__tar.gz → 0.45.0__tar.gz

{sqlspec-0.44.0 → sqlspec-0.45.0}/.gitignore

@@ -73,3 +73,4 @@ tools/scripts/profiles/*.prof
 # Beads / Dolt files (added by bd init)
 .dolt/
 .beads-credential-key
+.codex

{sqlspec-0.44.0 → sqlspec-0.45.0}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.15.11"
+    rev: "v0.15.12"
     hooks:
       - id: ruff
         args: ["--fix"]

{sqlspec-0.44.0 → sqlspec-0.45.0}/Makefile

@@ -221,7 +221,7 @@ pre-commit:                                        ## Run pre-commit hooks
 .PHONY: slotscheck
 slotscheck:                                        ## Run slotscheck
 	@echo "${INFO} Running slotscheck... 🔍"
-	@uv run slotscheck sqlspec/
+	@PYTHONWARNINGS="ignore:::google.adk.features._feature_decorator" uv run slotscheck sqlspec/
 	@echo "${OK} Slotscheck complete ✨"
 
 .PHONY: fix

{sqlspec-0.44.0 → sqlspec-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.44.0
+Version: 0.45.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/
@@ -68,7 +68,8 @@ Requires-Dist: msgspec; extra == 'msgspec'
 Provides-Extra: mypyc
 Requires-Dist: sqlglot[c]>=30.0.0; extra == 'mypyc'
 Provides-Extra: mysql-connector
-Requires-Dist: mysql-connector-python; extra == 'mysql-connector'
+Requires-Dist: mysql-connector-python; (python_version < '3.12') and extra == 'mysql-connector'
+Requires-Dist: mysql-connector-python<9.7.0; (python_version >= '3.12') and extra == 'mysql-connector'
 Provides-Extra: nanoid
 Requires-Dist: fastnanoid>=0.4.1; extra == 'nanoid'
 Provides-Extra: obstore
@@ -100,8 +101,12 @@ Provides-Extra: pymssql
 Requires-Dist: pymssql; extra == 'pymssql'
 Provides-Extra: pymysql
 Requires-Dist: pymysql; extra == 'pymysql'
+Provides-Extra: sanic
+Requires-Dist: sanic; extra == 'sanic'
 Provides-Extra: spanner
 Requires-Dist: google-cloud-spanner; extra == 'spanner'
+Provides-Extra: starlette
+Requires-Dist: starlette; extra == 'starlette'
 Provides-Extra: uuid
 Requires-Dist: uuid-utils; extra == 'uuid'
 Description-Content-Type: text/markdown
@@ -115,7 +120,7 @@ Description-Content-Type: text/markdown
 
 SQLSpec is a SQL execution layer for Python. You write the SQL -- as strings, through a builder API, or loaded from files -- and SQLSpec handles connections, parameter binding, SQL injection prevention, dialect translation, and mapping results back to typed Python objects. It uses [sqlglot](https://github.com/tobymao/sqlglot) under the hood to parse, validate, and optimize your queries before they hit the database.
 
-It works with PostgreSQL (asyncpg, psycopg, psqlpy), SQLite (sqlite3, aiosqlite), DuckDB, MySQL (asyncmy, mysql-connector, pymysql), Oracle (oracledb), CockroachDB, BigQuery, Spanner, and anything ADBC-compatible. Sync or async, same API. It also includes a built-in storage layer, native and bridged Arrow support for all drivers, and integrations for Litestar, FastAPI, Flask, and Starlette.
+It works with PostgreSQL (asyncpg, psycopg, psqlpy), SQLite (sqlite3, aiosqlite), DuckDB, MySQL (asyncmy, mysql-connector, pymysql), Oracle (oracledb), CockroachDB, BigQuery, Spanner, and anything ADBC-compatible. Sync or async, same API. It also includes a built-in storage layer, native and bridged Arrow support for all drivers, and integrations for Litestar, FastAPI, Flask, Sanic, and Starlette.
 
 ## Quick Start
 
@@ -165,7 +170,7 @@ users = session.select(
 - **Parameter binding and dialect translation** -- powered by sqlglot, with a fluent query builder and `.sql` file loader
 - **Result mapping** -- map rows to Pydantic, msgspec, attrs, or dataclass models, or export to Arrow tables for pandas and Polars
 - **Storage layer** -- read and write Arrow tables to local files, fsspec, or object stores
-- **Framework integrations** -- Litestar plugin with DI, Starlette/FastAPI middleware, Flask extension
+- **Framework integrations** -- Litestar plugin with DI, Starlette/FastAPI/Sanic middleware, Flask extension
 - **Observability** -- OpenTelemetry and Prometheus instrumentation, structured logging with correlation IDs
 - **Event channels** -- LISTEN/NOTIFY, Oracle AQ, and a portable polling fallback
 - **Migrations** -- schema versioning CLI built on Alembic

{sqlspec-0.44.0 → sqlspec-0.45.0}/README.md

@@ -7,7 +7,7 @@
 
 SQLSpec is a SQL execution layer for Python. You write the SQL -- as strings, through a builder API, or loaded from files -- and SQLSpec handles connections, parameter binding, SQL injection prevention, dialect translation, and mapping results back to typed Python objects. It uses [sqlglot](https://github.com/tobymao/sqlglot) under the hood to parse, validate, and optimize your queries before they hit the database.
 
-It works with PostgreSQL (asyncpg, psycopg, psqlpy), SQLite (sqlite3, aiosqlite), DuckDB, MySQL (asyncmy, mysql-connector, pymysql), Oracle (oracledb), CockroachDB, BigQuery, Spanner, and anything ADBC-compatible. Sync or async, same API. It also includes a built-in storage layer, native and bridged Arrow support for all drivers, and integrations for Litestar, FastAPI, Flask, and Starlette.
+It works with PostgreSQL (asyncpg, psycopg, psqlpy), SQLite (sqlite3, aiosqlite), DuckDB, MySQL (asyncmy, mysql-connector, pymysql), Oracle (oracledb), CockroachDB, BigQuery, Spanner, and anything ADBC-compatible. Sync or async, same API. It also includes a built-in storage layer, native and bridged Arrow support for all drivers, and integrations for Litestar, FastAPI, Flask, Sanic, and Starlette.
 
 ## Quick Start
 
@@ -57,7 +57,7 @@ users = session.select(
 - **Parameter binding and dialect translation** -- powered by sqlglot, with a fluent query builder and `.sql` file loader
 - **Result mapping** -- map rows to Pydantic, msgspec, attrs, or dataclass models, or export to Arrow tables for pandas and Polars
 - **Storage layer** -- read and write Arrow tables to local files, fsspec, or object stores
-- **Framework integrations** -- Litestar plugin with DI, Starlette/FastAPI middleware, Flask extension
+- **Framework integrations** -- Litestar plugin with DI, Starlette/FastAPI/Sanic middleware, Flask extension
 - **Observability** -- OpenTelemetry and Prometheus instrumentation, structured logging with correlation IDs
 - **Event channels** -- LISTEN/NOTIFY, Oracle AQ, and a portable polling fallback
 - **Migrations** -- schema versioning CLI built on Alembic

{sqlspec-0.44.0 → sqlspec-0.45.0}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.44.0"
+version = "0.45.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -51,7 +51,10 @@ fsspec = ["fsspec"]
 litestar = ["litestar"]
 msgspec = ["msgspec"]
 mypyc = ["sqlglot[c]>=30.0.0"]
-mysql-connector = ["mysql-connector-python"]
+mysql-connector = [
+  "mysql-connector-python; python_version < '3.12'",
+  "mysql-connector-python<9.7.0; python_version >= '3.12'",
+]
 nanoid = ["fastnanoid>=0.4.1"]
 obstore = ["obstore"]
 opentelemetry = ["opentelemetry-instrumentation"]
@@ -66,7 +69,9 @@ psycopg = ["psycopg[binary,pool]"]
 pydantic = ["pydantic", "pydantic-extra-types"]
 pymssql = ["pymssql"]
 pymysql = ["pymysql"]
+sanic = ["sanic"]
 spanner = ["google-cloud-spanner"]
+starlette = ["starlette"]
 uuid = ["uuid-utils"]
 
 [dependency-groups]
@@ -145,6 +150,7 @@ test = [
   "pytest-sugar>=1.0.0",
   "pytest-xdist>=3.6.1",
   "pytest-timeout>=2.3.1",
+  "sanic-testing",
 ]
 
 [project.scripts]
@@ -154,6 +160,16 @@ sqlspec = "sqlspec.__main__:run_cli"
 sqlspec-dark = "tools.sphinx_ext.pygments_styles:SQLSpecDarkStyle"
 sqlspec-light = "tools.sphinx_ext.pygments_styles:SQLSpecLightStyle"
 
+[tool.uv]
+# mysql-connector-python 9.7.0 dropped cp312/cp313/cp314 wheels (regression vs 9.6.0).
+# Override dependency metadata for every source that requests mysql-connector-python.
+# Keep the uncapped dependency on Python <3.12, and force the cap on Python >=3.12
+# so transitive pulls (e.g., pytest-databases[mysql]) resolve to an existing wheel.
+override-dependencies = [
+  "mysql-connector-python; python_version < '3.12'",
+  "mysql-connector-python<9.7.0; python_version >= '3.12'",
+]
+
 [build-system]
 build-backend = "hatchling.build"
 requires = ["hatchling", "hatch-mypyc"]
@@ -206,6 +222,10 @@ include = [
   "sqlspec/data_dictionary/**/*.py",       # Data dictionary mixin (required for adapter inheritance)
   "sqlspec/adapters/**/core.py",           # Adapter compiled helpers
   "sqlspec/adapters/**/type_converter.py", # All adapters type converters
+  "sqlspec/adapters/oracledb/_param_types.py",     # Slot-based LOB/JSON parameter wrappers
+  "sqlspec/adapters/oracledb/_json_handlers.py",   # Native JSON inputtypehandler / outputtypehandler chain
+  "sqlspec/adapters/oracledb/_uuid_handlers.py",   # UUID ↔ RAW(16) inputtypehandler / outputtypehandler chain
+  "sqlspec/adapters/oracledb/_vector_handlers.py", # DB_TYPE_VECTOR inputtypehandler / outputtypehandler dispatch
   "sqlspec/utils/text.py",                 # Text utilities
   "sqlspec/utils/sync_tools.py",           # Synchronous utility functions
   "sqlspec/utils/type_guards.py",          # Type guard utilities
@@ -244,7 +264,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.44.0"
+current_version = "0.45.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.44.0 → sqlspec-0.45.0}/sqlspec/adapters/oracledb/__init__.py

@@ -1,12 +1,15 @@
-import sqlspec.adapters.oracledb._numpy_handlers as numpy_handlers
-from sqlspec.adapters.oracledb._numpy_handlers import (
-    DTYPE_TO_ARRAY_CODE,
-    numpy_converter_in,
-    numpy_converter_out,
-    numpy_input_type_handler,
-    numpy_output_type_handler,
-    register_numpy_handlers,
+import sqlspec.adapters.oracledb._json_handlers as json_handlers
+import sqlspec.adapters.oracledb._vector_handlers as vector_handlers
+from sqlspec.adapters.oracledb._json_handlers import (
+    json_converter_in_blob,
+    json_converter_in_clob,
+    json_converter_out_blob,
+    json_converter_out_clob,
+    json_input_type_handler,
+    json_output_type_handler,
+    register_json_handlers,
 )
+from sqlspec.adapters.oracledb._param_types import OracleBlob, OracleClob, OracleJson
 from sqlspec.adapters.oracledb._typing import (
     OracleAsyncConnection,
     OracleAsyncCursor,
@@ -20,6 +23,14 @@ from sqlspec.adapters.oracledb._uuid_handlers import (
     uuid_input_type_handler,
     uuid_output_type_handler,
 )
+from sqlspec.adapters.oracledb._vector_handlers import (
+    DTYPE_TO_ARRAY_CODE,
+    numpy_converter_in,
+    numpy_converter_out,
+    numpy_input_type_handler,
+    numpy_output_type_handler,
+    register_numpy_handlers,
+)
 from sqlspec.adapters.oracledb.config import (
     OracleAsyncConfig,
     OracleConnectionParams,
@@ -42,8 +53,11 @@ __all__ = (
     "OracleAsyncCursor",
     "OracleAsyncDriver",
     "OracleAsyncExceptionHandler",
+    "OracleBlob",
+    "OracleClob",
     "OracleConnectionParams",
     "OracleDriverFeatures",
+    "OracleJson",
     "OraclePoolParams",
     "OracleSyncConfig",
     "OracleSyncConnection",
@@ -51,15 +65,23 @@ __all__ = (
     "OracleSyncDriver",
     "OracleSyncExceptionHandler",
     "default_statement_config",
+    "json_converter_in_blob",
+    "json_converter_in_clob",
+    "json_converter_out_blob",
+    "json_converter_out_clob",
+    "json_handlers",
+    "json_input_type_handler",
+    "json_output_type_handler",
     "numpy_converter_in",
     "numpy_converter_out",
-    "numpy_handlers",
     "numpy_input_type_handler",
     "numpy_output_type_handler",
+    "register_json_handlers",
     "register_numpy_handlers",
     "register_uuid_handlers",
     "uuid_converter_in",
     "uuid_converter_out",
     "uuid_input_type_handler",
     "uuid_output_type_handler",
+    "vector_handlers",
 )

sqlspec-0.45.0/sqlspec/adapters/oracledb/_json_handlers.py

@@ -0,0 +1,196 @@
+"""Oracle native JSON type handlers.
+
+Provides automatic conversion between Python ``dict`` / ``list`` / ``tuple`` values
+and Oracle's JSON storage types via connection type handlers.
+
+Routing matrix (input):
+
+* Oracle 21c+ native ``JSON``: bind via ``DB_TYPE_JSON`` (binary OSON).
+* Oracle 19c-20c with ``BLOB CHECK (... IS JSON)``: bind via ``DB_TYPE_BLOB`` with
+  UTF-8 JSON bytes.
+* Oracle 12c-18c with ``CLOB CHECK (... IS JSON)``: bind via ``DB_TYPE_CLOB`` with
+  serialized JSON string.
+* Server major version is read from ``connection._sqlspec_oracle_major`` (set in
+  ``OracleSyncConfig._init_connection`` / ``OracleAsyncConfig._init_connection``).
+  When unknown, default to 21c+ behavior.
+
+Routing matrix (output):
+
+* ``DB_TYPE_JSON``: passthrough (python-oracledb already returns ``dict``).
+* ``DB_TYPE_BLOB`` with ``JSON`` in column ``type_name``: parse via
+  ``json_converter_out_blob``.
+* ``DB_TYPE_CLOB`` with ``JSON`` in column ``type_name``: parse via
+  ``json_converter_out_clob``.
+
+Handlers chain to any pre-existing ``inputtypehandler`` / ``outputtypehandler``
+registered on the connection (e.g. NumPy vector, UUID), so registration order
+matters: register JSON after numpy, before UUID is also safe because each
+handler returns ``None`` for values it does not own.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from sqlspec.adapters.oracledb._typing import DB_TYPE_BLOB, DB_TYPE_CLOB, DB_TYPE_JSON
+from sqlspec.utils.serializers import from_json, to_json
+
+if TYPE_CHECKING:
+    from oracledb import AsyncConnection, AsyncCursor, Connection, Cursor
+
+__all__ = (
+    "json_converter_in_blob",
+    "json_converter_in_clob",
+    "json_converter_out_blob",
+    "json_converter_out_clob",
+    "json_input_type_handler",
+    "json_output_type_handler",
+    "register_json_handlers",
+)
+
+
+_JSON_TYPE_NAME_MARKER = "JSON"
+
+# Server-version thresholds for JSON binding strategy selection.
+# 21c+ supports DB_TYPE_JSON (binary OSON); 19c-20c uses BLOB CHECK (... IS JSON);
+# pre-19c uses CLOB CHECK (... IS JSON).
+_NATIVE_JSON_MIN_MAJOR = 21
+_BLOB_IS_JSON_MIN_MAJOR = 19
+
+
+def json_converter_in_clob(value: Any) -> str:
+    """Serialize a Python value to a JSON string for CLOB binding."""
+    return to_json(value)
+
+
+def json_converter_in_blob(value: Any) -> bytes:
+    """Serialize a Python value to UTF-8 JSON bytes for BLOB binding."""
+    return to_json(value, as_bytes=True)
+
+
+def json_converter_out_clob(value: "str | None") -> Any:
+    """Parse a JSON string from a CLOB read back into a Python value."""
+    if value is None:
+        return None
+    return from_json(value)
+
+
+def json_converter_out_blob(value: "bytes | None") -> Any:
+    """Parse JSON bytes from a BLOB read back into a Python value."""
+    if value is None:
+        return None
+    return from_json(value)
+
+
+def _is_json_payload(value: Any) -> bool:
+    """Return True if the value should be claimed by the JSON input handler.
+
+    ``dict`` and ``tuple``/``list`` of dicts are claimed. Sequences whose first
+    element is a number are NOT claimed — those are vector embeddings and
+    belong to the vector handler.
+    """
+    if isinstance(value, dict):
+        return True
+    if isinstance(value, (list, tuple)):
+        if not value:
+            # Empty sequence: ambiguous (could be empty vector or empty list).
+            # Defer to the next handler in the chain.
+            return False
+        first = value[0]
+        # Reject sequences of numbers (vector embeddings).
+        return not (isinstance(first, (int, float)) and not isinstance(first, bool))
+    return False
+
+
+def _input_type_handler(cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+    """Oracle input type handler for JSON-shaped Python values."""
+    if not _is_json_payload(value):
+        return None
+
+    server_major = getattr(cursor.connection, "_sqlspec_oracle_major", None)
+
+    if server_major is None or server_major >= _NATIVE_JSON_MIN_MAJOR:
+        return cursor.var(DB_TYPE_JSON, arraysize=arraysize)
+    if server_major >= _BLOB_IS_JSON_MIN_MAJOR:
+        return cursor.var(DB_TYPE_BLOB, arraysize=arraysize, inconverter=json_converter_in_blob)
+    return cursor.var(DB_TYPE_CLOB, arraysize=arraysize, inconverter=json_converter_in_clob)
+
+
+def _output_type_handler(cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+    """Oracle output type handler for JSON-bearing column reads."""
+    type_code = getattr(metadata, "type_code", None)
+
+    if type_code is DB_TYPE_JSON:
+        # Native JSON: python-oracledb returns dict/list directly. No conversion.
+        return None
+
+    type_name = (getattr(metadata, "type_name", "") or "").upper()
+    if _JSON_TYPE_NAME_MARKER not in type_name:
+        return None
+
+    if type_code is DB_TYPE_BLOB:
+        return cursor.var(DB_TYPE_BLOB, arraysize=cursor.arraysize, outconverter=json_converter_out_blob)
+    if type_code is DB_TYPE_CLOB:
+        return cursor.var(DB_TYPE_CLOB, arraysize=cursor.arraysize, outconverter=json_converter_out_clob)
+    return None
+
+
+def json_input_type_handler(cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+    """Public input type handler entry point."""
+    return _input_type_handler(cursor, value, arraysize)
+
+
+def json_output_type_handler(cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+    """Public output type handler entry point."""
+    return _output_type_handler(cursor, metadata)
+
+
+def register_json_handlers(connection: "Connection | AsyncConnection") -> None:
+    """Register JSON type handlers on an Oracle connection.
+
+    Chains to any existing handlers via ``_JsonInputHandler`` / ``_JsonOutputHandler``
+    wrapper classes so vector / UUID handlers continue to fire for non-JSON values.
+    """
+    try:
+        existing_input = connection.inputtypehandler
+    except AttributeError:
+        existing_input = None
+    try:
+        existing_output = connection.outputtypehandler
+    except AttributeError:
+        existing_output = None
+
+    connection.inputtypehandler = _JsonInputHandler(existing_input)
+    connection.outputtypehandler = _JsonOutputHandler(existing_output)
+
+
+class _JsonInputHandler:
+    """Chaining wrapper that claims dict/list/tuple values, falling back otherwise."""
+
+    __slots__ = ("_fallback",)
+
+    def __init__(self, fallback: "Any | None") -> None:
+        self._fallback = fallback
+
+    def __call__(self, cursor: "Cursor | AsyncCursor", value: Any, arraysize: int) -> Any:
+        result = _input_type_handler(cursor, value, arraysize)
+        if result is not None:
+            return result
+        if self._fallback is not None:
+            return self._fallback(cursor, value, arraysize)
+        return None
+
+
+class _JsonOutputHandler:
+    """Chaining wrapper that claims JSON-bearing columns, falling back otherwise."""
+
+    __slots__ = ("_fallback",)
+
+    def __init__(self, fallback: "Any | None") -> None:
+        self._fallback = fallback
+
+    def __call__(self, cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
+        result = _output_type_handler(cursor, metadata)
+        if result is not None:
+            return result
+        if self._fallback is not None:
+            return self._fallback(cursor, metadata)
+        return None

sqlspec-0.45.0/sqlspec/adapters/oracledb/_param_types.py

@@ -0,0 +1,46 @@
+"""Typed parameter wrappers for explicit Oracle LOB / JSON binding.
+
+These slot-based wrappers are an opt-in escape hatch for power users who need
+deterministic LOB or JSON routing regardless of the size-based heuristics in
+:func:`coerce_large_parameters_sync` / :func:`coerce_large_parameters_async`.
+
+Wrap a parameter value to express explicit intent:
+
+* :class:`OracleClob` — bind as ``DB_TYPE_CLOB`` regardless of length.
+* :class:`OracleBlob` — bind as ``DB_TYPE_BLOB`` regardless of length.
+* :class:`OracleJson` — bind as native JSON; defers to the C1 input handler.
+
+The wrappers themselves perform no validation — type discipline lives at the
+routing site so error messages can include database-context detail.
+"""
+
+from typing import Any
+
+__all__ = ("OracleBlob", "OracleClob", "OracleJson")
+
+
+class OracleClob:
+    """Mark a value to be bound as ``DB_TYPE_CLOB`` regardless of length."""
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: "str | bytes") -> None:
+        self.value = value
+
+
+class OracleBlob:
+    """Mark a value to be bound as ``DB_TYPE_BLOB`` regardless of length."""
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: "bytes | str") -> None:
+        self.value = value
+
+
+class OracleJson:
+    """Mark a value to be bound as native ``DB_TYPE_JSON`` regardless of detected version."""
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: Any) -> None:
+        self.value = value

{sqlspec-0.44.0 → sqlspec-0.45.0}/sqlspec/adapters/oracledb/_typing.py

@@ -7,7 +7,16 @@ compilation to avoid ABI boundary issues.
 import contextlib
 from typing import TYPE_CHECKING, Any, Protocol
 
-from oracledb import AsyncConnection, AsyncCursor, Connection, Cursor
+from oracledb import (
+    DB_TYPE_BLOB,
+    DB_TYPE_CLOB,
+    DB_TYPE_JSON,
+    DB_TYPE_RAW,
+    AsyncConnection,
+    AsyncCursor,
+    Connection,
+    Cursor,
+)
 from oracledb.pool import AsyncConnectionPool, ConnectionPool
 
 if TYPE_CHECKING:
@@ -217,6 +226,10 @@ class OracleAsyncSessionContext:
 
 
 __all__ = (
+    "DB_TYPE_BLOB",
+    "DB_TYPE_CLOB",
+    "DB_TYPE_JSON",
+    "DB_TYPE_RAW",
     "DB_TYPE_VECTOR",
     "OracleAsyncConnection",
     "OracleAsyncConnectionPool",

{sqlspec-0.44.0 → sqlspec-0.45.0}/sqlspec/adapters/oracledb/_uuid_handlers.py

@@ -7,6 +7,7 @@ via connection type handlers. Uses stdlib uuid (no external dependencies).
 import uuid
 from typing import TYPE_CHECKING, Any
 
+from sqlspec.adapters.oracledb._typing import DB_TYPE_RAW
 from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
@@ -76,10 +77,8 @@ def _input_type_handler(cursor: "Cursor | AsyncCursor", value: Any, arraysize: i
     Returns:
         Cursor variable with UUID converter if value is UUID, None otherwise.
     """
-    import oracledb
-
     if isinstance(value, uuid.UUID):
-        return cursor.var(oracledb.DB_TYPE_RAW, arraysize=arraysize, inconverter=uuid_converter_in)
+        return cursor.var(DB_TYPE_RAW, arraysize=arraysize, inconverter=uuid_converter_in)
     return None
 
 
@@ -95,11 +94,9 @@ def _output_type_handler(cursor: "Cursor | AsyncCursor", metadata: Any) -> Any:
     Returns:
         Cursor variable with UUID converter if column is RAW(16), None otherwise.
     """
-    import oracledb
-
     _name, type_code, _display_size, internal_size, _precision, _scale, _null_ok = metadata
 
-    if type_code is oracledb.DB_TYPE_RAW and internal_size == UUID_BINARY_SIZE:
+    if type_code is DB_TYPE_RAW and internal_size == UUID_BINARY_SIZE:
         return cursor.var(type_code, arraysize=cursor.arraysize, outconverter=uuid_converter_out)
     return None