Merge "Generalize RETURNING and suppor for MariaDB / SQLite" into main

17 files changed, 439 insertions, 351 deletions

diff --git a/test/dialect/oracle/test_dialect.py b/test/dialect/oracle/test_dialect.py
index 8d74c1f48..eda0fc986 100644
--- a/test/dialect/oracle/test_dialect.py
+++ b/test/dialect/oracle/test_dialect.py
@@ -626,7 +626,7 @@ class CompatFlagsTest(fixtures.TestBase, AssertsCompiledSQL):
         dialect.initialize(Mock())
 
         # oracle 8 / 8i support returning
-        assert dialect.implicit_returning
+        assert dialect.insert_returning
 
         assert not dialect._supports_char_length
         assert not dialect.use_ansi
diff --git a/test/dialect/oracle/test_types.py b/test/dialect/oracle/test_types.py
index 799a5e7b6..23df01a0b 100644
--- a/test/dialect/oracle/test_types.py
+++ b/test/dialect/oracle/test_types.py
@@ -229,7 +229,7 @@ class TypesTest(fixtures.TestBase):
             [(2, "value 2                       ")],
         )
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_int_not_float(self, metadata, connection):
         m = metadata
         t1 = Table("t1", m, Column("foo", Integer))
@@ -243,7 +243,7 @@ class TypesTest(fixtures.TestBase):
         assert x == 5
         assert isinstance(x, int)
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_int_not_float_no_coerce_decimal(self, metadata):
         engine = testing_engine(options=dict(coerce_to_decimal=False))
 
diff --git a/test/engine/test_deprecations.py b/test/engine/test_deprecations.py
index 5b723b871..f7602f98a 100644
--- a/test/engine/test_deprecations.py
+++ b/test/engine/test_deprecations.py
@@ -4,13 +4,8 @@ from unittest.mock import Mock
 import sqlalchemy as tsa
 from sqlalchemy import create_engine
 from sqlalchemy import event
-from sqlalchemy import exc
-from sqlalchemy import insert
-from sqlalchemy import Integer
-from sqlalchemy import MetaData
 from sqlalchemy import pool
 from sqlalchemy import select
-from sqlalchemy import String
 from sqlalchemy import testing
 from sqlalchemy.engine import BindTyping
 from sqlalchemy.engine import reflection
@@ -29,10 +24,7 @@ from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_instance_of
 from sqlalchemy.testing import mock
 from sqlalchemy.testing.assertions import expect_deprecated
-from sqlalchemy.testing.assertions import expect_raises_message
 from sqlalchemy.testing.engines import testing_engine
-from sqlalchemy.testing.schema import Column
-from sqlalchemy.testing.schema import Table
 
 
 def _string_deprecation_expect():
@@ -442,55 +434,11 @@ class ImplicitReturningFlagTest(fixtures.TestBase):
     @testing.combinations(True, False, None, argnames="implicit_returning")
     def test_implicit_returning_engine_parameter(self, implicit_returning):
         if implicit_returning is None:
-            e = engines.testing_engine()
+            engines.testing_engine()
         else:
             with assertions.expect_deprecated(ce_implicit_returning):
