Add optional PEP 249 methods to AsyncAdaptedCursor

The greenlet adapter implemented the hot-path cursor surface but left
four PEP 249 optional extensions unhandled: callproc, nextset, scroll,
and the `connection` property. Missing them means a consumer that
expects `cursor.nextset()` to raise NotSupportedError (as both the sync
Cursor and async AsyncCursor do) gets AttributeError instead.

Add the three NotSupportedError-raising methods and the connection
property so the adapter presents a consistent optional-extension
surface. Skip `rownumber`: the adapter buffers rows in a deque that is
popped left as the user consumes them, so a truthful counter would need
parallel state increments on every fetch path. Consumers who need
rownumber should use AsyncCursor directly — documented inline.

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

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -11,7 +11,7 @@
 from sqlalchemy.util import await_only
 
 from dqliteclient.exceptions import DqliteConnectionError
-from dqlitedbapi.exceptions import InterfaceError, OperationalError
+from dqlitedbapi.exceptions import InterfaceError, NotSupportedError, OperationalError
 from sqlalchemydqlite.base import DqliteDialect
 
 __all__ = ["DqliteDialect_aio"]
@@ -105,6 +105,36 @@ def setinputsizes(self, *inputsizes: Any) -> None:
     def setoutputsize(self, size: int, column: int | None = None) -> None:
         pass
 
+    @property
+    def connection(self) -> "AsyncAdaptedConnection":
+        """The AsyncAdaptedConnection this cursor was created from.
+
+        PEP 249 optional extension mirroring Cursor.connection /
+        AsyncCursor.connection. Read-only.
+        """
+        return self._adapt_connection
+
+    # PEP 249 optional extensions. The non-adapter cursors raise
+    # NotSupportedError for these same calls; do the same here so a
+    # consumer catching NotSupportedError behaves consistently whether it
+    # is handed an AsyncCursor or a greenlet-wrapped AsyncAdaptedCursor.
+    #
+    # `rownumber` is deliberately NOT implemented: the adapter buffers
+    # rows into a deque that is popped left on consumption, so a truthful
+    # counter would need parallel state increments in fetchone /
+    # fetchmany / fetchall / __next__. Consumers who need rownumber
+    # should use AsyncCursor directly.
+    def callproc(
+        self, procname: str, parameters: Sequence[Any] | None = None
+    ) -> Sequence[Any] | None:
+        raise NotSupportedError("dqlite does not support stored procedures")
+
+    def nextset(self) -> bool | None:
+        raise NotSupportedError("dqlite does not support multiple result sets")
+
+    def scroll(self, value: int, mode: str = "relative") -> None:
+        raise NotSupportedError("dqlite cursors are not scrollable")
+
     def __iter__(self) -> Any:
         while self._rows:
             yield self._rows.popleft()

tests/test_async_adapter.py

@@ -89,6 +89,39 @@ def _has_finally_with_close(func: object) -> bool:
     return False
 
 
+class TestAsyncAdaptedCursorOptionalMethods:
+    def test_connection_property_returns_adapter(self) -> None:
+        cursor = _make_cursor()
+        assert cursor.connection is cursor._adapt_connection
+
+    def test_callproc_raises_not_supported(self) -> None:
+        import pytest
+
+        from dqlitedbapi.exceptions import NotSupportedError
+
+        cursor = _make_cursor()
+        with pytest.raises(NotSupportedError):
+            cursor.callproc("sp_foo")
+
+    def test_nextset_raises_not_supported(self) -> None:
+        import pytest
+
+        from dqlitedbapi.exceptions import NotSupportedError
+
+        cursor = _make_cursor()
+        with pytest.raises(NotSupportedError):
+            cursor.nextset()
+
+    def test_scroll_raises_not_supported(self) -> None:
+        import pytest
+
+        from dqlitedbapi.exceptions import NotSupportedError
+
+        cursor = _make_cursor()
+        with pytest.raises(NotSupportedError):
+            cursor.scroll(5)
+
+
 class TestAsyncAdaptedCursorCleanup:
     def test_cursor_closed_on_execute_error(self) -> None:
         """Underlying cursor must be closed even if execute() raises."""