sqlspec 0.36.0__tar.gz → 0.36.2__tar.gz

{sqlspec-0.36.0 → sqlspec-0.36.2}/.gitignore

@@ -58,3 +58,5 @@ docs-build
 .gh-cache
 .gemini/
 specs/
+.playwright-mcp
+.geminiignore

{sqlspec-0.36.0 → sqlspec-0.36.2}/CONTRIBUTING.rst

@@ -36,7 +36,7 @@ Guidelines for writing code
 - All code should be fully `typed <https://peps.python.org/pep-0484/>`_. This is enforced via
   `mypy <https://mypy.readthedocs.io/en/stable/>`_.
 - All code should be tested. This is enforced via `pytest <https://docs.pytest.org/en/stable/>`_.
-- All code should be properly formatted. This is enforced via `black <https://black.readthedocs.io/en/stable/>`_ and `Ruff <https://beta.ruff.rs/docs/>`_.
+- All code should be properly formatted. This is enforced via `black <https://black.readthedocs.io/en/stable/>`_ and `Ruff <https://docs.astral.sh/ruff/>`_.
 
 Logging
 ++++++++
@@ -55,8 +55,8 @@ Project documentation
 
 The documentation is located in the ``/docs`` directory and is `ReST <https://docutils.sourceforge.io/rst.html>`_ and
 `Sphinx <https://www.sphinx-doc.org/en/master/>`_. If you're unfamiliar with any of those,
-`ReStructuredText primer <https://www.sphinx-doc.org/en/master/lib/usage/restructuredtext/basics.html>`_ and
-`Sphinx quickstart <https://www.sphinx-doc.org/en/master/lib/usage/quickstart.html>`_ are recommended reads.
+`ReStructuredText primer <https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html>`_ and
+`Sphinx quickstart <https://www.sphinx-doc.org/en/master/usage/quickstart.html>`_ are recommended reads.
 
 Running the docs locally
 ++++++++++++++++++++++++
@@ -67,7 +67,7 @@ Creating a new release
 ----------------------
 
 1. Increment the version in `pyproject.toml <https://github.com/litestar-org/sqlspec/blob/main/pyproject.toml>`_.
-    .. note:: The version should follow `semantic versioning <https://semver.org/>`_ and `PEP 440 <https://www.python.org/dev/peps/pep-0440/>`_.
+    .. note:: The version should follow `semantic versioning <https://semver.org/>`_ and `PEP 440 <https://peps.python.org/pep-0440/>`_.
 2. `Draft a new release <https://github.com/litestar-org/sqlspec/releases/new>`_ on GitHub
 
    * Use ``vMAJOR.MINOR.PATCH`` (e.g. ``v1.2.3``) as both the tag and release title

{sqlspec-0.36.0 → sqlspec-0.36.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.36.0
+Version: 0.36.2
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.36.0 → sqlspec-0.36.2}/pyproject.toml

@@ -13,7 +13,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.36.0"
+version = "0.36.2"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -222,7 +222,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.36.0"
+current_version = "0.36.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/adbc/driver.py

@@ -372,8 +372,11 @@ class AdbcDriver(SyncDriverAdapterBase):
         config = statement_config or self.statement_config
         prepared_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
 
+        exc_handler = self.handle_database_exceptions()
+        arrow_result: ArrowResult | None = None
+
         # Use ADBC cursor for native Arrow
-        with self.with_cursor(self.connection) as cursor, self.handle_database_exceptions():
+        with self.with_cursor(self.connection) as cursor, exc_handler:
             if cursor is None:
                 msg = "Failed to create cursor"
                 raise DatabaseConnectionError(msg)
@@ -387,15 +390,22 @@ class AdbcDriver(SyncDriverAdapterBase):
             # Fetch as Arrow table (zero-copy!)
             arrow_table = cursor.fetch_arrow_table()
 
