fix: drop unreachable drain loop from query_sql

The C dqlite server rejects multi-statement SELECT with a FailureResponse
(SQLITE_ERROR, "nonempty statement tail") rather than emitting additional
RowsResponse frames: handle_query_work_cb checks is_statement_empty on
the tail and, if non-empty, routes to handle_query_sql_done_cb which
emits a failure. The "drain extra result sets" loop added by #054 was
therefore unreachable dead code built on a misreading of the server.

Remove the loop. Update the docstring to note the real behaviour.
Replace the test that simulated the dead-code path with one asserting
the client leaves stray bytes in the buffer instead of silently
consuming them.

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

Author: antoineleclair

src/dqliteclient/protocol.py

@@ -170,7 +170,9 @@ async def query_sql(
     ) -> tuple[list[str], list[list[Any]]]:
         """Execute a query directly.
 
-        Returns (column_names, rows).
+        Returns (column_names, rows). Multi-statement SELECT is rejected
+        by the server with OperationalError(SQLITE_ERROR, "nonempty
+        statement tail") — there are no additional result sets to drain.
         """
         request = QuerySqlRequest(db_id=db_id, sql=sql, params=params if params is not None else [])
         self._writer.write(request.encode())
@@ -184,7 +186,6 @@ async def query_sql(
         if not isinstance(response, RowsResponse):
             raise ProtocolError(f"Expected RowsResponse, got {type(response).__name__}")
 
-        # Store column names from first response
         column_names = response.column_names
 
         # Handle multi-part responses via decode_continuation(),
@@ -197,12 +198,6 @@ async def query_sql(
             all_rows.extend(next_response.rows)
             response = next_response
 
-        # Drain any extra result sets from multi-statement SQL
-        while self._decoder.has_message():
-            extra = await self._read_response()
-            if isinstance(extra, FailureResponse):
-                raise OperationalError(extra.code, extra.message)
-
         return column_names, all_rows
 
     async def _read_data(self) -> bytes:

tests/test_protocol.py

@@ -156,38 +156,41 @@ async def test_exec_sql_reads_single_response(
         # The stray message must still be buffered — not silently consumed.
         assert protocol._decoder.has_message()
 
-    async def test_query_sql_multi_statement_drains_extra(
+    async def test_query_sql_reads_single_response(
         self,
         protocol: DqliteProtocol,
         mock_reader: AsyncMock,
     ) -> None:
-        """Multi-statement queries should drain extra result sets, not corrupt buffer."""
+        """query_sql reads exactly one RowsResponse — it must not drain extras.
+
+        The C server rejects multi-statement SELECT with a FailureResponse
+        ("nonempty statement tail") rather than sending multiple RowsResponses.
+        Any stray post-response bytes must be left alone, not silently
+        consumed.
+        """
         from dqlitewire.constants import ValueType
         from dqlitewire.messages import RowsResponse
 
-        # Two result sets from "SELECT 1; SELECT 2"
         rows1 = RowsResponse(
             column_names=["a"],
             column_types=[ValueType.INTEGER],
             rows=[[1]],
             has_more=False,
         )
-        rows2 = RowsResponse(
+        stray = RowsResponse(
             column_names=["b"],
             column_types=[ValueType.INTEGER],
             rows=[[2]],
             has_more=False,
         )
-        mock_reader.read.return_value = rows1.encode() + rows2.encode()
+        mock_reader.read.return_value = rows1.encode() + stray.encode()
 
-        columns, rows = await protocol.query_sql(1, "SELECT 1; SELECT 2")
+        columns, rows = await protocol.query_sql(1, "SELECT 1")
 
-        # Returns first result set
         assert columns == ["a"]
         assert rows == [[1]]
-
-        # Decoder buffer should be clean -- extra result set was drained
-        assert not protocol._decoder.has_message()
+        # Stray response must remain in the buffer, not silently consumed.
+        assert protocol._decoder.has_message()
 
     async def test_query_sql(
         self,