Pin insert / update / delete executemany_returning flags True

dqlitedbapi's executemany accumulates per-parameter-set RETURNING rows
via _ExecuteManyAccumulator, a DML-agnostic collector that works
identically for INSERT, UPDATE and DELETE. SQLAlchemy's DefaultDialect
surfaces insert_executemany_returning as a memoized property derived
from other flags, and defaults the UPDATE / DELETE siblings to False,
which blocks the compiler from issuing executemany RETURNING for those
DML kinds. Pin all three locally — INSERT to guard against the derived
property flipping, UPDATE / DELETE to expose the capability the wire
path already supports. New integration coverage exercises each DML
kind end-to-end against the test cluster; a unit test pins the three
flags into DqliteDialect.__dict__ so the pin is load-bearing.

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

Author: antoineleclair

src/sqlalchemydqlite/base.py

@@ -144,6 +144,20 @@ class DqliteDialect(SQLiteDialect):
     delete_returning = True
     update_returning_multifrom = True
 
+    # Executemany-RETURNING flags. dqlitedbapi's executemany accumulates
+    # per-parameter-set RETURNING rows via its _ExecuteManyAccumulator
+    # so all three DML kinds can deliver the full row set in a single
+    # call. The INSERT flag is a memoized property on DefaultDialect
+    # (derived from ``insert_returning and use_insertmanyvalues``) — pin
+    # explicitly so upstream drift can't silently flip it. UPDATE /
+    # DELETE flags default to False on DefaultDialect, which blocks
+    # SQLAlchemy from issuing executemany RETURNING even though the
+    # wire path supports it; pin True to surface the capability.
+    # Integration-verified in tests/integration/test_bulk_dml_returning.py.
+    insert_executemany_returning = True
+    update_executemany_returning = True
+    delete_executemany_returning = True
+
     # SQLite >= 3.7.11 supports multi-row INSERT VALUES, which SQLAlchemy's
     # insertmanyvalues optimisation depends on. Pin the flag so bulk-insert
     # behaviour stays stable against upstream dialect drift.

tests/integration/test_bulk_dml_returning.py

@@ -0,0 +1,120 @@
+"""Verify executemany RETURNING behaviour for INSERT / UPDATE / DELETE.
+
+The SQLAlchemy dialect flags ``insert_executemany_returning``,
+``update_executemany_returning`` and ``delete_executemany_returning``
+describe whether the dialect can deliver per-parameter-set RETURNING
+rows in a single round-trip. These tests exercise the wire path
+end-to-end against the test cluster so the flags can be pinned
+confidently on the dialect itself.
+"""
+
+import uuid
+from collections.abc import Generator
+
+import pytest
+from sqlalchemy import (
+    Column,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    bindparam,
+    create_engine,
+    delete,
+    insert,
+    update,
+)
+from sqlalchemy.engine import Engine
+
+
+@pytest.fixture
+def bulk_table(engine_url: str) -> Generator[tuple[Engine, Table]]:
+    """Per-test engine + freshly-named table so parallel runs don't collide."""
+    table_name = f"bulk_returning_{uuid.uuid4().hex[:8]}"
+    metadata = MetaData()
+    table = Table(
+        table_name,
+        metadata,
+        Column("id", Integer, primary_key=True),
+        Column("label", String(50)),
+    )
+    eng = create_engine(engine_url, future=True)
+    metadata.create_all(eng)
+    try:
+        yield eng, table
+    finally:
+        metadata.drop_all(eng)
+        eng.dispose()
+
+
+class TestInsertExecutemanyReturning:
+    def test_multi_row_insert_returns_each_row(self, bulk_table: tuple[Engine, Table]) -> None:
+        engine, table = bulk_table
+        stmt = insert(table).returning(table.c.id, table.c.label)
+        with engine.begin() as conn:
+            result = conn.execute(
+                stmt,
+                [
+                    {"id": 1, "label": "a"},
+                    {"id": 2, "label": "b"},
+                    {"id": 3, "label": "c"},
+                ],
+            )
+            rows = result.all()
+        assert sorted(rows) == [(1, "a"), (2, "b"), (3, "c")]
+
+
+class TestUpdateExecutemanyReturning:
+    def test_multi_row_update_returns_each_row(self, bulk_table: tuple[Engine, Table]) -> None:
+        engine, table = bulk_table
+        with engine.begin() as conn:
+            conn.execute(
+                insert(table),
+                [
+                    {"id": 10, "label": "old-a"},
+                    {"id": 11, "label": "old-b"},
+                ],
+            )
+
+        stmt = (
+            update(table)
+            .where(table.c.id == bindparam("target_id"))
+            .values(label=bindparam("new_label"))
+            .returning(table.c.id, table.c.label)
+        )
+        with engine.begin() as conn:
+            result = conn.execute(
+                stmt,
+                [
+                    {"target_id": 10, "new_label": "new-a"},
+                    {"target_id": 11, "new_label": "new-b"},
+                ],
+            )
+            rows = result.all()
+        assert sorted(rows) == [(10, "new-a"), (11, "new-b")]
+
+
+class TestDeleteExecutemanyReturning:
+    def test_multi_row_delete_returns_each_row(self, bulk_table: tuple[Engine, Table]) -> None:
+        engine, table = bulk_table
+        with engine.begin() as conn:
+            conn.execute(
+                insert(table),
+                [
+                    {"id": 20, "label": "x"},
+                    {"id": 21, "label": "y"},
+                ],
+            )
+
+        stmt = (
+            delete(table)
+            .where(table.c.id == bindparam("target_id"))
+            .returning(table.c.id, table.c.label)
+        )
+        with engine.begin() as conn:
+            result = conn.execute(
+                stmt,
+                [{"target_id": 20}, {"target_id": 21}],
+            )
+            rows = result.all()
+        assert sorted(rows) == [(20, "x"), (21, "y")]

tests/test_dialect.py

@@ -86,6 +86,25 @@ def test_update_returning_multifrom_pinned_locally(self) -> None:
         assert DqliteDialect.update_returning_multifrom is True
         assert "update_returning_multifrom" in DqliteDialect.__dict__
 
+    def test_executemany_returning_flags_pinned_locally(self) -> None:
+        # dqlitedbapi's executemany accumulates per-parameter-set
+        # RETURNING rows via _ExecuteManyAccumulator. All three DML kinds
+        # deliver the full row set in one call. Integration-verified in
+        # tests/integration/test_bulk_dml_returning.py.
+        #
+        # INSERT: DefaultDialect exposes this as a memoized property
+        # (derived from ``insert_returning and use_insertmanyvalues``) —
+        # pinning locally ensures upstream drift can't silently flip it.
+        # UPDATE / DELETE: DefaultDialect defaults False, which blocks
+        # SQLAlchemy from issuing executemany RETURNING; pin True to
+        # surface the capability.
+        assert DqliteDialect.insert_executemany_returning is True
+        assert DqliteDialect.update_executemany_returning is True
+        assert DqliteDialect.delete_executemany_returning is True
+        assert "insert_executemany_returning" in DqliteDialect.__dict__
+        assert "update_executemany_returning" in DqliteDialect.__dict__
+        assert "delete_executemany_returning" in DqliteDialect.__dict__
+
     @pytest.mark.parametrize(
         "flag",
         [