sqlspec 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

sqlspec/adapters/duckdb/driver.py

@@ -0,0 +1,225 @@
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
+
+from sqlspec.base import SyncDriverAdapterProtocol, T
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from duckdb import DuckDBPyConnection
+
+    from sqlspec.typing import ModelDTOT, StatementParameterType
+
+__all__ = ("DuckDBDriver",)
+
+
+class DuckDBDriver(SyncDriverAdapterProtocol["DuckDBPyConnection"]):
+    """DuckDB Sync Driver Adapter."""
+
+    connection: "DuckDBPyConnection"
+    use_cursor: bool = True
+    # param_style is inherited from CommonDriverAttributes
+
+    def __init__(self, connection: "DuckDBPyConnection", use_cursor: bool = True) -> None:
+        self.connection = connection
+        self.use_cursor = use_cursor
+
+    # --- Helper Methods --- #
+    def _cursor(self, connection: "DuckDBPyConnection") -> "DuckDBPyConnection":
+        if self.use_cursor:
+            # Ignore lack of type hint on cursor()
+            return connection.cursor()
+        return connection
+
+    @contextmanager
+    def _with_cursor(self, connection: "DuckDBPyConnection") -> "Generator[DuckDBPyConnection, None, None]":
+        if self.use_cursor:
+            cursor = self._cursor(connection)
+            try:
+                yield cursor
+            finally:
+                cursor.close()
+        else:
+            yield connection  # Yield the connection directly
+
+    # --- Public API Methods (Original Implementation + _process_sql_params) --- #
+
+    def select(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "list[Union[ModelDTOT, dict[str, Any]]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            results = cursor.fetchall()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if not results:
+                return []
+
+            column_names = [col[0] for col in cursor.description or []]  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+
+            if schema_type is not None:
+                return [cast("ModelDTOT", schema_type(**dict(zip(column_names, row)))) for row in results]  # pyright: ignore[reportUnknownArgumentType]
+            return [dict(zip(column_names, row)) for row in results]  # pyright: ignore[reportUnknownArgumentType]
+
+    def select_one(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Union[ModelDTOT, dict[str, Any]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = cursor.fetchone()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            result = self.check_not_found(result)  #  pyright: ignore
+
+            column_names = [col[0] for col in cursor.description or []]  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            if schema_type is not None:
+                return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))  # pyright: ignore[reportUnknownArgumentType]
+            # Always return dictionaries
+            return dict(zip(column_names, result))  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+
+    def select_one_or_none(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Optional[Union[ModelDTOT, dict[str, Any]]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = cursor.fetchone()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if result is None:
+                return None
+
+            column_names = [col[0] for col in cursor.description or []]  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            if schema_type is not None:
+                return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))  # pyright: ignore[reportUnknownArgumentType]
+            return dict(zip(column_names, result))  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+
+    def select_value(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        connection: "Optional[DuckDBPyConnection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+    ) -> "Union[T, Any]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = cursor.fetchone()  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            result = self.check_not_found(result)  #  pyright: ignore
+            if schema_type is None:
+                return result[0]  # pyright: ignore
+            return schema_type(result[0])  # type: ignore[call-arg]
+
+    def select_value_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        connection: "Optional[DuckDBPyConnection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+    ) -> "Optional[Union[T, Any]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = cursor.fetchone()  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            if result is None:
+                return None
+            if schema_type is None:
+                return result[0]  # pyright: ignore
+            return schema_type(result[0])  # type: ignore[call-arg]
+
+    def insert_update_delete(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+    ) -> int:
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            return getattr(cursor, "rowcount", -1)  # pyright: ignore[reportUnknownMemberType]
+
+    def insert_update_delete_returning(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = cursor.fetchall()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if not result:
+                return None  # pyright: ignore[reportUnknownArgumentType]
+            column_names = [col[0] for col in cursor.description or []]  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            if schema_type is not None:
+                return cast("ModelDTOT", schema_type(**dict(zip(column_names, result[0]))))  # pyright: ignore[reportUnknownArgumentType]
+            # Always return dictionaries
+            return dict(zip(column_names, result[0]))  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+
+    def _process_sql_params(
+        self, sql: str, parameters: "Optional[StatementParameterType]" = None
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Process SQL query and parameters for DB-API execution.
+
+        Converts named parameters (:name) to positional parameters (?) for DuckDB.
+
+        Args:
+            sql: The SQL query string.
+            parameters: The parameters for the query (dict, tuple, list, or None).
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters.
+        """
+        if not isinstance(parameters, dict) or not parameters:
+            # If parameters are not a dict, or empty dict, assume positional/no params
+            # Let the underlying driver handle tuples/lists directly
+            return sql, parameters
+
+        # Convert named parameters to positional parameters
+        processed_sql = sql
+        processed_params: list[Any] = []
+        for key, value in parameters.items():
+            # Replace :key with ? in the SQL
+            processed_sql = processed_sql.replace(f":{key}", "?")
+            processed_params.append(value)
+
+        return processed_sql, tuple(processed_params)
+
+    def execute_script(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["DuckDBPyConnection"] = None,
+    ) -> str:
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        with self._with_cursor(connection) as cursor:
+            cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            return cast("str", getattr(cursor, "statusmessage", "DONE"))  # pyright: ignore[reportUnknownMemberType]

sqlspec/adapters/oracledb/__init__.py

@@ -1,13 +1,16 @@
 from sqlspec.adapters.oracledb.config import (
-    OracleAsyncDatabaseConfig,
-    OracleAsyncPoolConfig,
-    OracleSyncDatabaseConfig,
-    OracleSyncPoolConfig,
+    OracleAsync,
+    OracleAsyncPool,
+    OracleSync,
+    OracleSyncPool,
 )
+from sqlspec.adapters.oracledb.driver import OracleAsyncDriver, OracleSyncDriver
 
 __all__ = (
-    "OracleAsyncDatabaseConfig",
-    "OracleAsyncPoolConfig",
-    "OracleSyncDatabaseConfig",
-    "OracleSyncPoolConfig",
+    "OracleAsync",
+    "OracleAsyncDriver",
+    "OracleAsyncPool",
+    "OracleSync",
+    "OracleSyncDriver",
+    "OracleSyncPool",
 )

sqlspec/adapters/oracledb/config/__init__.py

@@ -1,9 +1,9 @@
-from sqlspec.adapters.oracledb.config._asyncio import OracleAsyncDatabaseConfig, OracleAsyncPoolConfig
-from sqlspec.adapters.oracledb.config._sync import OracleSyncDatabaseConfig, OracleSyncPoolConfig
+from sqlspec.adapters.oracledb.config._asyncio import OracleAsync, OracleAsyncPool
+from sqlspec.adapters.oracledb.config._sync import OracleSync, OracleSyncPool
 
 __all__ = (
-    "OracleAsyncDatabaseConfig",
-    "OracleAsyncPoolConfig",
-    "OracleSyncDatabaseConfig",
-    "OracleSyncPoolConfig",
+    "OracleAsync",
+    "OracleAsyncPool",
+    "OracleSync",
+    "OracleSyncPool",
 )

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -1,14 +1,12 @@
 from contextlib import asynccontextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional
 
 from oracledb import create_pool_async as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import AsyncConnection
-from oracledb.pool import AsyncConnectionPool
 
-from sqlspec.adapters.oracledb.config._common import (
-    OracleGenericPoolConfig,
-)
+from sqlspec.adapters.oracledb.config._common import OracleGenericPoolConfig
+from sqlspec.adapters.oracledb.driver import OracleAsyncDriver
 from sqlspec.base import AsyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
@@ -16,20 +14,22 @@ from sqlspec.typing import dataclass_to_dict
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
 
+    from oracledb.pool import AsyncConnectionPool
+
 
 __all__ = (
-    "OracleAsyncDatabaseConfig",
-    "OracleAsyncPoolConfig",
+    "OracleAsync",
+    "OracleAsyncPool",
 )
 
 
 @dataclass
-class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
+class OracleAsyncPool(OracleGenericPoolConfig["AsyncConnection", "AsyncConnectionPool"]):
     """Async Oracle Pool Config"""
 
 
 @dataclass
-class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
+class OracleAsync(AsyncDatabaseConfig["AsyncConnection", "AsyncConnectionPool", "OracleAsyncDriver"]):
     """Oracle Async database Configuration.
 
     This class provides the base configuration for Oracle database connections, extending
@@ -42,30 +42,99 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
     options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
     """
 
-    pool_config: "Optional[OracleAsyncPoolConfig]" = None
+    pool_config: "Optional[OracleAsyncPool]" = None
     """Oracle Pool configuration"""
     pool_instance: "Optional[AsyncConnectionPool]" = None
     """Optional pool to use.
 
     If set, the plugin will use the provided pool rather than instantiate one.
     """
+    connection_type: "type[AsyncConnection]" = field(init=False, default_factory=lambda: AsyncConnection)
+    """Connection class to use.
+
+    Defaults to :class:`AsyncConnection`.
+    """
+    driver_type: "type[OracleAsyncDriver]" = field(init=False, default_factory=lambda: OracleAsyncDriver)  # type: ignore[type-abstract,unused-ignore]
+    """Driver class to use.
+
+    Defaults to :class:`OracleAsyncDriver`.
+    """
+
+    @property
+    def connection_config_dict(self) -> "dict[str, Any]":
+        """Return the connection configuration as a dict.
+
+        Returns:
+            A string keyed dict of config kwargs for the oracledb.connect function.
+
+        Raises:
+            ImproperConfigurationError: If the connection configuration is not provided.
+        """
+        if self.pool_config:
+            # Filter out pool-specific parameters
+            pool_only_params = {
+                "min",
+                "max",
+                "increment",
+                "timeout",
+                "wait_timeout",
+                "max_lifetime_session",
+                "session_callback",
+            }
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
+            )
+        msg = "You must provide a 'pool_config' for this adapter."
+        raise ImproperConfigurationError(msg)
 
     @property
     def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
+        Raises:
+            ImproperConfigurationError: If no pool_config is provided but a pool_instance
+
         Returns:
             A string keyed dict of config kwargs for the Asyncpg :func:`create_pool <oracledb.pool.create_pool>`
             function.
         """
         if self.pool_config is not None:
-            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude={"pool_instance", "connection_type", "driver_type"},
+            )
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
+    async def create_connection(self) -> "AsyncConnection":
+        """Create and return a new oracledb async connection.
+
+        Returns:
+            An AsyncConnection instance.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be created.
+        """
+        try:
+            import oracledb
+
+            return await oracledb.connect_async(**self.connection_config_dict)  # type: ignore[no-any-return]
+        except Exception as e:
+            msg = f"Could not configure the Oracle async connection. Error: {e!s}"
+            raise ImproperConfigurationError(msg) from e
+
     async def create_pool(self) -> "AsyncConnectionPool":
         """Return a pool. If none exists yet, create one.
 
+        Raises:
+            ImproperConfigurationError: If neither pool_config nor pool_instance are provided,
+                or if the pool could not be configured.
+
         Returns:
             Getter that returns the pool instance used by the plugin.
         """
@@ -95,9 +164,25 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
     async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[AsyncConnection, None]":
         """Create a connection instance.
 
-        Returns:
-            A connection instance.
+        Yields:
+            AsyncConnection: A connection instance.
         """
         db_pool = await self.provide_pool(*args, **kwargs)
         async with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
             yield connection
+
+    @asynccontextmanager
+    async def provide_session(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[OracleAsyncDriver, None]":
+        """Create and provide a database session.
+
+        Yields:
+            OracleAsyncDriver: A driver instance with an active connection.
+        """
+        async with self.provide_connection(*args, **kwargs) as connection:
+            yield self.driver_type(connection)
+
+    async def close_pool(self) -> None:
+        """Close the connection pool."""
+        if self.pool_instance is not None:
+            await self.pool_instance.close()
+            self.pool_instance = None

sqlspec/adapters/oracledb/config/_common.py

@@ -27,7 +27,7 @@ PoolT = TypeVar("PoolT", bound="Union[ConnectionPool, AsyncConnectionPool]")
 
 
 @dataclass
-class OracleGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
+class OracleGenericPoolConfig(GenericPoolConfig, Generic[ConnectionT, PoolT]):
     """Configuration for Oracle database connection pools.
 
     This class provides configuration options for both synchronous and asynchronous Oracle

sqlspec/adapters/oracledb/config/_sync.py

@@ -1,35 +1,35 @@
 from contextlib import contextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional
 
 from oracledb import create_pool as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import Connection
-from oracledb.pool import ConnectionPool
 
-from sqlspec.adapters.oracledb.config._common import (
-    OracleGenericPoolConfig,
-)
+from sqlspec.adapters.oracledb.config._common import OracleGenericPoolConfig
+from sqlspec.adapters.oracledb.driver import OracleSyncDriver
 from sqlspec.base import SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import Generator
-    from typing import Any
+
+    from oracledb.pool import ConnectionPool
+
 
 __all__ = (
-    "OracleSyncDatabaseConfig",
-    "OracleSyncPoolConfig",
+    "OracleSync",
+    "OracleSyncPool",
 )
 
 
 @dataclass
-class OracleSyncPoolConfig(OracleGenericPoolConfig[Connection, ConnectionPool]):
+class OracleSyncPool(OracleGenericPoolConfig["Connection", "ConnectionPool"]):
     """Sync Oracle Pool Config"""
 
 
 @dataclass
-class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
+class OracleSync(SyncDatabaseConfig["Connection", "ConnectionPool", "OracleSyncDriver"]):
     """Oracle Sync database Configuration.
 
     This class provides the base configuration for Oracle database connections, extending
@@ -42,30 +42,99 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
     options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
     """
 
-    pool_config: "Optional[OracleSyncPoolConfig]" = None
+    pool_config: "Optional[OracleSyncPool]" = None
     """Oracle Pool configuration"""
     pool_instance: "Optional[ConnectionPool]" = None
     """Optional pool to use.
 
     If set, the plugin will use the provided pool rather than instantiate one.
     """
+    connection_type: "type[Connection]" = field(init=False, default_factory=lambda: Connection)  # pyright: ignore
+    """Connection class to use.
+
+    Defaults to :class:`Connection`.
+    """
+    driver_type: "type[OracleSyncDriver]" = field(init=False, default_factory=lambda: OracleSyncDriver)  # type: ignore[type-abstract,unused-ignore]
+    """Driver class to use.
+
+    Defaults to :class:`OracleSyncDriver`.
+    """
+
+    @property
+    def connection_config_dict(self) -> "dict[str, Any]":
+        """Return the connection configuration as a dict.
+
+        Returns:
+            A string keyed dict of config kwargs for the oracledb.connect function.
+
+        Raises:
+            ImproperConfigurationError: If the connection configuration is not provided.
+        """
+        if self.pool_config:
+            # Filter out pool-specific parameters
+            pool_only_params = {
+                "min",
+                "max",
+                "increment",
+                "timeout",
+                "wait_timeout",
+                "max_lifetime_session",
+                "session_callback",
+            }
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
+            )
+        msg = "You must provide a 'pool_config' for this adapter."
+        raise ImproperConfigurationError(msg)
 
     @property
     def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
+        Raises:
+            ImproperConfigurationError: If no pool_config is provided but a pool_instance
+
         Returns:
             A string keyed dict of config kwargs for the Asyncpg :func:`create_pool <oracledb.pool.create_pool>`
             function.
         """
         if self.pool_config:
-            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude={"pool_instance", "connection_type", "driver_type"},
+            )
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
+    def create_connection(self) -> "Connection":
+        """Create and return a new oracledb connection.
+
+        Returns:
+            A Connection instance.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be created.
+        """
+        try:
+            import oracledb
+
+            return oracledb.connect(**self.connection_config_dict)
+        except Exception as e:
+            msg = f"Could not configure the Oracle connection. Error: {e!s}"
+            raise ImproperConfigurationError(msg) from e
+
     def create_pool(self) -> "ConnectionPool":
         """Return a pool. If none exists yet, create one.
 
+        Raises:
+            ImproperConfigurationError: If neither pool_config nor pool_instance is provided,
+                or if the pool could not be configured.
+
         Returns:
             Getter that returns the pool instance used by the plugin.
         """
@@ -95,9 +164,25 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
     def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
         """Create a connection instance.
 
-        Returns:
-            A connection instance.
+        Yields:
+            Connection: A connection instance from the pool.
         """
         db_pool = self.provide_pool(*args, **kwargs)
         with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
             yield connection
+
+    @contextmanager
+    def provide_session(self, *args: "Any", **kwargs: "Any") -> "Generator[OracleSyncDriver, None, None]":
+        """Create and provide a database session.
+
+        Yields:
+            OracleSyncDriver: A driver instance with an active connection.
+        """
+        with self.provide_connection(*args, **kwargs) as connection:
+            yield self.driver_type(connection)
+
+    def close_pool(self) -> None:
+        """Close the connection pool."""
+        if self.pool_instance is not None:
+            self.pool_instance.close()
+            self.pool_instance = None