fix: raise InterfaceError for nested transactions instead of OperationalError(0)

Nested transactions are client-side misuse, not a server operational
error. Using OperationalError with code=0 (SQLITE_OK) was semantically
incorrect. InterfaceError is the right exception type, consistent with
how _check_in_use() handles other misuse patterns.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/connection.py

@@ -305,9 +305,7 @@ async def fetchval(self, sql: str, params: Sequence[Any] | None = None) -> Any:
     async def transaction(self) -> AsyncIterator[None]:
         """Context manager for transactions."""
         if self._in_transaction:
-            raise OperationalError(
-                0, "Nested transactions are not supported; use SAVEPOINT directly"
-            )
+            raise InterfaceError("Nested transactions are not supported; use SAVEPOINT directly")
 
         self._in_transaction = True
         self._tx_owner = asyncio.current_task()

tests/test_connection.py

@@ -210,10 +210,10 @@ async def mock_execute(sql: str, params=None):
 
         conn.execute = mock_execute  # type: ignore[assignment]
 
-        from dqliteclient.exceptions import OperationalError
+        from dqliteclient.exceptions import InterfaceError
 
         async with conn.transaction():
-            with pytest.raises(OperationalError, match="[Nn]ested"):
+            with pytest.raises(InterfaceError, match="[Nn]ested"):
                 async with conn.transaction():
                     pass
 
@@ -816,11 +816,11 @@ async def do_execute():
         with pytest.raises(asyncio.CancelledError):
             await task
 
-    async def test_concurrent_transaction_raises_operational_error(self) -> None:
-        """Second concurrent transaction() must raise OperationalError, not InterfaceError."""
+    async def test_concurrent_transaction_raises_interface_error(self) -> None:
+        """Second concurrent transaction() must raise InterfaceError about nesting."""
         import asyncio
 
-        from dqliteclient.exceptions import InterfaceError, OperationalError
+        from dqliteclient.exceptions import InterfaceError
 
         conn = DqliteConnection("localhost:9001")
 
@@ -863,22 +863,21 @@ async def tx_b():
             try:
                 async with conn.transaction():
                     pass
-            except (OperationalError, InterfaceError) as e:
+            except InterfaceError as e:
                 errors.append(e)
 
         task_a = asyncio.create_task(tx_a())
         task_b = asyncio.create_task(tx_b())
 
-        await task_b  # should raise OperationalError about nested transactions
+        await task_b  # should raise InterfaceError about nested transactions
 
         task_a.cancel()
         with pytest.raises(asyncio.CancelledError):
             await task_a
 
         assert len(errors) == 1
-        # Must get OperationalError about nested transactions, NOT InterfaceError
-        assert isinstance(errors[0], OperationalError), (
-            f"Expected OperationalError about nested transactions, "
+        assert isinstance(errors[0], InterfaceError), (
+            f"Expected InterfaceError about nested transactions, "
             f"got {type(errors[0]).__name__}: {errors[0]}"
         )
         assert "Nested" in str(errors[0]) or "nested" in str(errors[0])