Add executescript and interrupt NotSupportedError stubs across sync + async surfaces

stdlib ``sqlite3.Connection`` and ``sqlite3.Cursor`` both
expose ``executescript``; ``sqlite3.Connection`` also
exposes ``interrupt``. aiosqlite mirrors all three on the
async surface. Cross-driver code that ports from stdlib /
aiosqlite hit bare ``AttributeError`` — escapes
``except dbapi.Error:`` and the SA dialect cannot
translate.

Add ``NotSupportedError`` stubs (NOT real implementations)
on all four surfaces (sync Connection / sync Cursor /
async Connection / async Cursor) so the failure stays in
the dbapi error hierarchy. Same shape as the existing
TPC / load_extension / backup / iterdump / create_*
stubs.

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

Author: antoineleclair

src/dqlitedbapi/aio/connection.py

@@ -952,6 +952,23 @@ async def tpc_recover(self) -> NoReturn:
     def xid(self, format_id: int, global_transaction_id: str, branch_qualifier: str) -> NoReturn:
         raise NotSupportedError("dqlite does not support two-phase commit")
 
+    async def executescript(self, sql_script: str) -> NoReturn:
+        """stdlib ``sqlite3``-parity stub. dqlite has no
+        multi-statement-script primitive on the wire; raises
+        ``NotSupportedError`` rather than escaping ``dbapi.Error``
+        as ``AttributeError``. Mirrors the sync sibling."""
+        raise NotSupportedError(
+            "dqlite does not support stdlib sqlite3 executescript; "
+            "split the script and execute each statement individually"
+        )
+
+    def interrupt(self) -> NoReturn:
+        """stdlib ``sqlite3``-parity stub. See sync sibling."""
+        raise NotSupportedError(
+            "dqlite does not surface interrupt() at the dbapi layer; "
+            "use asyncio.timeout(...) or rely on the per-RPC timeout"
+        )
+
     def enable_load_extension(self, enabled: bool) -> NoReturn:
         raise NotSupportedError("dqlite-server does not support runtime extension loading")
 

src/dqlitedbapi/aio/cursor.py

@@ -662,6 +662,19 @@ def scroll(self, value: int, mode: str = "relative") -> None:
         self._connection._check_loop_binding()
         raise NotSupportedError("dqlite cursors are not scrollable")
 
+    async def executescript(self, sql_script: str) -> NoReturn:
+        """stdlib ``sqlite3.Cursor``-parity stub. See sync sibling."""
+        del self.messages[:]
+        conn_messages = getattr(self._connection, "messages", None)
+        if conn_messages is not None:
+            del conn_messages[:]
+        self._check_closed()
+        self._connection._check_loop_binding()
+        raise NotSupportedError(
+            "dqlite does not support stdlib sqlite3 executescript; "
+            "split the script and execute each statement individually"
+        )
+
     def __repr__(self) -> str:
         state = "closed" if self._closed else "open"
         # Include the parent connection's address and ``id(self)`` so

src/dqlitedbapi/connection.py

@@ -1407,6 +1407,30 @@ def tpc_recover(self) -> NoReturn:
     def xid(self, format_id: int, global_transaction_id: str, branch_qualifier: str) -> NoReturn:
         raise NotSupportedError("dqlite does not support two-phase commit")
 
+    def executescript(self, sql_script: str) -> NoReturn:
+        """stdlib ``sqlite3``-parity stub. dqlite has no
+        multi-statement-script primitive on the wire (each statement
+        requires a separate Prepare → Exec / Query round-trip), so
+        this raises ``NotSupportedError`` rather than escaping
+        ``dbapi.Error`` as ``AttributeError``. Callers should split
+        the script and ``execute`` each statement individually."""
+        raise NotSupportedError(
+            "dqlite does not support stdlib sqlite3 executescript; "
+            "split the script and execute each statement individually"
+        )
+
+    def interrupt(self) -> NoReturn:
+        """stdlib ``sqlite3``-parity stub. dqlite's wire-level
+        interrupt primitive is not surfaced at the dbapi layer in
+        this driver. Callers needing cross-thread cancellation
+        should wrap calls in ``asyncio.timeout`` (async surface)
+        or rely on the configured per-RPC timeout."""
+        raise NotSupportedError(
+            "dqlite does not surface interrupt() at the dbapi layer; "
+            "use asyncio.timeout(...) on the async surface or rely "
+            "on the per-RPC timeout"
+        )
+
     def enable_load_extension(self, enabled: bool) -> NoReturn:
         raise NotSupportedError("dqlite-server does not support runtime extension loading")
 

src/dqlitedbapi/cursor.py

@@ -1395,6 +1395,23 @@ def scroll(self, value: int, mode: str = "relative") -> None:
         self._check_closed()
         raise NotSupportedError("dqlite cursors are not scrollable")
 
+    def executescript(self, sql_script: str) -> NoReturn:
+        """stdlib ``sqlite3.Cursor``-parity stub. dqlite has no
+        multi-statement-script primitive on the wire; raises
+        ``NotSupportedError`` rather than escaping ``dbapi.Error``
+        as ``AttributeError``. Same shape as the
+        ``Connection.executescript`` stub."""
+        del self.messages[:]
+        conn_messages = getattr(self._connection, "messages", None)
+        if conn_messages is not None:
+            del conn_messages[:]
+        self._connection._check_thread()
+        self._check_closed()
+        raise NotSupportedError(
+            "dqlite does not support stdlib sqlite3 executescript; "
+            "split the script and execute each statement individually"
+        )
+
     def __repr__(self) -> str:
         state = "closed" if self._closed else "open"
         # Include the parent connection's address and ``id(self)`` so