Copy rowcount and lastrowid on the async adapter RETURNING path

AsyncAdaptedCursor.execute and executemany cleared rowcount and
lastrowid at the top of each call and only re-populated them in
the non-description (DML) branch. The underlying AsyncCursor also
sets rowcount = len(rows) on the RETURNING path (and lastrowid on
INSERT ... RETURNING), so discarding those values left
result.rowcount pinned at -1 and silently collapsed the PEP 249
"affected rows" signal into "not determinable" whenever a
statement returned rows.

Mirror the DML-branch assignment after the fetch-first-then-assign
block so the atomicity pattern (ISSUE-252) is preserved: a
fetchall() raise still leaves description / _rows / rowcount /
lastrowid consistent with the pre-call cleared state. Both
execute() and executemany() pick the change up; existing
executemany-RETURNING test is extended to assert rowcount /
lastrowid and a new test pins the single-execute case.

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

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -97,6 +97,14 @@ def execute(self, operation: str, parameters: Any = None) -> None:
                 fetched = deque(await_only(cursor.fetchall()))
                 self.description = cursor.description
                 self._rows = fetched
+                # Mirror the DML branch: rowcount / lastrowid are set by
+                # the underlying cursor on the RETURNING path too
+                # (rowcount = len(rows); lastrowid from the last
+                # INSERT). SQLAlchemy's Result layer reads both through
+                # the adapter, so leaving rowcount at -1 would silently
+                # collapse "N rows returned" into "not determinable".
+                self.rowcount = cursor.rowcount
+                self.lastrowid = cursor.lastrowid
             else:
                 self.lastrowid = cursor.lastrowid
                 self.rowcount = cursor.rowcount
@@ -127,6 +135,12 @@ def executemany(self, operation: str, seq_of_parameters: Iterable[Sequence[Any]]
                 fetched = deque(await_only(cursor.fetchall()))
                 self.description = cursor.description
                 self._rows = fetched
+                # Mirror execute()'s RETURNING path: rowcount /
+                # lastrowid are accumulated by the underlying cursor
+                # across parameter sets and must flow through the
+                # adapter so SQLAlchemy's Result layer sees them.
+                self.rowcount = cursor.rowcount
+                self.lastrowid = cursor.lastrowid
             else:
                 self.lastrowid = cursor.lastrowid
                 self.rowcount = cursor.rowcount

tests/test_async_adapter.py

@@ -98,6 +98,11 @@ def test_executemany_returning_captures_rows_and_description(self) -> None:
         mock_inner.executemany.return_value = None
         mock_inner.fetchall.return_value = returned_rows
         mock_inner.close.return_value = None
+        # Underlying AsyncCursor sets rowcount = len(rows) for the
+        # RETURNING path; the adapter must mirror it so
+        # result.rowcount in SQLAlchemy is not stuck at -1.
+        mock_inner.rowcount = len(returned_rows)
+        mock_inner.lastrowid = 3
         cursor._connection.cursor.return_value = mock_inner
 
         with patch("sqlalchemydqlite.aio.await_only", side_effect=_run_sync):
@@ -107,11 +112,44 @@ def test_executemany_returning_captures_rows_and_description(self) -> None:
             )
 
         assert cursor.description == description
+        assert cursor.rowcount == len(returned_rows)
+        assert cursor.lastrowid == 3
         assert cursor.fetchone() == (1, "a")
         assert cursor.fetchone() == (2, "b")
         assert cursor.fetchone() == (3, "c")
         assert cursor.fetchone() is None
 
+    def test_execute_returning_captures_rows_rowcount_and_lastrowid(self) -> None:
+        """Single-execute RETURNING: the adapter must copy rowcount
+        and lastrowid from the underlying cursor alongside description
+        and rows, so SQLAlchemy's Result layer sees the affected-row
+        count for INSERT ... RETURNING.
+        """
+        cursor = _make_cursor()
+
+        mock_inner = MagicMock()
+        returned_rows = [(7, "alice")]
+        description = [
+            ("id", 1, None, None, None, None, None),
+            ("name", 3, None, None, None, None, None),
+        ]
+        mock_inner.description = description
+        mock_inner.execute.return_value = None
+        mock_inner.fetchall.return_value = returned_rows
+        mock_inner.close.return_value = None
+        mock_inner.rowcount = 1
+        mock_inner.lastrowid = 7
+        cursor._connection.cursor.return_value = mock_inner
+
+        with patch("sqlalchemydqlite.aio.await_only", side_effect=_run_sync):
+            cursor.execute("INSERT INTO t (name) VALUES (?) RETURNING id, name", ("alice",))
+
+        assert cursor.description == description
+        assert cursor.rowcount == 1
+        assert cursor.lastrowid == 7
+        assert cursor.fetchone() == (7, "alice")
+        assert cursor.fetchone() is None
+
 
 def _has_finally_with_close(func: object) -> bool:
     """Check if a function has cursor.close() inside a finally block."""