fix: drop unreachable drain loop from exec_sql

The C dqlite server aggregates multi-statement EXEC_SQL internally and
emits exactly one RESULT frame (handle_exec_sql_done_cb recurses on
exec->tail; fill_result reports sqlite3_changes of the last statement
only). The drain loop added by #029 never ran more than once in
practice and mis-advertised semantics ("sum of all rows_affected") the
server cannot deliver.

Read a single ResultResponse and return it. Update the docstring to
reflect the real server behaviour. Replace the test that simulated
the dead-code path with one asserting the client does not silently
consume stray responses.

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

Author: antoineleclair

src/dqliteclient/protocol.py

@@ -147,33 +147,23 @@ async def exec_sql(
         """Execute SQL directly.
 
         Returns (last_insert_id, rows_affected). For multi-statement SQL
-        (semicolon-separated), returns the last statement's last_insert_id
-        and the sum of all rows_affected, matching the Go client behavior.
+        (semicolon-separated), the server aggregates internally and returns
+        a single RESULT with sqlite3_changes() of the last statement only —
+        rows_affected is NOT a sum across statements.
         """
         request = ExecSqlRequest(db_id=db_id, sql=sql, params=params if params is not None else [])
         self._writer.write(request.encode())
         await self._writer.drain()
 
-        last_insert_id = 0
-        rows_affected = 0
-
-        while True:
-            response = await self._read_response()
-
-            if isinstance(response, FailureResponse):
-                raise OperationalError(response.code, response.message)
-
-            if not isinstance(response, ResultResponse):
-                raise ProtocolError(f"Expected ResultResponse, got {type(response).__name__}")
+        response = await self._read_response()
 
-            last_insert_id = response.last_insert_id
-            rows_affected += response.rows_affected
+        if isinstance(response, FailureResponse):
+            raise OperationalError(response.code, response.message)
 
-            # Check for more results from multi-statement SQL
-            if not self._decoder.has_message():
-                break
+        if not isinstance(response, ResultResponse):
+            raise ProtocolError(f"Expected ResultResponse, got {type(response).__name__}")
 
-        return last_insert_id, rows_affected
+        return response.last_insert_id, response.rows_affected
 
     async def query_sql(
         self, db_id: int, sql: str, params: Sequence[Any] | None = None

tests/test_protocol.py

@@ -126,30 +126,35 @@ async def test_exec_sql_with_empty_tuple_params(
         # Verify the request was written (meaning params=() was accepted)
         mock_writer.write.assert_called()
 
-    async def test_exec_sql_multi_statement(
+    async def test_exec_sql_reads_single_response(
         self,
         protocol: DqliteProtocol,
         mock_reader: AsyncMock,
     ) -> None:
-        """Multi-statement SQL should drain all ResultResponse messages."""
+        """exec_sql reads exactly one ResultResponse — it must not drain extras.
+
+        The C dqlite server emits exactly one RESULT per EXEC_SQL call, even
+        for multi-statement SQL: handle_exec_sql_done_cb recurses internally
+        on exec->tail and calls SUCCESS(..., RESULT) only after the last
+        statement completes. fill_result reports sqlite3_changes() of the
+        last statement only.
+
+        If any additional response bytes are buffered (server protocol
+        violation, pipelining, test artefact), the client must leave them
+        alone rather than silently consuming them.
+        """
         from dqlitewire.messages import ResultResponse
 
-        # Server sends two ResultResponse messages (one per statement)
         result1 = ResultResponse(last_insert_id=1, rows_affected=1)
-        result2 = ResultResponse(last_insert_id=2, rows_affected=1)
-        # Both arrive in a single read
-        mock_reader.read.return_value = result1.encode() + result2.encode()
+        stray = ResultResponse(last_insert_id=99, rows_affected=99)
+        mock_reader.read.return_value = result1.encode() + stray.encode()
 
-        last_id, rows_affected = await protocol.exec_sql(
-            1, "INSERT INTO t VALUES (1); INSERT INTO t VALUES (2)"
-        )
-
-        # Should return the last statement's result with accumulated rows_affected
-        assert last_id == 2
-        assert rows_affected == 2
+        last_id, rows_affected = await protocol.exec_sql(1, "INSERT INTO t VALUES (1)")
 
-        # The decoder buffer should be clean -- no leftover messages
-        assert not protocol._decoder.has_message()
+        assert last_id == 1
+        assert rows_affected == 1
+        # The stray message must still be buffered — not silently consumed.
+        assert protocol._decoder.has_message()
 
     async def test_query_sql_multi_statement_drains_extra(
         self,