-                e = engines.testing_engine(
+                engines.testing_engine(
                     options={"implicit_returning": implicit_returning}
                 )
 
-        if implicit_returning is None:
-            eq_(
-                e.dialect.implicit_returning,
-                testing.db.dialect.implicit_returning,
-            )
-        else:
-            eq_(e.dialect.implicit_returning, implicit_returning)
-
-        t = Table(
-            "t",
-            MetaData(),
-            Column("id", Integer, primary_key=True),
-            Column("data", String(50)),
-        )
-
-        t2 = Table(
-            "t",
-            MetaData(),
-            Column("id", Integer, primary_key=True),
-            Column("data", String(50)),
-            implicit_returning=False,
-        )
-
-        with e.connect() as conn:
-            stmt = insert(t).values(data="data")
-
-            if implicit_returning:
-                if not testing.requires.returning.enabled:
-                    with expect_raises_message(
-                        exc.CompileError, "RETURNING is not supported"
-                    ):
-                        stmt.compile(conn)
-                else:
-                    eq_(stmt.compile(conn).implicit_returning, [t.c.id])
-            elif (
-                implicit_returning is None
-                and testing.db.dialect.implicit_returning
-            ):
-                eq_(stmt.compile(conn).implicit_returning, [t.c.id])
-            else:
-                eq_(stmt.compile(conn).implicit_returning, [])
-
-            # table setting it to False disables it
-            stmt2 = insert(t2).values(data="data")
-            eq_(stmt2.compile(conn).implicit_returning, [])
+            # parameter has no effect
diff --git a/test/orm/test_defaults.py b/test/orm/test_defaults.py
index fc8e455ea..7860f5eb1 100644
--- a/test/orm/test_defaults.py
+++ b/test/orm/test_defaults.py
@@ -278,7 +278,7 @@ class ComputedDefaultsOnUpdateTest(fixtures.MappedTest):
 
         asserter.assert_(
             Conditional(
-                eager and testing.db.dialect.implicit_returning,
+                eager and testing.db.dialect.insert_returning,
                 [
                     Conditional(
                         testing.db.dialect.insert_executemany_returning,
@@ -361,7 +361,7 @@ class ComputedDefaultsOnUpdateTest(fixtures.MappedTest):
             eq_(t1.bar, 5 + 42)
             eq_(t2.bar, 6 + 42)
 
-        if eager and testing.db.dialect.implicit_returning:
+        if eager and testing.db.dialect.update_returning:
             asserter.assert_(
                 CompiledSQL(
                     "UPDATE test SET foo=%(foo)s "
@@ -462,7 +462,7 @@ class IdentityDefaultsOnUpdateTest(fixtures.MappedTest):
 
         asserter.assert_(
             Conditional(
-                testing.db.dialect.implicit_returning,
+                testing.db.dialect.insert_returning,
                 [
                     Conditional(
                         testing.db.dialect.insert_executemany_returning,
diff --git a/test/orm/test_events.py b/test/orm/test_events.py
index be1919614..7e1b29cb1 100644
--- a/test/orm/test_events.py
+++ b/test/orm/test_events.py
@@ -3411,7 +3411,7 @@ class RefreshFlushInReturningTest(fixtures.MappedTest):
         s.add(t1)
         s.flush()
 
-        if testing.requires.returning.enabled:
+        if testing.requires.insert_returning.enabled:
             # ordering is deterministic in this test b.c. the routine
             # appends the "returning" params before the "prefetch"
             # ones.  if there were more than one attribute in each category,
diff --git a/test/orm/test_naturalpks.py b/test/orm/test_naturalpks.py
index 0dc71f8b3..64c033ec4 100644
--- a/test/orm/test_naturalpks.py
+++ b/test/orm/test_naturalpks.py
@@ -157,7 +157,7 @@ class NaturalPKTest(fixtures.MappedTest):
         assert sess.get(User, "jack") is None
         assert sess.get(User, "ed").fullname == "jack"
 
-    @testing.requires.returning
+    @testing.requires.update_returning
     def test_update_to_sql_expr(self):
         users, User = self.tables.users, self.classes.User
 
@@ -169,6 +169,8 @@ class NaturalPKTest(fixtures.MappedTest):
         sess.add(u1)
         sess.flush()
 
+        # note this is the primary key, so you need UPDATE..RETURNING
+        # to catch this
         u1.username = User.username + " jones"
 
         sess.flush()
diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py
index 39223a355..881eee4dd 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -1214,7 +1214,7 @@ class DefaultTest(fixtures.MappedTest):
         session = fixture_session()
         session.add(h1)
 
-        if testing.db.dialect.implicit_returning:
+        if testing.db.dialect.insert_returning:
             self.sql_count_(1, session.flush)
         else:
             self.sql_count_(2, session.flush)
@@ -3502,7 +3502,10 @@ class NoRowInsertedTest(fixtures.TestBase):
     """
 
     __backend__ = True
-    __requires__ = ("returning",)
+
+    # the test manipulates INSERTS to become UPDATES to simulate
+    # "INSERT that returns no row" so both are needed
+    __requires__ = ("insert_returning", "update_returning")
 
     @testing.fixture
     def null_server_default_fixture(self, registry, connection):
diff --git a/test/orm/test_unitofworkv2.py b/test/orm/test_unitofworkv2.py
index 7f4c04652..68099a7a0 100644
--- a/test/orm/test_unitofworkv2.py
+++ b/test/orm/test_unitofworkv2.py
@@ -2409,7 +2409,7 @@ class EagerDefaultsTest(fixtures.MappedTest):
 
         s.add_all([t1, t2])
 
-        if testing.db.dialect.implicit_returning:
+        if testing.db.dialect.insert_returning:
             self.assert_sql_execution(
                 testing.db,
                 s.flush,
@@ -2469,7 +2469,7 @@ class EagerDefaultsTest(fixtures.MappedTest):
             testing.db,
             s.commit,
             Conditional(
-                testing.db.dialect.implicit_returning,
+                testing.db.dialect.insert_returning,
                 [
                     Conditional(
                         testing.db.dialect.insert_executemany_returning,
@@ -2541,7 +2541,7 @@ class EagerDefaultsTest(fixtures.MappedTest):
             testing.db,
             s.flush,
             Conditional(
-                testing.db.dialect.implicit_returning,
+                testing.db.dialect.update_returning,
                 [
                     CompiledSQL(
                         "UPDATE test2 SET foo=%(foo)s "
@@ -2633,7 +2633,7 @@ class EagerDefaultsTest(fixtures.MappedTest):
         t4.foo = 8
         t4.bar = text("5 + 7")
 
-        if testing.db.dialect.implicit_returning:
+        if testing.db.dialect.update_returning:
             self.assert_sql_execution(
                 testing.db,
                 s.flush,
@@ -3211,7 +3211,7 @@ class EnsureCacheTest(UOWTest):
 
 class ORMOnlyPrimaryKeyTest(fixtures.TestBase):
     @testing.requires.identity_columns
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_a(self, base, run_test):
         class A(base):
             __tablename__ = "a"
@@ -3224,7 +3224,7 @@ class ORMOnlyPrimaryKeyTest(fixtures.TestBase):
         run_test(A, A())
 
     @testing.requires.sequences_as_server_defaults
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_b(self, base, run_test):
 
         seq = Sequence("x_seq")
diff --git a/test/orm/test_update_delete.py b/test/orm/test_update_delete.py
index 427e49e5e..22d827be9 100644
--- a/test/orm/test_update_delete.py
+++ b/test/orm/test_update_delete.py
@@ -9,6 +9,7 @@ from sqlalchemy import func
 from sqlalchemy import insert
 from sqlalchemy import Integer
 from sqlalchemy import lambda_stmt
+from sqlalchemy import MetaData
 from sqlalchemy import or_
 from sqlalchemy import select
 from sqlalchemy import String
@@ -56,6 +57,19 @@ class UpdateDeleteTest(fixtures.MappedTest):
             Column("user_id", ForeignKey("users.id")),
         )
 
+        m = MetaData()
+        users_no_returning = Table(
+            "users",
+            m,
+            Column(
+                "id", Integer, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("name", String(32)),
+            Column("age_int", Integer),
+            implicit_returning=False,
+        )
+        cls.tables.users_no_returning = users_no_returning
+
     @classmethod
     def setup_classes(cls):
         class User(cls.Comparable):
@@ -64,6 +78,9 @@ class UpdateDeleteTest(fixtures.MappedTest):
         class Address(cls.Comparable):
             pass
 
+        class UserNoReturning(cls.Comparable):
+            pass
+
     @classmethod
     def insert_data(cls, connection):
         users = cls.tables.users
@@ -96,6 +113,16 @@ class UpdateDeleteTest(fixtures.MappedTest):
         )
         cls.mapper_registry.map_imperatively(Address, addresses)
 
+        UserNoReturning = cls.classes.UserNoReturning
+        users_no_returning = cls.tables.users_no_returning
+        cls.mapper_registry.map_imperatively(
+            UserNoReturning,
+            users_no_returning,
+            properties={
+                "age": users_no_returning.c.age_int,
+            },
+        )
+
     @testing.combinations("table", "mapper", "both", argnames="bind_type")
     @testing.combinations(
         "update", "insert", "delete", argnames="statement_type"
@@ -445,7 +472,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
                 {"age": User.age + 10}, synchronize_session="fetch"
             )
 
-        if testing.db.dialect.full_returning:
+        if testing.db.dialect.update_returning:
             asserter.assert_(
                 CompiledSQL(
                     "UPDATE users SET age_int=(users.age_int + %(age_int_1)s) "
@@ -857,8 +884,12 @@ class UpdateDeleteTest(fixtures.MappedTest):
             list(zip([25, 37, 29, 27])),
         )
 
-    def test_update_fetch_returning(self):
-        User = self.classes.User
+    @testing.combinations(True, False, argnames="implicit_returning")
+    def test_update_fetch_returning(self, implicit_returning):
+        if implicit_returning:
+            User = self.classes.User
+        else:
+            User = self.classes.UserNoReturning
 
         sess = fixture_session()
 
@@ -873,7 +904,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
             # the "fetch" strategy, new in 1.4, so there is no expiry
             eq_([john.age, jack.age, jill.age, jane.age], [25, 37, 29, 27])
 
-        if testing.db.dialect.full_returning:
+        if implicit_returning and testing.db.dialect.update_returning:
             asserter.assert_(
                 CompiledSQL(
                     "UPDATE users SET age_int=(users.age_int - %(age_int_1)s) "
@@ -919,7 +950,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
             # the "fetch" strategy, new in 1.4, so there is no expiry
             eq_([john.age, jack.age, jill.age, jane.age], [25, 37, 29, 27])
 
-        if testing.db.dialect.full_returning:
+        if testing.db.dialect.update_returning:
             asserter.assert_(
                 CompiledSQL(
                     "UPDATE users SET age_int=(users.age_int - %(age_int_1)s) "
@@ -942,7 +973,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
                 ),
             )
 
-    @testing.requires.full_returning
+    @testing.requires.update_returning
     def test_update_explicit_returning(self):
         User = self.classes.User
 
@@ -974,7 +1005,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
             ),
         )
 
-    @testing.requires.full_returning
+    @testing.requires.update_returning
     def test_no_fetch_w_explicit_returning(self):
         User = self.classes.User
 
@@ -994,8 +1025,12 @@ class UpdateDeleteTest(fixtures.MappedTest):
         ):
             sess.execute(stmt)
 
-    def test_delete_fetch_returning(self):
-        User = self.classes.User
+    @testing.combinations(True, False, argnames="implicit_returning")
+    def test_delete_fetch_returning(self, implicit_returning):
+        if implicit_returning:
+            User = self.classes.User
+        else:
+            User = self.classes.UserNoReturning
 
         sess = fixture_session()
 
@@ -1009,7 +1044,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
                 synchronize_session="fetch"
             )
 
-        if testing.db.dialect.full_returning:
+        if implicit_returning and testing.db.dialect.delete_returning:
             asserter.assert_(
                 CompiledSQL(
                     "DELETE FROM users WHERE users.age_int > %(age_int_1)s "
@@ -1054,7 +1089,7 @@ class UpdateDeleteTest(fixtures.MappedTest):
                 stmt, execution_options={"synchronize_session": "fetch"}
             )
 
-        if testing.db.dialect.full_returning:
+        if testing.db.dialect.delete_returning:
             asserter.assert_(
                 CompiledSQL(
                     "DELETE FROM users WHERE users.age_int > %(age_int_1)s "
@@ -2148,7 +2183,7 @@ class SingleTablePolymorphicTest(fixtures.DeclarativeMappedTest):
 
 class LoadFromReturningTest(fixtures.MappedTest):
     __backend__ = True
-    __requires__ = ("full_returning",)
+    __requires__ = ("insert_returning",)
 
     @classmethod
     def define_tables(cls, metadata):
@@ -2197,6 +2232,7 @@ class LoadFromReturningTest(fixtures.MappedTest):
             },
         )
 
+    @testing.requires.update_returning
     def test_load_from_update(self, connection):
         User = self.classes.User
 
diff --git a/test/orm/test_versioning.py b/test/orm/test_versioning.py
index 4898cb122..abd5833be 100644
--- a/test/orm/test_versioning.py
+++ b/test/orm/test_versioning.py
@@ -1347,6 +1347,7 @@ class InheritanceTwoVersionIdsTest(fixtures.MappedTest):
 
 class ServerVersioningTest(fixtures.MappedTest):
     run_define_tables = "each"
+
     __backend__ = True
 
     @classmethod
@@ -1432,7 +1433,7 @@ class ServerVersioningTest(fixtures.MappedTest):
                 lambda ctx: [{"value": "f1"}],
             )
         ]
-        if not testing.db.dialect.implicit_returning:
+        if not testing.db.dialect.insert_returning:
             # DBs without implicit returning, we must immediately
             # SELECT for the new version id
             statements.append(
@@ -1460,34 +1461,46 @@ class ServerVersioningTest(fixtures.MappedTest):
 
         f1.value = "f2"
 
-        statements = [
-            # note that the assertsql tests the rule against
-            # "default" - on a "returning" backend, the statement
-            # includes "RETURNING"
-            CompiledSQL(
-                "UPDATE version_table SET version_id=2, value=:value "
-                "WHERE version_table.id = :version_table_id AND "
-                "version_table.version_id = :version_table_version_id",
-                lambda ctx: [
-                    {
-                        "version_table_id": 1,
-                        "version_table_version_id": 1,
-                        "value": "f2",
-                    }
-                ],
-            )
-        ]
-        if not testing.db.dialect.implicit_returning:
+        if testing.db.dialect.update_returning:
+            statements = [
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id "
+                    "RETURNING version_table.version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 1,
+                            "version_table_version_id": 1,
+                            "value": "f2",
+                        }
+                    ],
+                    enable_returning=True,
+                )
+            ]
+        else:
             # DBs without implicit returning, we must immediately
             # SELECT for the new version id
-            statements.append(
+            statements = [
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 1,
+                            "version_table_version_id": 1,
+                            "value": "f2",
+                        }
+                    ],
+                ),
                 CompiledSQL(
                     "SELECT version_table.version_id "
                     "AS version_table_version_id "
                     "FROM version_table WHERE version_table.id = :pk_1",
                     lambda ctx: [{"pk_1": 1}],
-                )
-            )
+                ),
+            ]
         with conditional_sane_rowcount_warnings(
             update=True, only_returning=True
         ):
@@ -1512,8 +1525,9 @@ class ServerVersioningTest(fixtures.MappedTest):
 
         eq_(f1.version_id, 2)
 
+    @testing.requires.sane_rowcount_w_returning
     @testing.requires.updateable_autoincrement_pks
-    @testing.requires.returning
+    @testing.requires.update_returning
     def test_sql_expr_w_mods_bump(self):
         sess = self._fixture()
 
@@ -1544,72 +1558,111 @@ class ServerVersioningTest(fixtures.MappedTest):
         f2.value = "f2a"
         f3.value = "f3a"
 
-        statements = [
-            # note that the assertsql tests the rule against
-            # "default" - on a "returning" backend, the statement
-            # includes "RETURNING"
-            CompiledSQL(
-                "UPDATE version_table SET version_id=2, value=:value "
-                "WHERE version_table.id = :version_table_id AND "
-                "version_table.version_id = :version_table_version_id",
-                lambda ctx: [
-                    {
-                        "version_table_id": 1,
-                        "version_table_version_id": 1,
-                        "value": "f1a",
-                    }
-                ],
-            ),
-            CompiledSQL(
-                "UPDATE version_table SET version_id=2, value=:value "
-                "WHERE version_table.id = :version_table_id AND "
-                "version_table.version_id = :version_table_version_id",
-                lambda ctx: [
-                    {
-                        "version_table_id": 2,
-                        "version_table_version_id": 1,
-                        "value": "f2a",
-                    }
-                ],
-            ),
-            CompiledSQL(
-                "UPDATE version_table SET version_id=2, value=:value "
-                "WHERE version_table.id = :version_table_id AND "
-                "version_table.version_id = :version_table_version_id",
-                lambda ctx: [
-                    {
-                        "version_table_id": 3,
-                        "version_table_version_id": 1,
-                        "value": "f3a",
-                    }
-                ],
-            ),
-        ]
-        if not testing.db.dialect.implicit_returning:
-            # DBs without implicit returning, we must immediately
+        if testing.db.dialect.update_returning:
+            statements = [
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id "
+                    "RETURNING version_table.version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 1,
+                            "version_table_version_id": 1,
+                            "value": "f1a",
+                        }
+                    ],
+                    enable_returning=True,
+                ),
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id "
+                    "RETURNING version_table.version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 2,
+                            "version_table_version_id": 1,
+                            "value": "f2a",
+                        }
+                    ],
+                    enable_returning=True,
+                ),
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id "
+                    "RETURNING version_table.version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 3,
+                            "version_table_version_id": 1,
+                            "value": "f3a",
+                        }
+                    ],
+                    enable_returning=True,
+                ),
+            ]
+        else:
+            # DBs without update returning, we must immediately
             # SELECT for the new version id
-            statements.extend(
-                [
-                    CompiledSQL(
-                        "SELECT version_table.version_id "
-                        "AS version_table_version_id "
-                        "FROM version_table WHERE version_table.id = :pk_1",
-                        lambda ctx: [{"pk_1": 1}],
-                    ),
-                    CompiledSQL(
-                        "SELECT version_table.version_id "
-                        "AS version_table_version_id "
-                        "FROM version_table WHERE version_table.id = :pk_1",
-                        lambda ctx: [{"pk_1": 2}],
-                    ),
-                    CompiledSQL(
-                        "SELECT version_table.version_id "
-                        "AS version_table_version_id "
-                        "FROM version_table WHERE version_table.id = :pk_1",
-                        lambda ctx: [{"pk_1": 3}],
-                    ),
-                ]
-            )
+            statements = [
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 1,
+                            "version_table_version_id": 1,
+                            "value": "f1a",
+                        }
+                    ],
+                ),
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 2,
+                            "version_table_version_id": 1,
+                            "value": "f2a",
+                        }
+                    ],
+                ),
+                CompiledSQL(
+                    "UPDATE version_table SET version_id=2, value=:value "
+                    "WHERE version_table.id = :version_table_id AND "
+                    "version_table.version_id = :version_table_version_id",
+                    lambda ctx: [
+                        {
+                            "version_table_id": 3,
+                            "version_table_version_id": 1,
+                            "value": "f3a",
+                        }
+                    ],
+                ),
+                CompiledSQL(
+                    "SELECT version_table.version_id "
+                    "AS version_table_version_id "
+                    "FROM version_table WHERE version_table.id = :pk_1",
+                    lambda ctx: [{"pk_1": 1}],
+                ),
+                CompiledSQL(
+                    "SELECT version_table.version_id "
+                    "AS version_table_version_id "
+                    "FROM version_table WHERE version_table.id = :pk_1",
+                    lambda ctx: [{"pk_1": 2}],
+                ),
+                CompiledSQL(
+                    "SELECT version_table.version_id "
+                    "AS version_table_version_id "
+                    "FROM version_table WHERE version_table.id = :pk_1",
+                    lambda ctx: [{"pk_1": 3}],
+                ),
+            ]
+
         with conditional_sane_rowcount_warnings(
             update=True, only_returning=True
         ):
@@ -1638,6 +1691,7 @@ class ServerVersioningTest(fixtures.MappedTest):
         with conditional_sane_rowcount_warnings(delete=True):
             self.assert_sql_execution(testing.db, sess.flush, *statements)
 
+    @testing.requires.independent_connections
     @testing.requires.sane_rowcount_w_returning
     def test_concurrent_mod_err_expire_on_commit(self):
         sess = self._fixture()
@@ -1662,6 +1716,7 @@ class ServerVersioningTest(fixtures.MappedTest):
             sess.commit,
         )
 
+    @testing.requires.independent_connections
     @testing.requires.sane_rowcount_w_returning
     def test_concurrent_mod_err_noexpire_on_commit(self):
         sess = self._fixture(expire_on_commit=False)
diff --git a/test/requirements.py b/test/requirements.py
index f5cbbbf8d..6870fba2f 100644
--- a/test/requirements.py
+++ b/test/requirements.py
@@ -416,7 +416,7 @@ class DefaultRequirements(SuiteRequirements):
 
     @property
     def sql_expressions_inserted_as_primary_key(self):
-        return only_if([self.returning, self.sqlite])
+        return only_if([self.insert_returning, self.sqlite])
 
     @property
     def computed_columns_on_update_returning(self):
diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py
index 0fa51e04c..08911a6c5 100644
--- a/test/sql/test_defaults.py
+++ b/test/sql/test_defaults.py
@@ -870,7 +870,7 @@ class DefaultRoundTripTest(fixtures.TablesTest):
 
 
 class CTEDefaultTest(fixtures.TablesTest):
-    __requires__ = ("ctes", "returning", "ctes_on_dml")
+    __requires__ = ("ctes", "insert_returning", "ctes_on_dml")
     __backend__ = True
 
     @classmethod
@@ -993,8 +993,11 @@ class PKDefaultTest(fixtures.TestBase):
 
         return go
 
+    @testing.crashes(
+        "+mariadbconnector", "https://jira.mariadb.org/browse/CONPY-206"
+    )
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -1278,7 +1281,7 @@ class SpecialTypePKTest(fixtures.TestBase):
 
             # we don't pre-fetch 'server_default'.
             if "server_default" in kw and (
-                not testing.db.dialect.implicit_returning
+                not testing.db.dialect.insert_returning
                 or not implicit_returning
             ):
                 eq_(r.inserted_primary_key, (None,))
@@ -1321,15 +1324,18 @@ class SpecialTypePKTest(fixtures.TestBase):
     def test_server_default_no_autoincrement(self):
         self._run_test(server_default="1", autoincrement=False)
 
+    @testing.crashes(
+        "+mariadbconnector", "https://jira.mariadb.org/browse/CONPY-206"
+    )
     def test_clause(self):
         stmt = select(cast("INT_1", type_=self.MyInteger)).scalar_subquery()
         self._run_test(default=stmt)
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_no_implicit_returning(self):
         self._run_test(implicit_returning=False)
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_server_default_no_implicit_returning(self):
         self._run_test(server_default="1", autoincrement=False)
 
@@ -1363,7 +1369,7 @@ class ServerDefaultsOnPKTest(fixtures.TestBase):
         eq_(r.inserted_primary_key, (None,))
         eq_(list(connection.execute(t.select())), [("key_one", "data")])
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     @testing.provide_metadata
     def test_string_default_on_insert_with_returning(self, connection):
         """With implicit_returning, we get a string PK default back no
@@ -1441,8 +1447,9 @@ class ServerDefaultsOnPKTest(fixtures.TestBase):
         else:
             eq_(list(connection.execute(t2.select())), [(5, "data")])
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     @testing.provide_metadata
+    @testing.fails_on("sqlite", "sqlite doesn't like our default trick here")
     def test_int_default_on_insert_with_returning(self, connection):
         metadata = self.metadata
         t = Table(
diff --git a/test/sql/test_insert.py b/test/sql/test_insert.py
index 3a6217f67..808b047a2 100644
--- a/test/sql/test_insert.py
+++ b/test/sql/test_insert.py
@@ -332,10 +332,10 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL):
         table1 = self.tables.mytable
 
         stmt = table1.insert().returning(table1.c.myid)
-        assert_raises_message(
-            exc.CompileError,
-            "RETURNING is not supported by this dialect's statement compiler.",
-            stmt.compile,
+        self.assert_compile(
+            stmt,
+            "INSERT INTO mytable (myid, name, description) "
+            "VALUES (:myid, :name, :description) RETURNING mytable.myid",
             dialect=default.DefaultDialect(),
         )
 
@@ -1028,7 +1028,7 @@ class InsertImplicitReturningTest(
             Column("q", Integer),
         )
 
-        dialect = postgresql.dialect(implicit_returning=True)
+        dialect = postgresql.dialect()
         dialect.insert_null_pk_still_autoincrements = (
             insert_null_still_autoincrements
         )
diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py
index 45f4098b2..3e51e9450 100644
--- a/test/sql/test_insert_exec.py
+++ b/test/sql/test_insert_exec.py
@@ -100,8 +100,9 @@ class InsertExecTest(fixtures.TablesTest):
 
             # verify implicit_returning is working
             if (
-                connection.dialect.implicit_returning
+                connection.dialect.insert_returning
                 and table_.implicit_returning
+                and not connection.dialect.postfetch_lastrowid
             ):
                 ins = table_.insert()
                 comp = ins.compile(connection, column_keys=list(values))
@@ -146,7 +147,7 @@ class InsertExecTest(fixtures.TablesTest):
 
     @testing.requires.supports_autoincrement_w_composite_pk
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -173,7 +174,7 @@ class InsertExecTest(fixtures.TablesTest):
 
     @testing.requires.supports_autoincrement_w_composite_pk
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -200,7 +201,7 @@ class InsertExecTest(fixtures.TablesTest):
         )
 
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -223,7 +224,7 @@ class InsertExecTest(fixtures.TablesTest):
 
     @testing.requires.sequences
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -251,7 +252,7 @@ class InsertExecTest(fixtures.TablesTest):
 
     @testing.requires.sequences
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -277,7 +278,7 @@ class InsertExecTest(fixtures.TablesTest):
         )
 
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -299,7 +300,7 @@ class InsertExecTest(fixtures.TablesTest):
 
     @testing.requires.supports_autoincrement_w_composite_pk
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -338,6 +339,7 @@ class InsertExecTest(fixtures.TablesTest):
             self.metadata,
             Column("x", Integer, primary_key=True),
             Column("y", Integer),
+            implicit_returning=False,
         )
         t.create(connection)
         with mock.patch.object(
@@ -403,12 +405,16 @@ class InsertExecTest(fixtures.TablesTest):
         eq_(r.inserted_primary_key, (None,))
 
     @testing.requires.empty_inserts
-    @testing.requires.returning
-    def test_no_inserted_pk_on_returning(self, connection):
+    @testing.requires.insert_returning
+    def test_no_inserted_pk_on_returning(
+        self, connection, close_result_when_finished
+    ):
         users = self.tables.users
         result = connection.execute(
             users.insert().returning(users.c.user_id, users.c.user_name)
         )
+        close_result_when_finished(result)
+
         assert_raises_message(
             exc.InvalidRequestError,
             r"Can't call inserted_primary_key when returning\(\) is used.",
@@ -566,7 +572,7 @@ class TableInsertTest(fixtures.TablesTest):
             inserted_primary_key=(1,),
         )
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_uppercase_direct_params_returning(self, connection):
         t = self.tables.foo
         self._test(
@@ -599,7 +605,7 @@ class TableInsertTest(fixtures.TablesTest):
             inserted_primary_key=(),
         )
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_direct_params_returning(self, connection):
         t = self._fixture()
         self._test(
diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py
index bacdbaf3f..c458e3262 100644
--- a/test/sql/test_returning.py
+++ b/test/sql/test_returning.py
@@ -199,8 +199,8 @@ class ReturnCombinationTests(fixtures.TestBase, AssertsCompiledSQL):
         )
 
 
-class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
-    __requires__ = ("returning",)
+class InsertReturningTest(fixtures.TablesTest, AssertsExecutionResults):
+    __requires__ = ("insert_returning",)
     __backend__ = True
 
     run_create_tables = "each"
@@ -286,26 +286,6 @@ class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
         row = result.first()
         eq_(row[0], 30)
 
-    def test_update_returning(self, connection):
-        table = self.tables.tables
-        connection.execute(
-            table.insert(),
-            [{"persons": 5, "full": False}, {"persons": 3, "full": False}],
-        )
-
-        result = connection.execute(
-            table.update()
-            .values(dict(full=True))
-            .where(table.c.persons > 4)
-            .returning(table.c.id)
-        )
-        eq_(result.fetchall(), [(1,)])
-
-        result2 = connection.execute(
-            select(table.c.id, table.c.full).order_by(table.c.id)
-        )
-        eq_(result2.fetchall(), [(1, True), (2, False)])
-
     @testing.fails_on(
         "mssql",
         "driver has unknown issue with string concatenation "
@@ -339,6 +319,94 @@ class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
         )
         eq_(result2.fetchall(), [(1, "FOOsomegoofyBAR")])
 
+    def test_no_ipk_on_returning(self, connection, close_result_when_finished):
+        table = self.tables.tables
+        result = connection.execute(
+            table.insert().returning(table.c.id), {"persons": 1, "full": False}
+        )
+        close_result_when_finished(result)
+        assert_raises_message(
+            sa_exc.InvalidRequestError,
+            r"Can't call inserted_primary_key when returning\(\) is used.",
+            getattr,
+            result,
+            "inserted_primary_key",
+        )
+
+    def test_insert_returning(self, connection):
+        table = self.tables.tables
+        result = connection.execute(
+            table.insert().returning(table.c.id), {"persons": 1, "full": False}
+        )
+
+        eq_(result.fetchall(), [(1,)])
+
+    @testing.requires.multivalues_inserts
+    def test_multirow_returning(self, connection):
+        table = self.tables.tables
+        ins = (
+            table.insert()
+            .returning(table.c.id, table.c.persons)
+            .values(
+                [
+                    {"persons": 1, "full": False},
+                    {"persons": 2, "full": True},
+                    {"persons": 3, "full": False},
+                ]
+            )
+        )
+        result = connection.execute(ins)
+        eq_(result.fetchall(), [(1, 1), (2, 2), (3, 3)])
+
+    @testing.fails_on_everything_except(
+        "postgresql", "mariadb>=10.5", "sqlite>=3.34"
+    )
+    def test_literal_returning(self, connection):
+        if testing.against("mariadb"):
+            quote = "`"
+        else:
+            quote = '"'
+        if testing.against("postgresql"):
+            literal_true = "true"
+        else:
+            literal_true = "1"
+
+        result4 = connection.exec_driver_sql(
+            "insert into tables (id, persons, %sfull%s) "
+            "values (5, 10, %s) returning persons"
+            % (quote, quote, literal_true)
+        )
+        eq_([dict(row._mapping) for row in result4], [{"persons": 10}])
+
+
+class UpdateReturningTest(fixtures.TablesTest, AssertsExecutionResults):
+    __requires__ = ("update_returning",)
+    __backend__ = True
+
+    run_create_tables = "each"
+
+    define_tables = InsertReturningTest.define_tables
+
+    def test_update_returning(self, connection):
+        table = self.tables.tables
+        connection.execute(
+            table.insert(),
+            [{"persons": 5, "full": False}, {"persons": 3, "full": False}],
+        )
+
+        result = connection.execute(
+            table.update()
+            .values(dict(full=True))
+            .where(table.c.persons > 4)
+            .returning(table.c.id)
+        )
+        eq_(result.fetchall(), [(1,)])
+
+        result2 = connection.execute(
+            select(table.c.id, table.c.full).order_by(table.c.id)
+        )
+        eq_(result2.fetchall(), [(1, True), (2, False)])
+
     def test_update_returning_w_expression_one(self, connection):
         table = self.tables.tables
         connection.execute(
@@ -388,7 +456,6 @@ class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
             [(1, "FOOnewgoofyBAR"), (2, "FOOsomegoofy2BAR")],
         )
 
-    @testing.requires.full_returning
     def test_update_full_returning(self, connection):
         table = self.tables.tables
         connection.execute(
@@ -404,69 +471,14 @@ class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
         )
         eq_(result.fetchall(), [(1, True), (2, True)])
 
-    @testing.requires.full_returning
-    def test_delete_full_returning(self, connection):
-        table = self.tables.tables
-        connection.execute(
-            table.insert(),
-            [{"persons": 5, "full": False}, {"persons": 3, "full": False}],
-        )
-
-        result = connection.execute(
-            table.delete().returning(table.c.id, table.c.full)
-        )
-        eq_(result.fetchall(), [(1, False), (2, False)])
-
-    def test_insert_returning(self, connection):
-        table = self.tables.tables
-        result = connection.execute(
-            table.insert().returning(table.c.id), {"persons": 1, "full": False}
-        )
 
-        eq_(result.fetchall(), [(1,)])
-
-    @testing.requires.multivalues_inserts
-    def test_multirow_returning(self, connection):
-        table = self.tables.tables
-        ins = (
-            table.insert()
-            .returning(table.c.id, table.c.persons)
-            .values(
-                [
-                    {"persons": 1, "full": False},
-                    {"persons": 2, "full": True},
-                    {"persons": 3, "full": False},
-                ]
-            )
-        )
-        result = connection.execute(ins)
-        eq_(result.fetchall(), [(1, 1), (2, 2), (3, 3)])
-
-    def test_no_ipk_on_returning(self, connection):
-        table = self.tables.tables
-        result = connection.execute(
-            table.insert().returning(table.c.id), {"persons": 1, "full": False}
-        )
-        assert_raises_message(
-            sa_exc.InvalidRequestError,
-            r"Can't call inserted_primary_key when returning\(\) is used.",
-            getattr,
-            result,
-            "inserted_primary_key",
-        )
+class DeleteReturningTest(fixtures.TablesTest, AssertsExecutionResults):
+    __requires__ = ("delete_returning",)
+    __backend__ = True
 
-    @testing.fails_on_everything_except("postgresql")
-    def test_literal_returning(self, connection):
-        if testing.against("postgresql"):
-            literal_true = "true"
-        else:
-            literal_true = "1"
+    run_create_tables = "each"
 
-        result4 = connection.exec_driver_sql(
-            'insert into tables (id, persons, "full") '
-            "values (5, 10, %s) returning persons" % literal_true
-        )
-        eq_([dict(row._mapping) for row in result4], [{"persons": 10}])
+    define_tables = InsertReturningTest.define_tables
 
     def test_delete_returning(self, connection):
         table = self.tables.tables
@@ -487,7 +499,7 @@ class ReturningTest(fixtures.TablesTest, AssertsExecutionResults):
 
 
 class CompositeStatementTest(fixtures.TestBase):
-    __requires__ = ("returning",)
+    __requires__ = ("insert_returning",)
     __backend__ = True
 
     @testing.provide_metadata
@@ -517,7 +529,7 @@ class CompositeStatementTest(fixtures.TestBase):
 
 
 class SequenceReturningTest(fixtures.TablesTest):
-    __requires__ = "returning", "sequences"
+    __requires__ = "insert_returning", "sequences"
     __backend__ = True
 
     @classmethod
@@ -552,7 +564,7 @@ class KeyReturningTest(fixtures.TablesTest, AssertsExecutionResults):
 
     """test returning() works with columns that define 'key'."""
 
-    __requires__ = ("returning",)
+    __requires__ = ("insert_returning",)
     __backend__ = True
 
     @classmethod
@@ -583,8 +595,8 @@ class KeyReturningTest(fixtures.TablesTest, AssertsExecutionResults):
         assert row[table.c.foo_id] == row["id"] == 1
 
 
-class ReturnDefaultsTest(fixtures.TablesTest):
-    __requires__ = ("returning",)
+class InsertReturnDefaultsTest(fixtures.TablesTest):
+    __requires__ = ("insert_returning",)
     run_define_tables = "each"
     __backend__ = True
 
@@ -639,67 +651,99 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             [1, 0],
         )
 
-    def test_chained_update_pk(self, connection):
+    def test_insert_non_default(self, connection):
+        """test that a column not marked at all as a
+        default works with this feature."""
+
         t1 = self.tables.t1
-        connection.execute(t1.insert().values(upddef=1))
         result = connection.execute(
-            t1.update().values(data="d1").return_defaults(t1.c.upddef)
+            t1.insert().values(upddef=1).return_defaults(t1.c.data)
         )
         eq_(
-            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
+            [
+                result.returned_defaults._mapping[k]
+                for k in (t1.c.id, t1.c.data)
+            ],
+            [1, None],
         )
 
-    def test_arg_update_pk(self, connection):
+    def test_insert_sql_expr(self, connection):
+        from sqlalchemy import literal
+
         t1 = self.tables.t1
-        connection.execute(t1.insert().values(upddef=1))
         result = connection.execute(
-            t1.update().return_defaults(t1.c.upddef).values(data="d1")
+            t1.insert().return_defaults().values(insdef=literal(10) + 5)
         )
+
         eq_(
-            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
+            result.returned_defaults._mapping,
+            {"id": 1, "data": None, "insdef": 15, "upddef": None},
         )
 
-    def test_insert_non_default(self, connection):
-        """test that a column not marked at all as a
-        default works with this feature."""
+    def test_insert_non_default_plus_default(self, connection):
+        t1 = self.tables.t1
+        result = connection.execute(
+            t1.insert()
+            .values(upddef=1)
+            .return_defaults(t1.c.data, t1.c.insdef)
+        )
+        eq_(
+            dict(result.returned_defaults._mapping),
+            {"id": 1, "data": None, "insdef": 0},
+        )
+        eq_(result.inserted_primary_key, (1,))
 
+    def test_insert_all(self, connection):
         t1 = self.tables.t1
         result = connection.execute(
-            t1.insert().values(upddef=1).return_defaults(t1.c.data)
+            t1.insert().values(upddef=1).return_defaults()
         )
         eq_(
-            [
-                result.returned_defaults._mapping[k]
-                for k in (t1.c.id, t1.c.data)
-            ],
-            [1, None],
+            dict(result.returned_defaults._mapping),
+            {"id": 1, "data": None, "insdef": 0},
         )
+        eq_(result.inserted_primary_key, (1,))
 
-    def test_update_non_default(self, connection):
-        """test that a column not marked at all as a
-        default works with this feature."""
 
+class UpdatedReturnDefaultsTest(fixtures.TablesTest):
+    __requires__ = ("update_returning",)
+    run_define_tables = "each"
+    __backend__ = True
+
+    define_tables = InsertReturnDefaultsTest.define_tables
+
+    def test_chained_update_pk(self, connection):
         t1 = self.tables.t1
         connection.execute(t1.insert().values(upddef=1))
         result = connection.execute(
-            t1.update().values(upddef=2).return_defaults(t1.c.data)
+            t1.update().values(data="d1").return_defaults(t1.c.upddef)
         )
         eq_(
-            [result.returned_defaults._mapping[k] for k in (t1.c.data,)],
-            [None],
+            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
         )
 
-    def test_insert_sql_expr(self, connection):
-        from sqlalchemy import literal
-
+    def test_arg_update_pk(self, connection):
         t1 = self.tables.t1
+        connection.execute(t1.insert().values(upddef=1))
         result = connection.execute(
-            t1.insert().return_defaults().values(insdef=literal(10) + 5)
+            t1.update().return_defaults(t1.c.upddef).values(data="d1")
         )
+        eq_(
+            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
+        )
+
+    def test_update_non_default(self, connection):
+        """test that a column not marked at all as a
+        default works with this feature."""
 
+        t1 = self.tables.t1
+        connection.execute(t1.insert().values(upddef=1))
+        result = connection.execute(
+            t1.update().values(upddef=2).return_defaults(t1.c.data)
+        )
         eq_(
-            result.returned_defaults._mapping,
-            {"id": 1, "data": None, "insdef": 15, "upddef": None},
+            [result.returned_defaults._mapping[k] for k in (t1.c.data,)],
+            [None],
         )
 
     def test_update_sql_expr(self, connection):
@@ -713,19 +757,6 @@ class ReturnDefaultsTest(fixtures.TablesTest):
 
         eq_(result.returned_defaults._mapping, {"upddef": 15})
 
-    def test_insert_non_default_plus_default(self, connection):
-        t1 = self.tables.t1
-        result = connection.execute(
-            t1.insert()
-            .values(upddef=1)
-            .return_defaults(t1.c.data, t1.c.insdef)
-        )
-        eq_(
-            dict(result.returned_defaults._mapping),
-            {"id": 1, "data": None, "insdef": 0},
-        )
-        eq_(result.inserted_primary_key, (1,))
-
     def test_update_non_default_plus_default(self, connection):
         t1 = self.tables.t1
         connection.execute(t1.insert().values(upddef=1))
@@ -739,17 +770,6 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             {"data": None, "upddef": 1},
         )
 
-    def test_insert_all(self, connection):
-        t1 = self.tables.t1
-        result = connection.execute(
-            t1.insert().values(upddef=1).return_defaults()
-        )
-        eq_(
-            dict(result.returned_defaults._mapping),
-            {"id": 1, "data": None, "insdef": 0},
-        )
-        eq_(result.inserted_primary_key, (1,))
-
     def test_update_all(self, connection):
         t1 = self.tables.t1
         connection.execute(t1.insert().values(upddef=1))
@@ -758,7 +778,14 @@ class ReturnDefaultsTest(fixtures.TablesTest):
         )
         eq_(dict(result.returned_defaults._mapping), {"upddef": 1})
 
-    @testing.requires.insert_executemany_returning
+
+class InsertManyReturnDefaultsTest(fixtures.TablesTest):
+    __requires__ = ("insert_executemany_returning",)
+    run_define_tables = "each"
+    __backend__ = True
+
+    define_tables = InsertReturnDefaultsTest.define_tables
+
     def test_insert_executemany_no_defaults_passed(self, connection):
         t1 = self.tables.t1
         result = connection.execute(
@@ -802,7 +829,6 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             lambda: result.inserted_primary_key,
         )
 
-    @testing.requires.insert_executemany_returning
     def test_insert_executemany_insdefault_passed(self, connection):
         t1 = self.tables.t1
         result = connection.execute(
@@ -846,7 +872,6 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             lambda: result.inserted_primary_key,
         )
 
-    @testing.requires.insert_executemany_returning
     def test_insert_executemany_only_pk_passed(self, connection):
         t1 = self.tables.t1
         result = connection.execute(
diff --git a/test/sql/test_sequences.py b/test/sql/test_sequences.py
index be74153ce..19f95c661 100644
--- a/test/sql/test_sequences.py
+++ b/test/sql/test_sequences.py
@@ -218,9 +218,15 @@ class SequenceExecTest(fixtures.TestBase):
     @testing.combinations(
         ("implicit_returning",),
         ("no_implicit_returning",),
-        ("explicit_returning", testing.requires.returning),
-        ("return_defaults_no_implicit_returning", testing.requires.returning),
-        ("return_defaults_implicit_returning", testing.requires.returning),
+        ("explicit_returning", testing.requires.insert_returning),
+        (
+            "return_defaults_no_implicit_returning",
+            testing.requires.insert_returning,
+        ),
+        (
+            "return_defaults_implicit_returning",
+            testing.requires.insert_returning,
+        ),
         argnames="returning",
     )
     @testing.requires.multivalues_inserts
@@ -264,17 +270,17 @@ class SequenceExecTest(fixtures.TestBase):
         ("no_implicit_returning",),
         (
             "explicit_returning",
-            testing.requires.returning
+            testing.requires.insert_returning
             + testing.requires.insert_executemany_returning,
         ),
         (
             "return_defaults_no_implicit_returning",
-            testing.requires.returning
+            testing.requires.insert_returning
             + testing.requires.insert_executemany_returning,
         ),
         (
             "return_defaults_implicit_returning",
-            testing.requires.returning
+            testing.requires.insert_returning
             + testing.requires.insert_executemany_returning,
         ),
         argnames="returning",
@@ -318,7 +324,7 @@ class SequenceExecTest(fixtures.TestBase):
             [(1, "d1"), (2, "d2"), (3, "d3")],
         )
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     def test_inserted_pk_implicit_returning(self, connection, metadata):
         """test inserted_primary_key contains the result when
         pk_col=next_value(), when implicit returning is used."""
@@ -435,7 +441,7 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL):
         assert not self._has_sequence(connection, "s1")
         assert not self._has_sequence(connection, "s2")
 
-    @testing.requires.returning
+    @testing.requires.insert_returning
     @testing.requires.supports_sequence_for_autoincrement_column
     @testing.provide_metadata
     def test_freestanding_sequence_via_autoinc(self, connection):
@@ -545,7 +551,7 @@ class TableBoundSequenceTest(fixtures.TablesTest):
         return go
 
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
@@ -571,7 +577,7 @@ class TableBoundSequenceTest(fixtures.TablesTest):
         )
 
     @testing.combinations(
-        (True, testing.requires.returning),
+        (True, testing.requires.insert_returning),
         (False,),
         argnames="implicit_returning",
     )
diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py
index 70c8839e3..901be7132 100644
--- a/test/sql/test_type_expressions.py
+++ b/test/sql/test_type_expressions.py
@@ -496,7 +496,7 @@ class TypeDecRoundTripTest(fixtures.TablesTest, RoundTripTestBase):
 
 
 class ReturningTest(fixtures.TablesTest):
-    __requires__ = ("returning",)
+    __requires__ = ("insert_returning",)
 
     @classmethod
     def define_tables(cls, metadata):