sqlspec 0.47.0__tar.gz → 0.48.0__tar.gz

{sqlspec-0.47.0 → sqlspec-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.47.0
+Version: 0.48.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/
@@ -37,6 +37,9 @@ Provides-Extra: aiosqlite
 Requires-Dist: aiosqlite; extra == 'aiosqlite'
 Provides-Extra: alloydb
 Requires-Dist: google-cloud-alloydb-connector; extra == 'alloydb'
+Provides-Extra: arrow-odbc
+Requires-Dist: arrow-odbc>=10.4; extra == 'arrow-odbc'
+Requires-Dist: pyarrow; extra == 'arrow-odbc'
 Provides-Extra: asyncmy
 Requires-Dist: asyncmy; extra == 'asyncmy'
 Provides-Extra: asyncpg
@@ -65,6 +68,8 @@ Provides-Extra: litestar
 Requires-Dist: litestar>=2.22.0; extra == 'litestar'
 Provides-Extra: msgspec
 Requires-Dist: msgspec; extra == 'msgspec'
+Provides-Extra: mssql-python
+Requires-Dist: mssql-python>=1.7; extra == 'mssql-python'
 Provides-Extra: mypyc
 Requires-Dist: sqlglot[c]>=30.0.0; extra == 'mypyc'
 Provides-Extra: mysql-connector

{sqlspec-0.47.0 → sqlspec-0.48.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.47.0"
+version = "0.48.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -38,6 +38,7 @@ aiomysql = ["aiomysql"]
 aioodbc = ["aioodbc"]
 aiosqlite = ["aiosqlite"]
 alloydb = ["google-cloud-alloydb-connector"]
+arrow-odbc = ["arrow-odbc>=10.4", "pyarrow"]
 asyncmy = ["asyncmy"]
 asyncpg = ["asyncpg"]
 attrs = ["attrs", "cattrs"]
@@ -50,6 +51,7 @@ flask = ["flask"]
 fsspec = ["fsspec"]
 litestar = ["litestar>=2.22.0"]
 msgspec = ["msgspec"]
+mssql-python = ["mssql-python>=1.7"]
 mypyc = ["sqlglot[c]>=30.0.0"]
 mysql-connector = [
   "mysql-connector-python; python_version < '3.12'",
@@ -146,7 +148,7 @@ test = [
   "pytest>=8.0.0",
 
   "pytest-cov>=5.0.0",
-  "pytest-databases[postgres,oracle,bigquery,spanner]>=0.18.0",
+  "pytest-databases[postgres,oracle,bigquery,spanner]>=0.19.0",
   "pytest-mock>=3.14.0",
   "pytest-sugar>=1.0.0",
   "pytest-xdist>=3.6.1",
@@ -190,6 +192,7 @@ packages = ["sqlspec"]
 # Keep that smoke build from auto-discovering ignored scratch directories.
 packages = []
 
+
 [tool.hatch.build.targets.wheel.hooks.mypyc]
 dependencies = ["hatch-mypyc", "hatch-cython", "mypy>=2.0.0"]
 enable-by-default = false
@@ -289,7 +292,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.47.0"
+current_version = "0.48.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -397,6 +400,14 @@ filterwarnings = [
   "ignore:PROCEDURE .* does not exist:Warning",
   "ignore::Warning:aiomysql.cursors",
   "ignore:Exception ignored in:pytest.PytestUnraisableExceptionWarning",
+  # coverage 7.x stores per-process coverage data in sqlite. Those
+  # connections are GC'd non-deterministically by Python (often during
+  # xdist worker shutdown), surfacing tracebacks at random sites in
+  # stdlib/xdist/sqlglot. Tracemalloc confirms allocation in
+  # execnet/coverage code, not ours. Suppress the message globally.
+  "ignore:unclosed database:ResourceWarning",
+  # Same warning when pytest's unraisable-exception hook re-emits it.
+  "ignore:.*unclosed database.*:pytest.PytestUnraisableExceptionWarning",
 ]
 markers = [
   "xdist_group: pin tests sharing state to the same xdist worker (registered to silence PytestUnknownMarkWarning when xdist isn't actively loaded)",
@@ -415,6 +426,7 @@ markers = [
   "aiomysql: marks tests using aiomysql",
   "aioodbc: marks tests using aioodbc",
   "aiosqlite: marks tests using aiosqlite",
+  "arrow_odbc: marks tests using the arrow_odbc adapter",
   "asyncmy: marks tests using asyncmy",
   "asyncpg: marks tests using asyncpg",
   "duckdb_driver: marks tests using the duckdb driver",
@@ -422,6 +434,7 @@ markers = [
   "google_spanner: marks tests using google-cloud-spanner",
   "oracledb: marks tests using oracledb",
   "psycopg: marks tests using psycopg",
+  "mssql_python: marks tests using the mssql-python driver",
   "pymssql: marks tests using pymssql",
   "mysql_connector: marks tests using mysql-connector",
   "pymysql: marks tests using pymysql",
@@ -460,8 +473,12 @@ module = [
   "uvloop.*",
   "aiomysql",
   "aiomysql.*",
+  "arrow_odbc",
+  "arrow_odbc.*",
   "asyncmy",
   "asyncmy.*",
+  "mssql_python",
+  "mssql_python.*",
   "pyarrow",
   "pyarrow.*",
   "opentelemetry.*",

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/adbc/_typing.py

@@ -86,11 +86,16 @@ class AdbcSessionContext:
         self._driver: AdbcDriver | None = None
 
     def __enter__(self) -> "AdbcDriver":
+        from sqlspec.adapters.adbc.core import resolve_dialect_name
         from sqlspec.adapters.adbc.driver import AdbcDriver
 
         self._connection = self._acquire_connection()
+        resolved_dialect = resolve_dialect_name(self._statement_config.dialect) or None
         self._driver = AdbcDriver(
-            connection=self._connection, statement_config=self._statement_config, driver_features=self._driver_features
+            connection=self._connection,
+            statement_config=self._statement_config,
+            driver_features=self._driver_features,
+            dialect=resolved_dialect,
         )
         return self._prepare_driver(self._driver)
 

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/adbc/config.py

@@ -224,8 +224,10 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
 
+        dialect = resolve_dialect_from_config(self.connection_config)
+
         if statement_config is None:
-            statement_config = get_statement_config(resolve_dialect_from_config(self.connection_config))
+            statement_config = get_statement_config(dialect)
 
         statement_config, driver_features = apply_driver_features(statement_config, driver_features)
 
@@ -241,6 +243,11 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             **kwargs,
         )
 
+    @property
+    def supports_migration_schemas(self) -> bool:  # type: ignore[override]
+        """Migration schema support is only available for PostgreSQL-backed ADBC drivers."""
+        return is_postgres_dialect(resolve_dialect_from_config(self.connection_config))
+
     def create_connection(self) -> AdbcConnection:
         """Create and return a new connection using the specified driver.
 

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/adbc/core.py

@@ -157,12 +157,15 @@ _BIGQUERY_DB_KWARGS_FIELDS: "tuple[str, ...]" = ("project_id", "dataset_id", "to
 _TYPE_COERCION_DISPATCHERS: "dict[tuple[tuple[type, Callable[[Any], Any]], ...], TypeDispatcher[Callable[[Any], Any]]]" = {}
 
 
-def detect_dialect(connection: Any, logger: Any | None = None) -> str:
+def detect_dialect(connection: Any, logger: Any | None = None, *, fallback_dialect: "str | None" = None) -> str:
     """Detect database dialect from ADBC driver information.
 
     Args:
         connection: ADBC connection with driver metadata.
         logger: Optional logger for diagnostics.
+        fallback_dialect: Pre-resolved dialect from config (e.g. from
+            ``resolve_dialect_from_config``). Used when introspection
+            yields no match, before defaulting to ``postgres``.
 
     Returns:
         Detected dialect name, defaulting to ``postgres``.
@@ -182,6 +185,11 @@ def detect_dialect(connection: Any, logger: Any | None = None) -> str:
         if logger is not None:
             logger.debug("Dialect detection failed: %s", exc)
 
+    if fallback_dialect:
+        if logger is not None:
+            logger.debug("Dialect from connection_config: %s (introspection yielded no match)", fallback_dialect)
+        return fallback_dialect
+
     if logger is not None:
         logger.warning("Could not determine dialect from driver info. Defaulting to 'postgres'.")
     return "postgres"

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/adbc/driver.py

@@ -31,6 +31,7 @@ from sqlspec.exceptions import DatabaseConnectionError, SQLSpecError
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.module_loader import ensure_pyarrow
 from sqlspec.utils.serializers import to_json
+from sqlspec.utils.text import quote_identifier
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -89,8 +90,10 @@ class AdbcDriver(SyncDriverAdapterBase):
         connection: "AdbcConnection",
         statement_config: "StatementConfig | None" = None,
         driver_features: "dict[str, Any] | None" = None,
+        *,
+        dialect: "str | None" = None,
     ) -> None:
-        self._detected_dialect = detect_dialect(connection, logger)
+        self._detected_dialect = detect_dialect(connection, logger, fallback_dialect=dialect)
 
         if statement_config is None:
             base_config = get_statement_config(self._detected_dialect)
@@ -256,7 +259,15 @@ class AdbcDriver(SyncDriverAdapterBase):
     # ─────────────────────────────────────────────────────────────────────────────
 
     def begin(self) -> None:
-        """Begin database transaction."""
+        """Begin database transaction.
+
+        ADBC SQLite holds an implicit transaction after the first DML and
+        rejects an explicit ``BEGIN`` with "cannot start a transaction
+        within a transaction." On that dialect this is a no-op; the
+        implicit transaction is closed by ``commit()`` / ``rollback()``.
+        """
+        if self._dialect_name == "sqlite":
+            return
         try:
             with self.with_cursor(self.connection) as cursor:
                 cursor.execute("BEGIN")
@@ -282,6 +293,35 @@ class AdbcDriver(SyncDriverAdapterBase):
             msg = f"Failed to rollback transaction: {e}"
             raise SQLSpecError(msg) from e
 
+    def set_migration_session_schema(self, schema: str) -> None:
+        """Set the PostgreSQL search path for migration SQL when using ADBC PostgreSQL."""
+        if not self._is_postgres:
+            super().set_migration_session_schema(schema)
+            return
+        quoted_schema = quote_identifier(schema)
+        with self.with_cursor(self.connection) as cursor:
+            cursor.execute(f'SET search_path TO {quoted_schema}, "$user", public')
+
+    def set_migration_non_transactional_schema(self, schema: str) -> None:
+        """Set the PostgreSQL search path for non-transactional migration SQL."""
+        self.set_migration_session_schema(schema)
+
+    def reset_migration_session_schema(self) -> None:
+        """Reset PostgreSQL search path after non-transactional migration SQL."""
+        if not self._is_postgres:
+            super().reset_migration_session_schema()
+            return
+        with self.with_cursor(self.connection) as cursor:
+            cursor.execute("RESET search_path")
+
+    def has_schema(self, schema: str) -> bool:
+        """Return whether a PostgreSQL schema exists when using ADBC PostgreSQL."""
+        if not self._is_postgres:
+            return super().has_schema(schema)
+        with self.with_cursor(self.connection) as cursor:
+            cursor.execute("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1", parameters=[schema])
+            return cursor.fetchone() is not None
+
     def with_cursor(self, connection: "AdbcConnection") -> "AdbcCursor":
         """Create context manager for cursor.
 

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/aiomysql/core.py

@@ -21,6 +21,7 @@ from sqlspec.exceptions import (
     UniqueViolationError,
 )
 from sqlspec.utils.serializers import from_json, to_json
+from sqlspec.utils.text import quote_backtick_identifier
 from sqlspec.utils.type_converters import build_uuid_coercions
 from sqlspec.utils.type_guards import has_cursor_metadata, has_lastrowid, has_rowcount
 
@@ -117,23 +118,18 @@ def _bool_to_int(value: bool) -> int:
     return int(value)
 
 
-def _quote_mysql_identifier(identifier: str) -> str:
-    normalized = identifier.replace("`", "``")
-    return f"`{normalized}`"
-
-
 def format_identifier(identifier: str) -> str:
     cleaned = identifier.strip()
     if not cleaned:
         msg = "Table name must not be empty"
         raise SQLSpecError(msg)
     parts = [part for part in cleaned.split(".") if part]
-    formatted = ".".join(_quote_mysql_identifier(part) for part in parts)
-    return formatted or _quote_mysql_identifier(cleaned)
+    formatted = ".".join(quote_backtick_identifier(part) for part in parts)
+    return formatted or quote_backtick_identifier(cleaned)
 
 
 def build_insert_statement(table: str, columns: "list[str]") -> str:
-    column_clause = ", ".join(_quote_mysql_identifier(column) for column in columns)
+    column_clause = ", ".join(quote_backtick_identifier(column) for column in columns)
     placeholders = ", ".join("%s" for _ in columns)
     return f"INSERT INTO {format_identifier(table)} ({column_clause}) VALUES ({placeholders})"
 

{sqlspec-0.47.0 → sqlspec-0.48.0}/sqlspec/adapters/aiosqlite/core.py

@@ -18,6 +18,7 @@ from sqlspec.exceptions import (
     UniqueViolationError,
 )
 from sqlspec.utils.serializers import from_json, to_json
+from sqlspec.utils.text import quote_identifier
 from sqlspec.utils.type_converters import build_decimal_converter, build_time_iso_converter, build_uuid_coercions
 from sqlspec.utils.type_guards import has_rowcount, has_sqlite_error
 
@@ -58,23 +59,18 @@ def _bool_to_int(value: bool) -> int:
     return int(value)
 
 
-def _quote_sqlite_identifier(identifier: str) -> str:
-    normalized = identifier.replace('"', '""')
-    return f'"{normalized}"'
-
-
 def format_identifier(identifier: str) -> str:
     cleaned = identifier.strip()
     if not cleaned:
         msg = "Table name must not be empty"
         raise SQLSpecError(msg)
     parts = [part for part in cleaned.split(".") if part]
-    formatted = ".".join(_quote_sqlite_identifier(part) for part in parts)
-    return formatted or _quote_sqlite_identifier(cleaned)
+    formatted = ".".join(quote_identifier(part) for part in parts)
+    return formatted or quote_identifier(cleaned)
 
 
 def build_insert_statement(table: str, columns: "list[str]") -> str:
-    column_clause = ", ".join(_quote_sqlite_identifier(column) for column in columns)
+    column_clause = ", ".join(quote_identifier(column) for column in columns)
     placeholders = ", ".join("?" for _ in columns)
     return f"INSERT INTO {format_identifier(table)} ({column_clause}) VALUES ({placeholders})"
 

sqlspec-0.48.0/sqlspec/adapters/arrow_odbc/__init__.py

@@ -0,0 +1,30 @@
+"""SQLSpec adapter for arrow-odbc."""
+
+from sqlspec.adapters.arrow_odbc.config import ArrowOdbcConfig, ArrowOdbcConnectionParams, ArrowOdbcDriverFeatures
+from sqlspec.adapters.arrow_odbc.core import (
+    apply_driver_features,
+    build_connection_config,
+    build_statement_config,
+    create_mapped_exception,
+    default_statement_config,
+    driver_profile,
+    resolve_dialect_from_dbms_name,
+)
+from sqlspec.adapters.arrow_odbc.data_dictionary import ArrowOdbcDataDictionary
+from sqlspec.adapters.arrow_odbc.driver import ArrowOdbcDriver, ArrowOdbcExceptionHandler
+
+__all__ = (
+    "ArrowOdbcConfig",
+    "ArrowOdbcConnectionParams",
+    "ArrowOdbcDataDictionary",
+    "ArrowOdbcDriver",
+    "ArrowOdbcDriverFeatures",
+    "ArrowOdbcExceptionHandler",
+    "apply_driver_features",
+    "build_connection_config",
+    "build_statement_config",
+    "create_mapped_exception",
+    "default_statement_config",
+    "driver_profile",
+    "resolve_dialect_from_dbms_name",
+)

sqlspec-0.48.0/sqlspec/adapters/arrow_odbc/_typing.py

@@ -0,0 +1,96 @@
+# pyright: reportAttributeAccessIssue=false
+"""arrow-odbc adapter type definitions and mypyc-excluded context managers."""
+
+from typing import TYPE_CHECKING, Any
+
+import arrow_odbc as _arrow_odbc  # pyright: ignore[reportMissingImports]
+from arrow_odbc import connect as arrow_odbc_connect  # pyright: ignore[reportMissingImports]
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+    from typing import TypeAlias
+
+    from sqlspec.adapters.arrow_odbc.driver import ArrowOdbcDriver
+    from sqlspec.core import StatementConfig
+
+    ArrowOdbcConnection: TypeAlias = _arrow_odbc.Connection
+    ArrowOdbcRawCursor: TypeAlias = _arrow_odbc.Connection
+
+if not TYPE_CHECKING:
+    ArrowOdbcConnection = _arrow_odbc.Connection
+    ArrowOdbcRawCursor = _arrow_odbc.Connection
+
+ArrowOdbcError: "type[Exception]" = getattr(_arrow_odbc, "Error", Exception)
+
+
+class ArrowOdbcCursor:
+    """Context manager yielding the arrow-odbc connection as its execution cursor."""
+
+    __slots__ = ("connection",)
+
+    def __init__(self, connection: "ArrowOdbcConnection") -> None:
+        self.connection = connection
+
+    def __enter__(self) -> "ArrowOdbcRawCursor":
+        return self.connection
+
+    def __exit__(self, *_: object) -> None:
+        return None
+
+
+class ArrowOdbcSessionContext:
+    """Sync session context bridging interpreted config and compiled driver code."""
+
+    __slots__ = (
+        "_acquire_connection",
+        "_connection",
+        "_driver",
+        "_driver_features",
+        "_prepare_driver",
+        "_release_connection",
+        "_statement_config",
+    )
+
+    def __init__(
+        self,
+        acquire_connection: "Callable[[], Any]",
+        release_connection: "Callable[[Any], Any]",
+        statement_config: "StatementConfig",
+        driver_features: "dict[str, Any]",
+        prepare_driver: "Callable[[ArrowOdbcDriver], ArrowOdbcDriver]",
+    ) -> None:
+        self._acquire_connection = acquire_connection
+        self._release_connection = release_connection
+        self._statement_config = statement_config
+        self._driver_features = driver_features
+        self._prepare_driver = prepare_driver
+        self._connection: Any = None
+        self._driver: ArrowOdbcDriver | None = None
+
+    def __enter__(self) -> "ArrowOdbcDriver":
+        from sqlspec.adapters.arrow_odbc.driver import ArrowOdbcDriver
+
+        self._connection = self._acquire_connection()
+        self._driver = ArrowOdbcDriver(
+            connection=self._connection, statement_config=self._statement_config, driver_features=self._driver_features
+        )
+        return self._prepare_driver(self._driver)
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
+    ) -> "bool | None":
+        if self._connection is not None:
+            self._release_connection(self._connection)
+            self._connection = None
+        return None
+
+
+__all__ = (
+    "ArrowOdbcConnection",
+    "ArrowOdbcCursor",
+    "ArrowOdbcError",
+    "ArrowOdbcRawCursor",
+    "ArrowOdbcSessionContext",
+    "arrow_odbc_connect",
+)

sqlspec-0.48.0/sqlspec/adapters/arrow_odbc/config.py

@@ -0,0 +1,202 @@
+"""arrow-odbc database configuration."""
+
+from typing import TYPE_CHECKING, Any, ClassVar, TypedDict, cast
+
+from typing_extensions import NotRequired
+
+from sqlspec.adapters.arrow_odbc._typing import ArrowOdbcConnection, ArrowOdbcSessionContext, arrow_odbc_connect
+from sqlspec.adapters.arrow_odbc.core import apply_driver_features, build_connection_config, default_statement_config
+from sqlspec.adapters.arrow_odbc.driver import ArrowOdbcDriver
+from sqlspec.config import ExtensionConfigs, NoPoolSyncConfig
+from sqlspec.driver._sync import SyncPoolConnectionContext, SyncPoolSessionFactory
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.extensions.events import EventRuntimeHints
+from sqlspec.utils.config_tools import normalize_connection_config
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from sqlspec.core import StatementConfig
+    from sqlspec.observability import ObservabilityConfig
+
+__all__ = ("ArrowOdbcConfig", "ArrowOdbcConnectionParams", "ArrowOdbcDriverFeatures")
+
+
+class ArrowOdbcConnectionParams(TypedDict):
+    """arrow-odbc connection parameters."""
+
+    connection_string: NotRequired[str]
+    dsn: NotRequired[str]
+    driver: NotRequired[str]
+    server: NotRequired[str]
+    host: NotRequired[str]
+    database: NotRequired[str]
+    uid: NotRequired[str]
+    pwd: NotRequired[str]
+    user: NotRequired[str]
+    password: NotRequired[str]
+    login_timeout: NotRequired[int]
+    login_timeout_sec: NotRequired[int]
+    packet_size: NotRequired[int]
+    autocommit: NotRequired[bool]
+    extra: NotRequired[dict[str, Any]]
+
+
+class ArrowOdbcDriverFeatures(TypedDict):
+    """arrow-odbc driver feature flags."""
+
+    chunk_size: NotRequired[int]
+    max_bytes_per_batch: NotRequired[int]
+    max_text_size: NotRequired[int]
+    max_binary_size: NotRequired[int]
+    fetch_concurrently: NotRequired[bool]
+    query_timeout_sec: NotRequired[int]
+    connection_string: NotRequired[str]
+    dbms_name: NotRequired[str]
+    enable_events: NotRequired[bool]
+
+
+class ArrowOdbcConnectionContext(SyncPoolConnectionContext):
+    """Context manager for arrow-odbc connections."""
+
+    __slots__ = ("_connection",)
+
+    def __init__(self, config: "ArrowOdbcConfig") -> None:
+        super().__init__(config)
+        self._connection: ArrowOdbcConnection | None = None
+
+    def __enter__(self) -> "ArrowOdbcConnection":
+        self._connection = self._config.create_connection()
+        return cast("ArrowOdbcConnection", self._connection)
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
+    ) -> "bool | None":
+        if self._connection is not None:
+            _close_arrow_odbc_connection(self._connection)
+            self._connection = None
+        return None
+
+
+class _ArrowOdbcSessionConnectionHandler(SyncPoolSessionFactory):
+    """Session connection handler for no-pool arrow-odbc sessions."""
+
+    __slots__ = ("_connection",)
+
+    def __init__(self, config: "ArrowOdbcConfig") -> None:
+        super().__init__(config)
+        self._connection: ArrowOdbcConnection | None = None
+
+    def acquire_connection(self) -> "ArrowOdbcConnection":
+        self._connection = self._config.create_connection()
+        return cast("ArrowOdbcConnection", self._connection)
+
+    def release_connection(self, _conn: "ArrowOdbcConnection", **kwargs: Any) -> None:
+        if self._connection is None:
+            return
+        _close_arrow_odbc_connection(self._connection)
+        self._connection = None
+
+
+class ArrowOdbcConfig(NoPoolSyncConfig[ArrowOdbcConnection, ArrowOdbcDriver]):
+    """Configuration for synchronous arrow-odbc connections."""
+
+    driver_type: "ClassVar[type[ArrowOdbcDriver]]" = ArrowOdbcDriver
+    connection_type: "ClassVar[type[ArrowOdbcConnection]]" = ArrowOdbcConnection
+    supports_transactional_ddl: "ClassVar[bool]" = False
+    supports_native_arrow_export: "ClassVar[bool]" = True
+    supports_native_arrow_import: "ClassVar[bool]" = True
+    supports_native_parquet_export: "ClassVar[bool]" = False
+    supports_native_parquet_import: "ClassVar[bool]" = False
+    _connection_context_class: "ClassVar[type[ArrowOdbcConnectionContext]]" = ArrowOdbcConnectionContext
+    _session_factory_class: "ClassVar[type[_ArrowOdbcSessionConnectionHandler]]" = _ArrowOdbcSessionConnectionHandler
+    _session_context_class: "ClassVar[type[ArrowOdbcSessionContext]]" = ArrowOdbcSessionContext
+    _default_statement_config = default_statement_config
+
+    def __init__(
+        self,
+        *,
+        connection_config: "ArrowOdbcConnectionParams | dict[str, Any] | None" = None,
+        connection_instance: "Any" = None,
+        migration_config: "dict[str, Any] | None" = None,
+        statement_config: "StatementConfig | None" = None,
+        driver_features: "ArrowOdbcDriverFeatures | dict[str, Any] | None" = None,
+        bind_key: str | None = None,
+        extension_config: "ExtensionConfigs | None" = None,
+        observability_config: "ObservabilityConfig | None" = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize arrow-odbc configuration."""
+        self.connection_config = normalize_connection_config(connection_config)
+        features = apply_driver_features(dict(driver_features or {}))
+        connection_string = self.connection_config.get("connection_string")
+        if connection_string is not None:
+            features.setdefault("connection_string", str(connection_string))
+        elif self.connection_config.get("driver") is not None:
+            features.setdefault("dbms_name", str(self.connection_config["driver"]))
+
+        super().__init__(
+            connection_config=self.connection_config,
+            connection_instance=connection_instance,
+            migration_config=migration_config,
+            statement_config=statement_config or default_statement_config,
+            driver_features=features,
+            bind_key=bind_key,
+            extension_config=extension_config,
+            observability_config=observability_config,
+            **kwargs,
+        )
+
+    def create_connection(self) -> "ArrowOdbcConnection":
+        """Create and return a new arrow-odbc connection."""
+        if self.connection_instance is not None:
+            return cast("ArrowOdbcConnection", self.connection_instance)
+        connection_string, connect_kwargs = build_connection_config(self.connection_config)
+        try:
+            connection = cast("ArrowOdbcConnection", arrow_odbc_connect(connection_string, **connect_kwargs))
+            return cast("ArrowOdbcConnection", connection)
+        except Exception as exc:
+            msg = f"Could not configure arrow-odbc connection. Error: {exc}"
+            raise ImproperConfigurationError(msg) from exc
+
+    def provide_connection(self, *args: Any, **kwargs: Any) -> "ArrowOdbcConnectionContext":
+        """Provide a connection context manager."""
+        return ArrowOdbcConnectionContext(self)
+
+    def provide_session(
+        self, *_args: Any, statement_config: "StatementConfig | None" = None, **_kwargs: Any
+    ) -> "ArrowOdbcSessionContext":
+        """Provide a driver session context manager."""
+        handler = _ArrowOdbcSessionConnectionHandler(self)
+        return ArrowOdbcSessionContext(
+            acquire_connection=handler.acquire_connection,
+            release_connection=handler.release_connection,
+            statement_config=statement_config or self.statement_config,
+            driver_features=self.driver_features,
+            prepare_driver=self._prepare_driver,
+        )
+
+    def get_signature_namespace(self) -> "dict[str, Any]":
+        """Get the signature namespace for ArrowOdbcConfig types."""
+        namespace = super().get_signature_namespace()
+        namespace.update({
+            "ArrowOdbcConfig": ArrowOdbcConfig,
+            "ArrowOdbcConnection": ArrowOdbcConnection,
+            "ArrowOdbcConnectionContext": ArrowOdbcConnectionContext,
+            "ArrowOdbcConnectionParams": ArrowOdbcConnectionParams,
+            "ArrowOdbcDriver": ArrowOdbcDriver,
+            "ArrowOdbcDriverFeatures": ArrowOdbcDriverFeatures,
+            "ArrowOdbcSessionContext": ArrowOdbcSessionContext,
+        })
+        return namespace
+
+    def get_event_runtime_hints(self) -> "EventRuntimeHints":
+        """Return polling defaults suitable for generic ODBC sources."""
+        return EventRuntimeHints(poll_interval=2.0, lease_seconds=60, retention_seconds=172_800)
+
+
+def _close_arrow_odbc_connection(connection: "ArrowOdbcConnection") -> None:
+    """Close connection objects from compatible wrappers when they expose close()."""
+    close = getattr(connection, "close", None)
+    if close is not None:
+        close()