sqlspec 0.36.1__tar.gz → 0.36.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.36.1
+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.1 → 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.1"
+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.1"
+current_version = "0.36.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.36.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → sqlspec-0.36.2}/sqlspec/adapters/psycopg/driver.py

@@ -384,6 +384,10 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
     def _execute_stack_pipeline(
         self, stack: "StatementStack", prepared_ops: "list[PreparedStackOperation]"
     ) -> "tuple[StackResult, ...]":
+        def _raise_pending_exception(exception_ctx: "PsycopgSyncExceptionHandler") -> None:
+            if exception_ctx.pending_exception is not None:
+                raise exception_ctx.pending_exception from None
+
         results: list[StackResult] = []
         started_transaction = False
 
@@ -393,12 +397,14 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
                     self.begin()
                     started_transaction = True
 
+                exception_handlers = []
                 with ExitStack() as resource_stack:
                     pipeline = resource_stack.enter_context(self.connection.pipeline())
                     pending: list[PipelineCursorEntry] = []
 
                     for prepared in prepared_ops:
                         exception_ctx = self.handle_database_exceptions()
+                        exception_handlers.append(exception_ctx)
                         resource_stack.enter_context(exception_ctx)
                         cursor = resource_stack.enter_context(self.with_cursor(self.connection))
 
@@ -428,6 +434,9 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
                         sql_result = self.build_statement_result(statement, execution_result)
                         results.append(StackResult.from_sql_result(sql_result))
 
+                for exception_ctx in exception_handlers:
+                    _raise_pending_exception(exception_ctx)
+
                 if started_transaction:
                     self.commit()
             except Exception:
@@ -482,17 +491,23 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             truncate_sql = build_truncate_command(table)
-            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.execute(truncate_sql)
+            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:
             copy_sql = build_copy_from_command(table, columns)
+            exc_handler = self.handle_database_exceptions()
             with ExitStack() as stack:
-                stack.enter_context(self.handle_database_exceptions())
+                stack.enter_context(exc_handler)
                 cursor = stack.enter_context(self.with_cursor(self.connection))
                 copy_ctx = stack.enter_context(cursor.copy(copy_sql))
                 for record in records:
                     copy_ctx.write_row(record)
+            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)
@@ -818,6 +833,10 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
     async def _execute_stack_pipeline(
         self, stack: "StatementStack", prepared_ops: "list[PreparedStackOperation]"
     ) -> "tuple[StackResult, ...]":
+        def _raise_pending_exception(exception_ctx: "PsycopgAsyncExceptionHandler") -> None:
+            if exception_ctx.pending_exception is not None:
+                raise exception_ctx.pending_exception from None
+
         results: list[StackResult] = []
         started_transaction = False
 
@@ -827,12 +846,14 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
                     await self.begin()
                     started_transaction = True
 
+                exception_handlers = []
                 async with AsyncExitStack() as resource_stack:
                     pipeline = await resource_stack.enter_async_context(self.connection.pipeline())
                     pending: list[PipelineCursorEntry] = []
 
                     for prepared in prepared_ops:
                         exception_ctx = self.handle_database_exceptions()
+                        exception_handlers.append(exception_ctx)
                         await resource_stack.enter_async_context(exception_ctx)
                         cursor = await resource_stack.enter_async_context(self.with_cursor(self.connection))
 
@@ -862,6 +883,9 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
                         sql_result = self.build_statement_result(statement, execution_result)
                         results.append(StackResult.from_sql_result(sql_result))
 
+                for exception_ctx in exception_handlers:
+                    _raise_pending_exception(exception_ctx)
+
                 if started_transaction:
                     await self.commit()
             except Exception:
@@ -916,17 +940,23 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             truncate_sql = build_truncate_command(table)
-            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.execute(truncate_sql)
+            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:
             copy_sql = build_copy_from_command(table, columns)
+            exc_handler = self.handle_database_exceptions()
             async with AsyncExitStack() as stack:
-                await stack.enter_async_context(self.handle_database_exceptions())
+                await stack.enter_async_context(exc_handler)
                 cursor = await stack.enter_async_context(self.with_cursor(self.connection))
                 copy_ctx = await stack.enter_async_context(cursor.copy(copy_sql))
                 for record in records:
                     await copy_ctx.write_row(record)
+            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.1 → sqlspec-0.36.2}/sqlspec/adapters/pymysql/driver.py

@@ -211,14 +211,20 @@ class PyMysqlDriver(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

{sqlspec-0.36.1 → sqlspec-0.36.2}/sqlspec/adapters/sqlite/driver.py

@@ -300,14 +300,20 @@ class SqliteDriver(SyncDriverAdapterBase):
         arrow_table = self._coerce_arrow_table(source)
         if overwrite:
             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(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

{sqlspec-0.36.1 → sqlspec-0.36.2}/tests/integration/adapters/adbc/test_exceptions.py

@@ -13,6 +13,8 @@ from sqlspec.exceptions import (
     SQLParsingError,
     UniqueViolationError,
 )
+from sqlspec.typing import PYARROW_INSTALLED
+from tests.integration.adapters.adbc.conftest import xfail_if_driver_missing
 
 pytestmark = pytest.mark.xdist_group("postgres")
 
@@ -116,3 +118,11 @@ def test_sql_parsing_error(adbc_exception_session: AdbcDriver) -> None:
         adbc_exception_session.execute("SELCT * FROM nonexistent_table")
 
     assert "syntax" in str(exc_info.value).lower() or "pars" in str(exc_info.value).lower()
+
+
+@pytest.mark.skipif(not PYARROW_INSTALLED, reason="pyarrow missing")
+@xfail_if_driver_missing
+def test_select_to_arrow_raises_mapped_exception(adbc_exception_session: AdbcDriver) -> None:
+    """Test select_to_arrow re-raises mapped database errors."""
+    with pytest.raises(SQLParsingError):
+        adbc_exception_session.select_to_arrow("SELECT * FROM missing_arrow_table")