executemany([]) clears prior SELECT state

executemany with an empty seq_of_parameters used to leave
_description / _rows untouched from any preceding SELECT on the
same cursor. A caller checking cursor.description after
executemany([]) saw stale column metadata from the prior query —
a subtle trap.

Now both sync Cursor._executemany_async and AsyncCursor.executemany
clear description/rows/row_index before the loop, so an empty
parameter sequence leaves the cursor in a clean "no result set"
state.

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

Author: antoineleclair

src/dqlitedbapi/aio/cursor.py

@@ -121,9 +121,17 @@ async def execute(
     async def executemany(
         self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
     ) -> "AsyncCursor":
-        """Execute a database operation multiple times."""
+        """Execute a database operation multiple times.
+
+        An empty ``seq_of_parameters`` must not leave stale SELECT
+        state around: reset description / rows so callers can't
+        confuse an empty executemany with a preceding SELECT.
+        """
         self._check_closed()
 
+        self._description = None
+        self._rows = []
+        self._row_index = 0
         total_affected = 0
         for params in seq_of_parameters:
             await self.execute(operation, params)

src/dqlitedbapi/cursor.py

@@ -240,7 +240,16 @@ def executemany(self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
     async def _executemany_async(
         self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
     ) -> None:
-        """Async implementation of executemany."""
+        """Async implementation of executemany.
+
+        An empty ``seq_of_parameters`` must not leave stale SELECT
+        state around: reset description / rows to None / empty so
+        callers can't confuse an empty executemany with a preceding
+        SELECT.
+        """
+        self._description = None
+        self._rows = []
+        self._row_index = 0
         total_affected = 0
         for params in seq_of_parameters:
             await self._execute_async(operation, params)

tests/test_executemany_empty.py

@@ -0,0 +1,43 @@
+"""executemany([]) doesn't leak stale SELECT state (ISSUE-34)."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+from dqlitedbapi.cursor import Cursor
+
+
+def _cursor_with_prior_select() -> Cursor:
+    conn = MagicMock()
+    c = Cursor(conn)
+    c._description = [("id", None, None, None, None, None, None)]
+    c._rows = [(1,), (2,)]
+    c._rowcount = 2
+    return c
+
+
+class TestExecutemanyEmpty:
+    def test_empty_executemany_clears_description(self) -> None:
+        """After executemany([]) the cursor must not appear to hold a
+        prior SELECT result."""
+        c = _cursor_with_prior_select()
+        # Mock _run_sync so we don't need a loop.
+        c._connection._run_sync = MagicMock(side_effect=lambda coro: coro.close() or None)
+        c._connection._check_thread = MagicMock()
+
+        # Directly drive _executemany_async — it's the code we're
+        # verifying. Run it synchronously via a throwaway event loop.
+        import asyncio
+
+        asyncio.run(_run_empty(c))
+
+        assert c.description is None
+        assert c._rows == []
+        assert c.rowcount == 0
+
+
+async def _run_empty(c: Cursor) -> None:
+    # Stub _execute_async so we don't need the full connection pathway.
+    async def _noop(*_a: object, **_kw: object) -> None:
+        return None
+
+    c._execute_async = _noop  # type: ignore[method-assign]
+    await c._executemany_async("INSERT INTO t VALUES (?)", [])