-            return build_arrow_result_from_table(
+            arrow_result = build_arrow_result_from_table(
                 prepared_statement,
                 arrow_table,
                 return_format=return_format,
                 batch_size=batch_size,
                 arrow_schema=arrow_schema,
             )
-        msg = "Unreachable"
-        raise RuntimeError(msg)  # pragma: no cover
+
+        if exc_handler.pending_exception is not None:
+            raise exc_handler.pending_exception from None
+
+        if arrow_result is None:
+            msg = "Unreachable"
+            raise RuntimeError(msg)  # pragma: no cover
+
+        return arrow_result
 
     # ─────────────────────────────────────────────────────────────────────────────
     # STORAGE API METHODS
@@ -440,8 +450,12 @@ class AdbcDriver(SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         ingest_mode: Literal["append", "create", "replace", "create_append"]
         ingest_mode = "replace" if overwrite else "create_append"
-        with self.with_cursor(self.connection) as cursor, self.handle_database_exceptions():
+        exc_handler = self.handle_database_exceptions()
+        with self.with_cursor(self.connection) as cursor, exc_handler:
             cursor.adbc_ingest(table, arrow_table, mode=ingest_mode)
+
+        if exc_handler.pending_exception is not None:
+            raise exc_handler.pending_exception from None
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
         self._attach_partition_telemetry(telemetry_payload, partitioner)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/aiosqlite/driver.py

@@ -252,14 +252,20 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = f"DELETE FROM {format_identifier(table)}"
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.executemany(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/asyncmy/config.py

@@ -13,7 +13,7 @@ from sqlspec.adapters.asyncmy.core import apply_driver_features, default_stateme
 from sqlspec.adapters.asyncmy.driver import AsyncmyCursor, AsyncmyDriver, AsyncmyExceptionHandler, AsyncmySessionContext
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -173,8 +173,6 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "AsyncmyPool", Asyncm
             observability_config: Adapter-level observability overrides for lifecycle hooks and observers
             **kwargs: Additional keyword arguments
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
 
         connection_config.setdefault("host", "localhost")

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/asyncmy/driver.py

@@ -320,14 +320,20 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = f"TRUNCATE TABLE {format_identifier(table)}"
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.executemany(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/asyncpg/config.py

@@ -22,7 +22,7 @@ from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
 from sqlspec.exceptions import ImproperConfigurationError, MissingDependencyError
 from sqlspec.extensions.events import EventRuntimeHints
 from sqlspec.typing import ALLOYDB_CONNECTOR_INSTALLED, CLOUD_SQL_CONNECTOR_INSTALLED, PGVECTOR_INSTALLED
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.serializers import from_json, to_json
 
@@ -304,8 +304,6 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
             observability_config: Adapter-level observability overrides for lifecycle hooks and observers
             **kwargs: Additional keyword arguments
         """
-        reject_pool_aliases(kwargs)
-
         statement_config = statement_config or default_statement_config
         statement_config, driver_features = apply_driver_features(statement_config, driver_features)
 

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/bigquery/driver.py

@@ -413,7 +413,10 @@ class BigQueryDriver(SyncDriverAdapterBase):
         # Get compiled SQL and parameters
         sql, driver_params = self._get_compiled_sql(prepared_statement, config)
 
-        with self.handle_database_exceptions():
+        exc_handler = self.handle_database_exceptions()
+        arrow_result: ArrowResult | None = None
+
+        with exc_handler:
             query_job = run_query_job(
                 self.connection,
                 sql,
@@ -427,15 +430,22 @@ class BigQueryDriver(SyncDriverAdapterBase):
             # Native Arrow via Storage API
             arrow_table = query_job.to_arrow()
 
-            return build_arrow_result_from_table(
+            arrow_result = build_arrow_result_from_table(
                 prepared_statement,
                 arrow_table,
                 return_format=return_format,
                 batch_size=batch_size,
                 arrow_schema=arrow_schema,
             )
-        msg = "Unreachable"
-        raise RuntimeError(msg)  # pragma: no cover
+
+        if exc_handler.pending_exception is not None:
+            raise exc_handler.pending_exception from None
+
+        if arrow_result is None:
+            msg = "Unreachable"
+            raise RuntimeError(msg)  # pragma: no cover
+
+        return arrow_result
 
     # ─────────────────────────────────────────────────────────────────────────────
     # STORAGE API METHODS

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/cockroach_asyncpg/config.py

@@ -15,7 +15,7 @@ from sqlspec.adapters.cockroach_asyncpg.core import CockroachAsyncpgRetryConfig
 from sqlspec.adapters.cockroach_asyncpg.driver import CockroachAsyncpgDriver, CockroachAsyncpgExceptionHandler
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
@@ -156,8 +156,6 @@ class CockroachAsyncpgConfig(
         observability_config: "ObservabilityConfig | None" = None,
         **kwargs: Any,
     ) -> None:
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
         statement_config = statement_config or default_statement_config
         statement_config, driver_features = apply_driver_features(statement_config, driver_features)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/cockroach_psycopg/config.py

@@ -27,7 +27,7 @@ from sqlspec.adapters.cockroach_psycopg.driver import (
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs, SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -175,8 +175,6 @@ class CockroachPsycopgSyncConfig(
         observability_config: "ObservabilityConfig | None" = None,
         **kwargs: Any,
     ) -> None:
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
         statement_config = statement_config or build_statement_config()
         statement_config, driver_features = apply_driver_features(statement_config, driver_features)
@@ -364,8 +362,6 @@ class CockroachPsycopgAsyncConfig(
         observability_config: "ObservabilityConfig | None" = None,
         **kwargs: Any,
     ) -> None:
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
         statement_config = statement_config or build_statement_config()
         statement_config, driver_features = apply_driver_features(statement_config, driver_features)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/duckdb/driver.py

@@ -298,8 +298,11 @@ class DuckDBDriver(SyncDriverAdapterBase):
         config = statement_config or self.statement_config
         prepared_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
 
+        exc_handler = self.handle_database_exceptions()
+        arrow_result: ArrowResult | None = None
+
         # Execute query and get native Arrow
-        with self.with_cursor(self.connection) as cursor, self.handle_database_exceptions():
+        with self.with_cursor(self.connection) as cursor, exc_handler:
             if cursor is None:
                 msg = "Failed to create cursor"
                 raise DatabaseConnectionError(msg)
@@ -314,15 +317,22 @@ class DuckDBDriver(SyncDriverAdapterBase):
             arrow_reader = cursor.arrow()
             arrow_table = arrow_reader.read_all()
 
-            return build_arrow_result_from_table(
+            arrow_result = build_arrow_result_from_table(
                 prepared_statement,
                 arrow_table,
                 return_format=return_format,
                 batch_size=batch_size,
                 arrow_schema=arrow_schema,
             )
-        msg = "Unreachable"
-        raise RuntimeError(msg)  # pragma: no cover
+
+        if exc_handler.pending_exception is not None:
+            raise exc_handler.pending_exception from None
+
+        if arrow_result is None:
+            msg = "Unreachable"
+            raise RuntimeError(msg)  # pragma: no cover
+
+        return arrow_result
 
     # ─────────────────────────────────────────────────────────────────────────────
     # STORAGE API METHODS

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/duckdb/pool.py

@@ -43,6 +43,7 @@ class DuckDBConnectionPool:
         "_extension_flags",
         "_extensions",
         "_health_check_interval",
+        "_is_memory_db",
         "_lock",
         "_on_connection_create",
         "_recycle",
@@ -82,6 +83,10 @@ class DuckDBConnectionPool:
         self._lock = threading.RLock()
         self._created_connections = 0
         self._connection_times: dict[int, float] = {}
+        # Track if this pool uses an in-memory database
+        # In-memory databases require connections to stay alive to preserve data
+        database = connection_config.get("database", "")
+        self._is_memory_db = database.startswith(":memory:") or database == ""
 
     def _create_connection(self) -> DuckDBConnection:
         """Create a new DuckDB connection with extensions and secrets."""
@@ -252,6 +257,13 @@ class DuckDBConnectionPool:
         Each thread gets its own dedicated DuckDB connection to prevent
         thread-safety issues with concurrent cursor operations.
 
+        For file-based databases, the connection is closed when the context
+        manager exits to release DuckDB's file lock, allowing subsequent
+        connections with different configurations.
+
+        For in-memory databases, connections are kept alive to preserve data,
+        as in-memory data is lost when the last connection closes.
+
         Yields:
             DuckDBConnection: A thread-local connection.
         """
@@ -261,6 +273,11 @@ class DuckDBConnectionPool:
         except Exception:
             self._close_thread_connection()
             raise
+        else:
+            # Only close connection for file-based databases to release file locks
+            # In-memory databases need connections to stay alive to preserve data
+            if not self._is_memory_db:
+                self._close_thread_connection()
 
     def close(self) -> None:
         """Close the thread-local connection if it exists."""

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/mock/driver.py

@@ -364,14 +364,20 @@ class MockSyncDriver(SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             delete_statement = f"DELETE FROM {format_identifier(table)}"
-            with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
                 cursor.execute(delete_statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
                 cursor.executemany(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
@@ -645,16 +651,22 @@ class MockAsyncDriver(AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             delete_statement = f"DELETE FROM {format_identifier(table)}"
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 execute_async = async_(cursor.execute)
                 await execute_async(delete_statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 executemany_async = async_(cursor.executemany)
                 await executemany_async(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/mysqlconnector/config.py

@@ -24,7 +24,7 @@ from sqlspec.adapters.mysqlconnector.driver import (
 )
 from sqlspec.config import ExtensionConfigs, NoPoolAsyncConfig, SyncDatabaseConfig
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -231,8 +231,6 @@ class MysqlConnectorSyncConfig(
         observability_config: "ObservabilityConfig | None" = None,
         **kwargs: Any,
     ) -> None:
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
         connection_config.setdefault("host", "localhost")
         connection_config.setdefault("port", 3306)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/mysqlconnector/driver.py

@@ -227,14 +227,20 @@ class MysqlConnectorSyncDriver(SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = f"TRUNCATE TABLE {format_identifier(table)}"
-            with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
                 cursor.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
                 cursor.executemany(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
@@ -436,14 +442,20 @@ class MysqlConnectorAsyncDriver(AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = f"TRUNCATE TABLE {format_identifier(table)}"
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.executemany(insert_sql, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/oracledb/config.py

@@ -27,7 +27,7 @@ from sqlspec.adapters.oracledb.driver import (
 )
 from sqlspec.adapters.oracledb.migrations import OracleAsyncMigrationTracker, OracleSyncMigrationTracker
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs, SyncDatabaseConfig
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -205,8 +205,6 @@ class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "OracleSyncConne
             extension_config: Extension-specific configuration (e.g., Litestar plugin settings).
             **kwargs: Additional keyword arguments.
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
         statement_config = statement_config or default_statement_config
 
@@ -420,8 +418,6 @@ class OracleAsyncConfig(AsyncDatabaseConfig[OracleAsyncConnection, "OracleAsyncC
             extension_config: Extension-specific configuration (e.g., Litestar plugin settings).
             **kwargs: Additional keyword arguments.
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
 
         driver_features = apply_driver_features(driver_features)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/oracledb/driver.py

@@ -634,13 +634,19 @@ class OracleSyncDriver(OraclePipelineMixin, SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = build_truncate_statement(table)
-            with self.handle_database_exceptions():
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler:
                 self.connection.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             statement = build_insert_statement(table, columns)
-            with self.with_cursor(self.connection) as cursor, self.handle_database_exceptions():
+            exc_handler = self.handle_database_exceptions()
+            with self.with_cursor(self.connection) as cursor, exc_handler:
                 cursor.executemany(statement, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
         self._attach_partition_telemetry(telemetry_payload, partitioner)
@@ -1087,13 +1093,19 @@ class OracleAsyncDriver(OraclePipelineMixin, AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             statement = build_truncate_statement(table)
-            async with self.handle_database_exceptions():
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler:
                 await self.connection.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             statement = build_insert_statement(table, columns)
-            async with self.with_cursor(self.connection) as cursor, self.handle_database_exceptions():
+            exc_handler = self.handle_database_exceptions()
+            async with self.with_cursor(self.connection) as cursor, exc_handler:
                 await cursor.executemany(statement, records)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
         self._attach_partition_telemetry(telemetry_payload, partitioner)

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/psqlpy/config.py

@@ -11,7 +11,7 @@ from sqlspec.adapters.psqlpy.core import apply_driver_features, build_connection
 from sqlspec.adapters.psqlpy.driver import PsqlpyCursor, PsqlpyDriver, PsqlpyExceptionHandler, PsqlpySessionContext
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -187,8 +187,6 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
             extension_config: Extension-specific configuration (e.g., Litestar plugin settings).
             **kwargs: Additional keyword arguments.
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
 
         statement_config = statement_config or default_statement_config

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/psqlpy/driver.py

@@ -333,13 +333,17 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             qualified = format_table_identifier(table)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 await cursor.execute(f"TRUNCATE TABLE {qualified}")
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             schema_name, table_name = split_schema_and_table(table)
-            async with self.handle_database_exceptions(), self.with_cursor(self.connection) as cursor:
+            exc_handler = self.handle_database_exceptions()
+            async with exc_handler, self.with_cursor(self.connection) as cursor:
                 copy_kwargs: dict[str, Any] = {"columns": columns}
                 if schema_name:
                     copy_kwargs["schema_name"] = schema_name
@@ -355,6 +359,8 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
                     insert_operation = cursor.execute_many(insert_sql, formatted_records)
                     if inspect.isawaitable(insert_operation):
                         await insert_operation
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
 
         telemetry_payload = self._build_ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table

{sqlspec-0.36.0 → sqlspec-0.36.2}/sqlspec/adapters/psycopg/config.py

@@ -23,7 +23,7 @@ from sqlspec.adapters.psycopg.type_converter import register_pgvector_async, reg
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs, SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
-from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.config_tools import normalize_connection_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -195,8 +195,6 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
             extension_config: Extension-specific configuration (e.g., Litestar plugin settings)
             **kwargs: Additional keyword arguments
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
 
         statement_config = statement_config or default_statement_config
@@ -426,8 +424,6 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             extension_config: Extension-specific configuration (e.g., Litestar plugin settings)
             **kwargs: Additional keyword arguments
         """
-        reject_pool_aliases(kwargs)
-
         connection_config = normalize_connection_config(connection_config)
 
         statement_config = statement_config or default_statement_config