From: Mike Bayer <mike_mp@zzzcomputing.com>
Date: Wed, 6 Jan 2021 15:43:19 +0000 (-0500)
Subject: update execute() arg formats in modules and tests
X-Git-Tag: rel_1_4_0b2~49^2
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=ebbbac0a76b3327a829864afb26ee1b7ff1dc780;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git

update execute() arg formats in modules and tests

continuing with producing a SQLAlchemy 1.4.0b2 that internally
does not emit any of its own 2.0 deprecation warnings,
migrate the *args and **kwargs passed to execute() methods
that now must be a single list or dictionary.

Alembic 1.5 is again waiting on this internal consistency to
be present so that it can pass all tests with no 2.0
deprecation warnings.

Change-Id: If6b792e57c8c5dff205419644ab68e631575a2fa
---

diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py
index 1cc8b7aef0..a496f03543 100644
--- a/lib/sqlalchemy/dialects/oracle/base.py
+++ b/lib/sqlalchemy/dialects/oracle/base.py
@@ -1731,7 +1731,7 @@ class OracleDialect(default.DefaultDialect):
                 sql.text(
                     "SELECT username FROM user_db_links " "WHERE db_link=:link"
                 ),
-                link=dblink,
+                dict(link=dblink),
             )
             dblink = "@" + dblink
         elif not owner:
@@ -1805,7 +1805,7 @@ class OracleDialect(default.DefaultDialect):
                 "SELECT sequence_name FROM all_sequences "
                 "WHERE sequence_owner = :schema_name"
             ),
-            schema_name=self.denormalize_name(schema),
+            dict(schema_name=self.denormalize_name(schema)),
         )
         return [self.normalize_name(row[0]) for row in cursor]
 
diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py
index 735990a20d..7a898cb8ac 100644
--- a/lib/sqlalchemy/dialects/postgresql/base.py
+++ b/lib/sqlalchemy/dialects/postgresql/base.py
@@ -3335,7 +3335,11 @@ class PGDialect(default.DefaultDialect):
                 "WHERE n.nspname = :schema AND c.relkind IN (%s)"
                 % (", ".join("'%s'" % elem for elem in kinds))
             ).columns(relname=sqltypes.Unicode),
-            schema=schema if schema is not None else self.default_schema_name,
+            dict(
+                schema=schema
+                if schema is not None
+                else self.default_schema_name
+            ),
         )
         return [name for name, in result]
 
@@ -3367,8 +3371,12 @@ class PGDialect(default.DefaultDialect):
                 "WHERE n.nspname = :schema AND c.relname = :view_name "
                 "AND c.relkind IN ('v', 'm')"
             ).columns(view_def=sqltypes.Unicode),
-            schema=schema if schema is not None else self.default_schema_name,
-            view_name=view_name,
+            dict(
+                schema=schema
+                if schema is not None
+                else self.default_schema_name,
+                view_name=view_name,
+            ),
         )
         return view_def
 
diff --git a/lib/sqlalchemy/dialects/postgresql/provision.py b/lib/sqlalchemy/dialects/postgresql/provision.py
index 70c3908000..9196337baa 100644
--- a/lib/sqlalchemy/dialects/postgresql/provision.py
+++ b/lib/sqlalchemy/dialects/postgresql/provision.py
@@ -62,7 +62,7 @@ def _pg_drop_db(cfg, eng, ident):
                     "where usename=current_user and pid != pg_backend_pid() "
                     "and datname=:dname"
                 ),
-                dname=ident,
+                dict(dname=ident),
             )
             conn.exec_driver_sql("DROP DATABASE %s" % ident)
 
diff --git a/lib/sqlalchemy/orm/__init__.py b/lib/sqlalchemy/orm/__init__.py
index 2b7ad7bbd3..f6b1a2e93f 100644
--- a/lib/sqlalchemy/orm/__init__.py
+++ b/lib/sqlalchemy/orm/__init__.py
@@ -264,6 +264,7 @@ def clear_mappers():
     upon a fixed set of classes.
 
     """
+
     with mapperlib._CONFIGURE_MUTEX:
         while _mapper_registry:
             try:
diff --git a/lib/sqlalchemy/testing/fixtures.py b/lib/sqlalchemy/testing/fixtures.py
index f19b4652ad..dcdeee5c90 100644
--- a/lib/sqlalchemy/testing/fixtures.py
+++ b/lib/sqlalchemy/testing/fixtures.py
@@ -396,9 +396,7 @@ def stop_test_class_inside_fixtures(cls):
 
 
 def after_test():
-
     if _fixture_sessions:
-
         _close_all_sessions()
 
 
diff --git a/lib/sqlalchemy/testing/suite/test_insert.py b/lib/sqlalchemy/testing/suite/test_insert.py
index da59d831f7..35f3315c72 100644
--- a/lib/sqlalchemy/testing/suite/test_insert.py
+++ b/lib/sqlalchemy/testing/suite/test_insert.py
@@ -51,13 +51,15 @@ class LastrowidTest(fixtures.TablesTest):
 
     def test_autoincrement_on_insert(self, connection):
 
-        connection.execute(self.tables.autoinc_pk.insert(), data="some data")
+        connection.execute(
+            self.tables.autoinc_pk.insert(), dict(data="some data")
+        )
         self._assert_round_trip(self.tables.autoinc_pk, connection)
 
     def test_last_inserted_id(self, connection):
 
         r = connection.execute(
-            self.tables.autoinc_pk.insert(), data="some data"
+            self.tables.autoinc_pk.insert(), dict(data="some data")
         )
         pk = connection.scalar(select(self.tables.autoinc_pk.c.id))
         eq_(r.inserted_primary_key, (pk,))
@@ -65,7 +67,7 @@ class LastrowidTest(fixtures.TablesTest):
     @requirements.dbapi_lastrowid
     def test_native_lastrowid_autoinc(self, connection):
         r = connection.execute(
-            self.tables.autoinc_pk.insert(), data="some data"
+            self.tables.autoinc_pk.insert(), dict(data="some data")
         )
         lastrowid = r.lastrowid
         pk = connection.scalar(select(self.tables.autoinc_pk.c.id))
@@ -116,7 +118,9 @@ class InsertBehaviorTest(fixtures.TablesTest):
             engine = config.db
 
         with engine.begin() as conn:
-            r = conn.execute(self.tables.autoinc_pk.insert(), data="some data")
+            r = conn.execute(
+                self.tables.autoinc_pk.insert(), dict(data="some data")
+            )
         assert r._soft_closed
         assert not r.closed
         assert r.is_insert
@@ -131,7 +135,7 @@ class InsertBehaviorTest(fixtures.TablesTest):
     @requirements.returning
     def test_autoclose_on_insert_implicit_returning(self, connection):
         r = connection.execute(
-            self.tables.autoinc_pk.insert(), data="some data"
+            self.tables.autoinc_pk.insert(), dict(data="some data")
         )
         assert r._soft_closed
         assert not r.closed
@@ -315,7 +319,7 @@ class ReturningTest(fixtures.TablesTest):
     def test_explicit_returning_pk_autocommit(self, connection):
         table = self.tables.autoinc_pk
         r = connection.execute(
-            table.insert().returning(table.c.id), data="some data"
+            table.insert().returning(table.c.id), dict(data="some data")
         )
         pk = r.first()[0]
         fetched_pk = connection.scalar(select(table.c.id))
@@ -324,7 +328,7 @@ class ReturningTest(fixtures.TablesTest):
     def test_explicit_returning_pk_no_autocommit(self, connection):
         table = self.tables.autoinc_pk
         r = connection.execute(
-            table.insert().returning(table.c.id), data="some data"
+            table.insert().returning(table.c.id), dict(data="some data")
         )
         pk = r.first()[0]
         fetched_pk = connection.scalar(select(table.c.id))
@@ -332,13 +336,15 @@ class ReturningTest(fixtures.TablesTest):
 
     def test_autoincrement_on_insert_implicit_returning(self, connection):
 
-        connection.execute(self.tables.autoinc_pk.insert(), data="some data")
+        connection.execute(
+            self.tables.autoinc_pk.insert(), dict(data="some data")
+        )
         self._assert_round_trip(self.tables.autoinc_pk, connection)
 
     def test_last_inserted_id_implicit_returning(self, connection):
 
         r = connection.execute(
-            self.tables.autoinc_pk.insert(), data="some data"
+            self.tables.autoinc_pk.insert(), dict(data="some data")
         )
         pk = connection.scalar(select(self.tables.autoinc_pk.c.id))
         eq_(r.inserted_primary_key, (pk,))
diff --git a/lib/sqlalchemy/testing/suite/test_select.py b/lib/sqlalchemy/testing/suite/test_select.py
index f8d9b3d88c..0d9f08848f 100644
--- a/lib/sqlalchemy/testing/suite/test_select.py
+++ b/lib/sqlalchemy/testing/suite/test_select.py
@@ -742,7 +742,7 @@ class PostCompileParamsTest(
 
         with self.sql_execution_asserter() as asserter:
             with config.db.connect() as conn:
-                conn.execute(stmt, q=10)
+                conn.execute(stmt, dict(q=10))
 
         asserter.assert_(
             CursorSQL(
@@ -761,7 +761,7 @@ class PostCompileParamsTest(
 
         with self.sql_execution_asserter() as asserter:
             with config.db.connect() as conn:
-                conn.execute(stmt, q=[5, 6, 7])
+                conn.execute(stmt, dict(q=[5, 6, 7]))
 
         asserter.assert_(
             CursorSQL(
@@ -783,7 +783,7 @@ class PostCompileParamsTest(
 
         with self.sql_execution_asserter() as asserter:
             with config.db.connect() as conn:
-                conn.execute(stmt, q=[(5, 10), (12, 18)])
+                conn.execute(stmt, dict(q=[(5, 10), (12, 18)]))
 
         asserter.assert_(
             CursorSQL(
@@ -807,7 +807,7 @@ class PostCompileParamsTest(
 
         with self.sql_execution_asserter() as asserter:
             with config.db.connect() as conn:
-                conn.execute(stmt, q=[(5, "z1"), (12, "z3")])
+                conn.execute(stmt, dict(q=[(5, "z1"), (12, "z3")]))
 
         asserter.assert_(
             CursorSQL(
diff --git a/lib/sqlalchemy/testing/suite/test_sequence.py b/lib/sqlalchemy/testing/suite/test_sequence.py
index d8c35ed0b6..7445ade00c 100644
--- a/lib/sqlalchemy/testing/suite/test_sequence.py
+++ b/lib/sqlalchemy/testing/suite/test_sequence.py
@@ -46,11 +46,13 @@ class SequenceTest(fixtures.TablesTest):
         )
 
     def test_insert_roundtrip(self, connection):
-        connection.execute(self.tables.seq_pk.insert(), data="some data")
+        connection.execute(self.tables.seq_pk.insert(), dict(data="some data"))
         self._assert_round_trip(self.tables.seq_pk, connection)
 
     def test_insert_lastrowid(self, connection):
-        r = connection.execute(self.tables.seq_pk.insert(), data="some data")
+        r = connection.execute(
+            self.tables.seq_pk.insert(), dict(data="some data")
+        )
         eq_(
             r.inserted_primary_key, (testing.db.dialect.default_sequence_base,)
         )
@@ -62,7 +64,7 @@ class SequenceTest(fixtures.TablesTest):
     @requirements.sequences_optional
     def test_optional_seq(self, connection):
         r = connection.execute(
-            self.tables.seq_opt_pk.insert(), data="some data"
+            self.tables.seq_opt_pk.insert(), dict(data="some data")
         )
         eq_(r.inserted_primary_key, (1,))
 
diff --git a/lib/sqlalchemy/testing/suite/test_update_delete.py b/lib/sqlalchemy/testing/suite/test_update_delete.py
index f7e6da98e1..3fb51ead3d 100644
--- a/lib/sqlalchemy/testing/suite/test_update_delete.py
+++ b/lib/sqlalchemy/testing/suite/test_update_delete.py
@@ -32,7 +32,9 @@ class SimpleUpdateDeleteTest(fixtures.TablesTest):
 
     def test_update(self, connection):
         t = self.tables.plain_pk
-        r = connection.execute(t.update().where(t.c.id == 2), data="d2_new")
+        r = connection.execute(
+            t.update().where(t.c.id == 2), dict(data="d2_new")
+        )
         assert not r.is_insert
         assert not r.returns_rows
 
diff --git a/lib/sqlalchemy/testing/warnings.py b/lib/sqlalchemy/testing/warnings.py
index 1b078a2634..5699cd035d 100644
--- a/lib/sqlalchemy/testing/warnings.py
+++ b/lib/sqlalchemy/testing/warnings.py
@@ -56,9 +56,6 @@ def setup_filters():
         # Core execution
         #
         r"The (?:Executable|Engine)\.(?:execute|scalar)\(\) method",
-        r"The connection.execute\(\) method in SQLAlchemy 2.0 will accept "
-        "parameters as a single dictionary or a single sequence of "
-        "dictionaries only.",
         r"The Connection.connect\(\) method is considered legacy",
         #        r".*DefaultGenerator.execute\(\)",
         #
diff --git a/test/dialect/mssql/test_query.py b/test/dialect/mssql/test_query.py
index b806b9247f..d3b2e06441 100644
--- a/test/dialect/mssql/test_query.py
+++ b/test/dialect/mssql/test_query.py
@@ -91,7 +91,7 @@ class IdentityInsertTest(fixtures.TablesTest, AssertsCompiledSQL):
     def test_insert_plain_param(self, connection):
         conn = connection
         cattable = self.tables.cattable
-        conn.execute(cattable.insert(), id=5)
+        conn.execute(cattable.insert(), dict(id=5))
         eq_(conn.scalar(select(cattable.c.id)), 5)
 
     def test_insert_values_key_plain(self, connection):
@@ -156,8 +156,7 @@ class QueryTest(testing.AssertsExecutionResults, fixtures.TestBase):
     __only_on__ = "mssql"
     __backend__ = True
 
-    @testing.provide_metadata
-    def test_fetchid_trigger(self, connection):
+    def test_fetchid_trigger(self, metadata, connection):
         # TODO: investigate test hang on mssql when connection fixture is used
         """
         Verify identity return value on inserting to a trigger table.
@@ -190,7 +189,7 @@ class QueryTest(testing.AssertsExecutionResults, fixtures.TestBase):
         # TODO: check whether this error also occurs with clients other
         #      than the SQL Server Native Client. Maybe an assert_raises
         #      test should be written.
-        meta = self.metadata
+        meta = metadata
         t1 = Table(
             "t1",
             meta,
@@ -230,9 +229,9 @@ class QueryTest(testing.AssertsExecutionResults, fixtures.TestBase):
         # seems to work with all linux drivers + backend.  not sure
         # if windows drivers / servers have different behavior here.
         meta.create_all(connection)
-        r = connection.execute(t2.insert(), descr="hello")
+        r = connection.execute(t2.insert(), dict(descr="hello"))
         eq_(r.inserted_primary_key, (200,))
-        r = connection.execute(t1.insert(), descr="hello")
+        r = connection.execute(t1.insert(), dict(descr="hello"))
         eq_(r.inserted_primary_key, (100,))
 
     @testing.provide_metadata
diff --git a/test/dialect/mssql/test_types.py b/test/dialect/mssql/test_types.py
index c2231d105b..439828fe4d 100644
--- a/test/dialect/mssql/test_types.py
+++ b/test/dialect/mssql/test_types.py
@@ -770,7 +770,7 @@ class TypeRoundTripTest(
     def test_date_roundtrips(self, date_fixture, connection):
         t, (d1, t1, d2) = date_fixture
         connection.execute(
-            t.insert(), adate=d1, adatetime=d2, atime1=t1, atime2=d2
+            t.insert(), dict(adate=d1, adatetime=d2, atime1=t1, atime2=d2)
         )
 
         row = connection.execute(t.select()).first()
@@ -876,13 +876,13 @@ class TypeRoundTripTest(
                 sa.exc.DBAPIError,
                 connection.execute,
                 t.insert(),
-                adatetimeoffset=dto_param_value,
+                dict(adatetimeoffset=dto_param_value),
             )
             return
 
         connection.execute(
             t.insert(),
-            adatetimeoffset=dto_param_value,
+            dict(adatetimeoffset=dto_param_value),
         )
 
         row = connection.execute(t.select()).first()
@@ -1248,7 +1248,7 @@ class BinaryTest(fixtures.TestBase):
                 expected = data
 
         with engine.begin() as conn:
-            conn.execute(binary_table.insert(), data=data)
+            conn.execute(binary_table.insert(), dict(data=data))
 
             eq_(conn.scalar(select(binary_table.c.data)), expected)
 
@@ -1263,7 +1263,7 @@ class BinaryTest(fixtures.TestBase):
 
             conn.execute(binary_table.delete())
 
-            conn.execute(binary_table.insert(), data=None)
+            conn.execute(binary_table.insert(), dict(data=None))
             eq_(conn.scalar(select(binary_table.c.data)), None)
 
             eq_(
diff --git a/test/dialect/oracle/test_dialect.py b/test/dialect/oracle/test_dialect.py
index 32234bf653..2ec3068425 100644
--- a/test/dialect/oracle/test_dialect.py
+++ b/test/dialect/oracle/test_dialect.py
@@ -465,7 +465,7 @@ end;
                 outparam("y_out", Float),
                 outparam("z_out", String),
             ),
-            x_in=5,
+            dict(x_in=5),
         )
         eq_(result.out_parameters, {"x_out": 10, "y_out": 75, "z_out": None})
         assert isinstance(result.out_parameters["x_out"], int)
@@ -527,7 +527,7 @@ class QuotedBindRoundTripTest(fixtures.TestBase):
 
         connection.execute(
             select(t).where(t.c.foo.in_(bindparam("uid", expanding=True))),
-            uid=[1, 2, 3],
+            dict(uid=[1, 2, 3]),
         )
 
 
diff --git a/test/dialect/oracle/test_reflection.py b/test/dialect/oracle/test_reflection.py
index 0df4236e25..f9ce1a30b1 100644
--- a/test/dialect/oracle/test_reflection.py
+++ b/test/dialect/oracle/test_reflection.py
@@ -668,8 +668,10 @@ class RoundTripIndexTest(fixtures.TestBase):
                AND owner = :owner
                AND constraint_type = 'P' """
             ),
-            table_name=s_table.name.upper(),
-            owner=testing.db.dialect.default_schema_name.upper(),
+            dict(
+                table_name=s_table.name.upper(),
+                owner=testing.db.dialect.default_schema_name.upper(),
+            ),
         )
 
         reflectedtable = inspect.tables[s_table.name]
diff --git a/test/dialect/oracle/test_types.py b/test/dialect/oracle/test_types.py
index 8ea7c0e044..5b92dea016 100644
--- a/test/dialect/oracle/test_types.py
+++ b/test/dialect/oracle/test_types.py
@@ -206,9 +206,11 @@ class TypesTest(fixtures.TestBase):
         t.create(connection)
         connection.execute(
             t.insert(),
-            dict(id=1, data=v1),
-            dict(id=2, data=v2),
-            dict(id=3, data=v3),
+            [
+                dict(id=1, data=v1),
+                dict(id=2, data=v2),
+                dict(id=3, data=v3),
+            ],
         )
 
         eq_(
@@ -767,7 +769,7 @@ class TypesTest(fixtures.TestBase):
             Column("data", oracle.RAW(35)),
         )
         metadata.create_all(connection)
-        connection.execute(raw_table.insert(), id=1, data=b("ABCDEF"))
+        connection.execute(raw_table.insert(), dict(id=1, data=b("ABCDEF")))
         eq_(connection.execute(raw_table.select()).first(), (1, b("ABCDEF")))
 
     def test_reflect_nvarchar(self, metadata, connection):
@@ -842,7 +844,7 @@ class TypesTest(fixtures.TestBase):
 
         t = Table("t", metadata, Column("data", oracle.LONG))
         metadata.create_all(connection)
-        connection.execute(t.insert(), data="xyz")
+        connection.execute(t.insert(), dict(data="xyz"))
         eq_(connection.scalar(select(t.c.data)), "xyz")
 
     def test_longstring(self, metadata, connection):
@@ -858,7 +860,7 @@ class TypesTest(fixtures.TestBase):
         )
         try:
             t = Table("z_test", metadata, autoload_with=connection)
-            connection.execute(t.insert(), id=1.0, add_user="foobar")
+            connection.execute(t.insert(), dict(id=1.0, add_user="foobar"))
             assert connection.execute(t.select()).fetchall() == [(1, "foobar")]
         finally:
             exec_sql(connection, "DROP TABLE Z_TEST")
@@ -909,7 +911,7 @@ class LOBFetchTest(fixtures.TablesTest):
             cls.stream = stream = file_.read(12000)
 
         for i in range(1, 11):
-            connection.execute(binary_table.insert(), id=i, data=stream)
+            connection.execute(binary_table.insert(), dict(id=i, data=stream))
 
     def test_lobs_without_convert(self):
         engine = testing_engine(options=dict(auto_convert_lobs=False))
diff --git a/test/dialect/postgresql/test_dialect.py b/test/dialect/postgresql/test_dialect.py
index 9c9d817bba..08be41b75f 100644
--- a/test/dialect/postgresql/test_dialect.py
+++ b/test/dialect/postgresql/test_dialect.py
@@ -1160,7 +1160,7 @@ $$ LANGUAGE plpgsql;
         )
         t = Table("speedy_users", meta, autoload_with=connection)
         r = connection.execute(
-            t.insert(), user_name="user", user_password="lala"
+            t.insert(), dict(user_name="user", user_password="lala")
         )
         eq_(r.inserted_primary_key, (1,))
         result = connection.execute(t.select()).fetchall()
diff --git a/test/dialect/postgresql/test_query.py b/test/dialect/postgresql/test_query.py
index c51fd19432..47f86e791f 100644
--- a/test/dialect/postgresql/test_query.py
+++ b/test/dialect/postgresql/test_query.py
@@ -180,13 +180,15 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
 
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
 
                 # executemany, uses SERIAL
 
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
 
                 # single execute, explicit id, inline
 
@@ -252,10 +254,12 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
                 eq_(r.inserted_primary_key, (5,))
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
                 conn.execute(table.insert().inline(), {"id": 33, "data": "d7"})
                 conn.execute(table.insert().inline(), {"data": "d8"})
 
@@ -320,13 +324,15 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
 
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
 
                 # executemany, uses SERIAL
 
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
 
                 # single execute, explicit id, inline
 
@@ -392,10 +398,12 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
                 eq_(r.inserted_primary_key, (5,))
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
                 conn.execute(table.insert().inline(), {"id": 33, "data": "d7"})
                 conn.execute(table.insert().inline(), {"data": "d8"})
 
@@ -451,10 +459,12 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
                 conn.execute(table.insert(), {"data": "d2"})
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
                 conn.execute(table.insert().inline(), {"id": 33, "data": "d7"})
                 conn.execute(table.insert().inline(), {"data": "d8"})
 
@@ -514,10 +524,12 @@ class InsertTest(fixtures.TestBase, AssertsExecutionResults):
                 conn.execute(table.insert(), {"data": "d2"})
                 conn.execute(
                     table.insert(),
-                    {"id": 31, "data": "d3"},
-                    {"id": 32, "data": "d4"},
+                    [
+                        {"id": 31, "data": "d3"},
+                        {"id": 32, "data": "d4"},
+                    ],
                 )
-                conn.execute(table.insert(), {"data": "d5"}, {"data": "d6"})
+                conn.execute(table.insert(), [{"data": "d5"}, {"data": "d6"}])
                 conn.execute(table.insert().inline(), {"id": 33, "data": "d7"})
                 conn.execute(table.insert().inline(), {"data": "d8"})
 
diff --git a/test/dialect/postgresql/test_types.py b/test/dialect/postgresql/test_types.py
index 6202f8f868..b36f50408d 100644
--- a/test/dialect/postgresql/test_types.py
+++ b/test/dialect/postgresql/test_types.py
@@ -128,7 +128,7 @@ class FloatCoercionTest(fixtures.TablesTest, AssertsExecutionResults):
         )
         metadata.create_all(connection)
         connection.execute(
-            t1.insert(), x=[5], y=[5], z=[6], q=[decimal.Decimal("6.4")]
+            t1.insert(), dict(x=[5], y=[5], z=[6], q=[decimal.Decimal("6.4")])
         )
         row = connection.execute(t1.select()).first()
         eq_(row, ([5], [5], [6], [decimal.Decimal("6.4")]))
@@ -144,7 +144,7 @@ class FloatCoercionTest(fixtures.TablesTest, AssertsExecutionResults):
         )
         metadata.create_all(connection)
         connection.execute(
-            t1.insert(), x=[5], y=[5], z=[6], q=[decimal.Decimal("6.4")]
+            t1.insert(), dict(x=[5], y=[5], z=[6], q=[decimal.Decimal("6.4")])
         )
         row = connection.execute(t1.select()).first()
         eq_(row, ([5], [5], [6], [decimal.Decimal("6.4")]))
@@ -167,9 +167,9 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
         )
         t1.create(connection)
         t1.create(connection, checkfirst=True)  # check the create
-        connection.execute(t1.insert(), value="two")
-        connection.execute(t1.insert(), value="three")
-        connection.execute(t1.insert(), value="three")
+        connection.execute(t1.insert(), dict(value="two"))
+        connection.execute(t1.insert(), dict(value="three"))
+        connection.execute(t1.insert(), dict(value="three"))
         eq_(
             connection.execute(t1.select().order_by(t1.c.id)).fetchall(),
             [(1, "two"), (2, "three"), (3, "three")],
@@ -207,9 +207,9 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
         ]
         t1.create(conn, checkfirst=True)
 
-        conn.execute(t1.insert(), value="two")
-        conn.execute(t1.insert(), value="three")
-        conn.execute(t1.insert(), value="three")
+        conn.execute(t1.insert(), dict(value="two"))
+        conn.execute(t1.insert(), dict(value="three"))
+        conn.execute(t1.insert(), dict(value="three"))
         eq_(
             conn.execute(t1.select().order_by(t1.c.id)).fetchall(),
             [(1, "two"), (2, "three"), (3, "three")],
@@ -245,9 +245,9 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
             ),
         )
         metadata.create_all(connection)
-        connection.execute(t1.insert(), value=util.u("drôle"))
-        connection.execute(t1.insert(), value=util.u("réveillé"))
-        connection.execute(t1.insert(), value=util.u("S’il"))
+        connection.execute(t1.insert(), dict(value=util.u("drôle")))
+        connection.execute(t1.insert(), dict(value=util.u("réveillé")))
+        connection.execute(t1.insert(), dict(value=util.u("S’il")))
         eq_(
             connection.execute(t1.select().order_by(t1.c.id)).fetchall(),
             [
@@ -940,7 +940,9 @@ class TimezoneTest(fixtures.TablesTest):
 
         somedate = connection.scalar(func.current_timestamp().select())
         assert somedate.tzinfo
-        connection.execute(tztable.insert(), id=1, name="row1", date=somedate)
+        connection.execute(
+            tztable.insert(), dict(id=1, name="row1", date=somedate)
+        )
         row = connection.execute(
             select(tztable.c.date).where(tztable.c.id == 1)
         ).first()
@@ -951,7 +953,9 @@ class TimezoneTest(fixtures.TablesTest):
         )
         result = connection.execute(
             tztable.update(tztable.c.id == 1).returning(tztable.c.date),
-            name="newname",
+            dict(
+                name="newname",
+            ),
         )
         row = result.first()
         assert row[0] >= somedate
@@ -964,7 +968,7 @@ class TimezoneTest(fixtures.TablesTest):
         somedate = datetime.datetime(2005, 10, 20, 11, 52, 0)
         assert not somedate.tzinfo
         connection.execute(
-            notztable.insert(), id=1, name="row1", date=somedate
+            notztable.insert(), dict(id=1, name="row1", date=somedate)
         )
         row = connection.execute(
             select(notztable.c.date).where(notztable.c.id == 1)
@@ -973,7 +977,9 @@ class TimezoneTest(fixtures.TablesTest):
         eq_(row[0].tzinfo, None)
         result = connection.execute(
             notztable.update(notztable.c.id == 1).returning(notztable.c.date),
-            name="newname",
+            dict(
+                name="newname",
+            ),
         )
         row = result.first()
         assert row[0] >= somedate
@@ -1324,7 +1330,7 @@ class ArrayRoundTripTest(object):
         )
 
     def _fixture_456(self, table, connection):
-        connection.execute(table.insert(), intarr=[4, 5, 6])
+        connection.execute(table.insert(), dict(intarr=[4, 5, 6]))
 
     def test_reflect_array_column(self, connection):
         metadata2 = MetaData()
@@ -1403,8 +1409,10 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[1, 2, 3],
-            strarr=[util.u("abc"), util.u("def")],
+            dict(
+                intarr=[1, 2, 3],
+                strarr=[util.u("abc"), util.u("def")],
+            ),
         )
         results = connection.execute(arrtable.select()).fetchall()
         eq_(len(results), 1)
@@ -1415,8 +1423,10 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[1, None, 3],
-            strarr=[util.u("abc"), None],
+            dict(
+                intarr=[1, None, 3],
+                strarr=[util.u("abc"), None],
+            ),
         )
         results = connection.execute(arrtable.select()).fetchall()
         eq_(len(results), 1)
@@ -1427,11 +1437,13 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[1, 2, 3],
-            strarr=[util.u("abc"), util.u("def")],
+            dict(
+                intarr=[1, 2, 3],
+                strarr=[util.u("abc"), util.u("def")],
+            ),
         )
         connection.execute(
-            arrtable.insert(), intarr=[4, 5, 6], strarr=util.u("ABC")
+            arrtable.insert(), dict(intarr=[4, 5, 6], strarr=util.u("ABC"))
         )
         results = connection.execute(
             arrtable.select().where(arrtable.c.intarr == [1, 2, 3])
@@ -1443,8 +1455,7 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[1, 2, 3],
-            strarr=[util.u("abc"), util.u("def")],
+            dict(intarr=[1, 2, 3], strarr=[util.u("abc"), util.u("def")]),
         )
         results = connection.execute(
             select(arrtable.c.intarr + [4, 5, 6])
@@ -1456,9 +1467,9 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            id=5,
-            intarr=[1, 2, 3],
-            strarr=[util.u("abc"), util.u("def")],
+            dict(
+                id=5, intarr=[1, 2, 3], strarr=[util.u("abc"), util.u("def")]
+            ),
         )
         results = connection.execute(
             select(arrtable.c.id).where(arrtable.c.intarr < [4, 5, 6])
@@ -1470,13 +1481,17 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[4, 5, 6],
-            strarr=[[util.ue("m\xe4\xe4")], [util.ue("m\xf6\xf6")]],
+            dict(
+                intarr=[4, 5, 6],
+                strarr=[[util.ue("m\xe4\xe4")], [util.ue("m\xf6\xf6")]],
+            ),
         )
         connection.execute(
             arrtable.insert(),
-            intarr=[1, 2, 3],
-            strarr=[util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")],
+            dict(
+                intarr=[1, 2, 3],
+                strarr=[util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")],
+            ),
         )
         results = connection.execute(
             arrtable.select(order_by=[arrtable.c.intarr])
@@ -1556,8 +1571,10 @@ class ArrayRoundTripTest(object):
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            intarr=[4, 5, 6],
-            strarr=[util.u("abc"), util.u("def")],
+            dict(
+                intarr=[4, 5, 6],
+                strarr=[util.u("abc"), util.u("def")],
+            ),
         )
         eq_(connection.scalar(select(arrtable.c.intarr[2:3])), [5, 6])
         connection.execute(
@@ -1567,7 +1584,9 @@ class ArrayRoundTripTest(object):
 
     def test_multi_dim_roundtrip(self, connection):
         arrtable = self.tables.arrtable
-        connection.execute(arrtable.insert(), dimarr=[[1, 2, 3], [4, 5, 6]])
+        connection.execute(
+            arrtable.insert(), dict(dimarr=[[1, 2, 3], [4, 5, 6]])
+        )
         eq_(
             connection.scalar(select(arrtable.c.dimarr)),
             [[-1, 0, 1], [2, 3, 4]],
@@ -1575,7 +1594,7 @@ class ArrayRoundTripTest(object):
 
     def test_array_any_exec(self, connection):
         arrtable = self.tables.arrtable
-        connection.execute(arrtable.insert(), intarr=[4, 5, 6])
+        connection.execute(arrtable.insert(), dict(intarr=[4, 5, 6]))
         eq_(
             connection.scalar(
                 select(arrtable.c.intarr).where(
@@ -1587,7 +1606,7 @@ class ArrayRoundTripTest(object):
 
     def test_array_all_exec(self, connection):
         arrtable = self.tables.arrtable
-        connection.execute(arrtable.insert(), intarr=[4, 5, 6])
+        connection.execute(arrtable.insert(), dict(intarr=[4, 5, 6]))
         eq_(
             connection.scalar(
                 select(arrtable.c.intarr).where(
@@ -1610,16 +1629,18 @@ class ArrayRoundTripTest(object):
         )
         metadata.create_all(connection)
         connection.execute(
-            t1.insert(), id=1, data=["1", "2", "3"], data2=[5.4, 5.6]
+            t1.insert(), dict(id=1, data=["1", "2", "3"], data2=[5.4, 5.6])
         )
         connection.execute(
-            t1.insert(), id=2, data=["4", "5", "6"], data2=[1.0]
+            t1.insert(), dict(id=2, data=["4", "5", "6"], data2=[1.0])
         )
         connection.execute(
             t1.insert(),
-            id=3,
-            data=[["4", "5"], ["6", "7"]],
-            data2=[[5.4, 5.6], [1.0, 1.1]],
+            dict(
+                id=3,
+                data=[["4", "5"], ["6", "7"]],
+                data2=[[5.4, 5.6], [1.0, 1.1]],
+            ),
         )
 
         r = connection.execute(t1.select().order_by(t1.c.id)).fetchall()
@@ -1704,7 +1725,7 @@ class PGArrayRoundTripTest(
 
     def test_array_contained_by_exec(self, connection):
         arrtable = self.tables.arrtable
-        connection.execute(arrtable.insert(), intarr=[6, 5, 4])
+        connection.execute(arrtable.insert(), dict(intarr=[6, 5, 4]))
         eq_(
             connection.scalar(
                 select(arrtable.c.intarr.contained_by([4, 5, 6, 7]))
@@ -1724,7 +1745,7 @@ class PGArrayRoundTripTest(
 
     def test_array_overlap_exec(self, connection):
         arrtable = self.tables.arrtable
-        connection.execute(arrtable.insert(), intarr=[4, 5, 6])
+        connection.execute(arrtable.insert(), dict(intarr=[4, 5, 6]))
         eq_(
             connection.scalar(
                 select(arrtable.c.intarr).where(
@@ -2106,10 +2127,12 @@ class SpecialTypesTest(fixtures.TablesTest, ComparesTables):
     def test_tsvector_round_trip(self, connection, metadata):
         t = Table("t1", metadata, Column("data", postgresql.TSVECTOR))
         t.create(connection)
-        connection.execute(t.insert(), data="a fat cat sat")
+        connection.execute(t.insert(), dict(data="a fat cat sat"))
         eq_(connection.scalar(select(t.c.data)), "'a' 'cat' 'fat' 'sat'")
 
-        connection.execute(t.update(), data="'a' 'cat' 'fat' 'mat' 'sat'")
+        connection.execute(
+            t.update(), dict(data="'a' 'cat' 'fat' 'mat' 'sat'")
+        )
 
         eq_(
             connection.scalar(select(t.c.data)),
@@ -2479,11 +2502,13 @@ class HStoreRoundTripTest(fixtures.TablesTest):
         data_table = self.tables.data_table
         connection.execute(
             data_table.insert(),
-            {"name": "r1", "data": {"k1": "r1v1", "k2": "r1v2"}},
-            {"name": "r2", "data": {"k1": "r2v1", "k2": "r2v2"}},
-            {"name": "r3", "data": {"k1": "r3v1", "k2": "r3v2"}},
-            {"name": "r4", "data": {"k1": "r4v1", "k2": "r4v2"}},
-            {"name": "r5", "data": {"k1": "r5v1", "k2": "r5v2"}},
+            [
+                {"name": "r1", "data": {"k1": "r1v1", "k2": "r1v2"}},
+                {"name": "r2", "data": {"k1": "r2v1", "k2": "r2v2"}},
+                {"name": "r3", "data": {"k1": "r3v1", "k2": "r3v2"}},
+                {"name": "r4", "data": {"k1": "r4v1", "k2": "r4v2"}},
+                {"name": "r5", "data": {"k1": "r5v1", "k2": "r5v2"}},
+            ],
         )
 
     def _assert_data(self, compare, conn):
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
index 1926c60652..5871485257 100644
--- a/test/dialect/test_sqlite.py
+++ b/test/dialect/test_sqlite.py
@@ -106,7 +106,7 @@ class TestTypes(fixtures.TestBase, AssertsExecutionResults):
             exc.StatementError,
             connection.execute,
             select(1).where(bindparam("date", type_=Date)),
-            date=str(datetime.date(2007, 10, 30)),
+            dict(date=str(datetime.date(2007, 10, 30))),
         )
 
     def test_cant_parse_datetime_message(self, connection):
@@ -305,7 +305,7 @@ class JSONTest(fixtures.TestBase):
 
         value = {"json": {"foo": "bar"}, "recs": ["one", "two"]}
 
-        connection.execute(sqlite_json.insert(), foo=value)
+        connection.execute(sqlite_json.insert(), dict(foo=value))
 
         eq_(connection.scalar(select(sqlite_json.c.foo)), value)
 
@@ -316,7 +316,7 @@ class JSONTest(fixtures.TestBase):
 
         value = {"json": {"foo": "bar"}}
 
-        connection.execute(sqlite_json.insert(), foo=value)
+        connection.execute(sqlite_json.insert(), dict(foo=value))
 
         eq_(
             connection.scalar(select(sqlite_json.c.foo["json"])), value["json"]
@@ -2397,11 +2397,11 @@ class SavepointTest(fixtures.TablesTest):
         users = self.tables.users
         connection = self.bind.connect()
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans2 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         trans2.rollback()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.commit()
         eq_(
             connection.execute(
@@ -2415,11 +2415,11 @@ class SavepointTest(fixtures.TablesTest):
         users = self.tables.users
         connection = self.bind.connect()
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans2 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         trans2.commit()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.commit()
         eq_(
             connection.execute(
diff --git a/test/engine/test_ddlevents.py b/test/engine/test_ddlevents.py
index baa766d48f..d2755221d1 100644
--- a/test/engine/test_ddlevents.py
+++ b/test/engine/test_ddlevents.py
@@ -490,17 +490,10 @@ class DDLExecutionTest(fixtures.TestBase):
         engine = create_engine("sqlite:///")
         cx = engine.connect()
         cx.begin()
-        table = self.users
         ddl = DDL("SELECT 1")
 
-        for spec in (
-            (cx.execute, ddl),
-            (cx.execute, ddl, table),
-        ):
-            fn = spec[0]
-            arg = spec[1:]
-            r = fn(*arg)
-            eq_(list(r), [(1,)])
+        r = cx.execute(ddl)
+        eq_(list(r), [(1,)])
 
     def test_platform_escape(self):
         """test the escaping of % characters in the DDL construct."""
diff --git a/test/engine/test_deprecations.py b/test/engine/test_deprecations.py
index 0a2c9abe58..4758d49eb6 100644
--- a/test/engine/test_deprecations.py
+++ b/test/engine/test_deprecations.py
@@ -2,6 +2,7 @@ import re
 
 import sqlalchemy as tsa
 import sqlalchemy as sa
+from sqlalchemy import bindparam
 from sqlalchemy import create_engine
 from sqlalchemy import DDL
 from sqlalchemy import engine
@@ -508,13 +509,13 @@ class TransactionTest(fixtures.TablesTest):
         connection.begin()
         branched = connection.connect()
         assert branched.in_transaction()
-        branched.execute(users.insert(), user_id=1, user_name="user1")
+        branched.execute(users.insert(), dict(user_id=1, user_name="user1"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             nested = branched.begin()
-        branched.execute(users.insert(), user_id=2, user_name="user2")
+        branched.execute(users.insert(), dict(user_id=2, user_name="user2"))
         nested.rollback()
         assert not connection.in_transaction()
 
@@ -559,16 +560,16 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans2 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
 
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             trans3 = connection.begin()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         trans3.rollback()
 
         assert_raises_message(
@@ -580,7 +581,7 @@ class TransactionTest(fixtures.TablesTest):
         trans2.rollback()
         assert connection._nested_transaction is None
 
-        connection.execute(users.insert(), user_id=4, user_name="user4")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
         transaction.commit()
         eq_(
             connection.execute(
@@ -602,24 +603,24 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             transaction2 = connection.begin()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         transaction3 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             transaction4 = connection.begin()
-        connection.execute(users.insert(), user_id=4, user_name="user4")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
         transaction4.commit()
         transaction3.rollback()
-        connection.execute(users.insert(), user_id=5, user_name="user5")
+        connection.execute(users.insert(), dict(user_id=5, user_name="user5"))
         transaction2.commit()
         transaction.prepare()
         transaction.commit()
@@ -664,16 +665,16 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             trans2 = connection.begin()
-        connection.execute(users.insert(), user_id=4, user_name="user4")
-        connection.execute(users.insert(), user_id=5, user_name="user5")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
+        connection.execute(users.insert(), dict(user_id=5, user_name="user5"))
         assert connection.in_transaction()
         trans2.close()
         assert connection.in_transaction()
@@ -692,16 +693,16 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             trans2 = connection.begin()
-        connection.execute(users.insert(), user_id=4, user_name="user4")
-        connection.execute(users.insert(), user_id=5, user_name="user5")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
+        connection.execute(users.insert(), dict(user_id=5, user_name="user5"))
         assert connection.in_transaction()
         trans2.close()
         assert connection.in_transaction()
@@ -746,13 +747,13 @@ class TransactionTest(fixtures.TablesTest):
             transaction = connection.begin()
             try:
                 connection.execute(
-                    users.insert(), user_id=1, user_name="user1"
+                    users.insert(), dict(user_id=1, user_name="user1")
                 )
                 connection.execute(
-                    users.insert(), user_id=2, user_name="user2"
+                    users.insert(), dict(user_id=2, user_name="user2")
                 )
                 connection.execute(
-                    users.insert(), user_id=3, user_name="user3"
+                    users.insert(), dict(user_id=3, user_name="user3")
                 )
                 with testing.expect_deprecated_20(
                     r"Calling .begin\(\) when a transaction is already "
@@ -761,10 +762,10 @@ class TransactionTest(fixtures.TablesTest):
                     trans2 = connection.begin()
                 try:
                     connection.execute(
-                        users.insert(), user_id=4, user_name="user4"
+                        users.insert(), dict(user_id=4, user_name="user4")
                     )
                     connection.execute(
-                        users.insert(), user_id=5, user_name="user5"
+                        users.insert(), dict(user_id=5, user_name="user5")
                     )
                     raise Exception("uh oh")
                     trans2.commit()
@@ -786,16 +787,16 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         with testing.expect_deprecated_20(
             r"Calling .begin\(\) when a transaction is already "
             "begun, creating a 'sub' transaction"
         ):
             trans2 = connection.begin()
-        connection.execute(users.insert(), user_id=4, user_name="user4")
-        connection.execute(users.insert(), user_id=5, user_name="user5")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
+        connection.execute(users.insert(), dict(user_id=5, user_name="user5"))
         trans2.commit()
         transaction.rollback()
         self.assert_(
@@ -930,9 +931,9 @@ class TransactionTest(fixtures.TablesTest):
         trans = connection.begin()
         branched = connection.connect()
         assert branched.in_transaction()
-        branched.execute(users.insert(), user_id=1, user_name="user1")
+        branched.execute(users.insert(), dict(user_id=1, user_name="user1"))
         nested = branched.begin_nested()
-        branched.execute(users.insert(), user_id=2, user_name="user2")
+        branched.execute(users.insert(), dict(user_id=2, user_name="user2"))
         nested.rollback()
         assert connection.in_transaction()
         trans.commit()
@@ -951,9 +952,11 @@ class TransactionTest(fixtures.TablesTest):
             r"The current statement is being autocommitted using "
             "implicit autocommit"
         ):
-            branched.execute(users.insert(), user_id=1, user_name="user1")
+            branched.execute(
+                users.insert(), dict(user_id=1, user_name="user1")
+            )
         nested = branched.begin_twophase()
-        branched.execute(users.insert(), user_id=2, user_name="user2")
+        branched.execute(users.insert(), dict(user_id=2, user_name="user2"))
         nested.rollback()
         assert not connection.in_transaction()
         eq_(
@@ -1616,6 +1619,44 @@ class EngineEventsTest(fixtures.TestBase):
                 ):
                     break
 
+    @testing.combinations(
+        ((), {"z": 10}, [], {"z": 10}, testing.requires.legacy_engine),
+    )
+    def test_modify_parameters_from_event_one(
+        self, multiparams, params, expected_multiparams, expected_params
+    ):
+        # this is testing both the normalization added to parameters
+        # as of I97cb4d06adfcc6b889f10d01cc7775925cffb116 as well as
+        # that the return value from the event is taken as the new set
+        # of parameters.
+        def before_execute(
+            conn, clauseelement, multiparams, params, execution_options
+        ):
+            eq_(multiparams, expected_multiparams)
+            eq_(params, expected_params)
+            return clauseelement, (), {"q": "15"}
+
+        def after_execute(
+            conn, clauseelement, multiparams, params, result, execution_options
+        ):
+            eq_(multiparams, ())
+            eq_(params, {"q": "15"})
+
+        e1 = testing_engine(config.db_url)
+        event.listen(e1, "before_execute", before_execute, retval=True)
+        event.listen(e1, "after_execute", after_execute)
+
+        with e1.connect() as conn:
+            with testing.expect_deprecated_20(
+                r"The connection\.execute\(\) method"
+            ):
+                result = conn.execute(
+                    select(bindparam("q", type_=String)),
+                    *multiparams,
+                    **params
+                )
+            eq_(result.all(), [("15",)])
+
     def test_retval_flag(self):
         canary = []
 
diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index a1e4ea218e..b9eb4f815e 100644
--- a/test/engine/test_execute.py
+++ b/test/engine/test_execute.py
@@ -1650,7 +1650,6 @@ class EngineEventsTest(fixtures.TestBase):
             [{"x": 5, "y": 10}, {"x": 8, "y": 9}],
             {},
         ),
-        ((), {"z": 10}, [], {"z": 10}, testing.requires.legacy_engine),
         (({"z": 10},), {}, [], {"z": 10}),
         argnames="multiparams, params, expected_multiparams, expected_params",
     )
diff --git a/test/engine/test_transaction.py b/test/engine/test_transaction.py
index 47504b60a3..8a8d1fa62d 100644
--- a/test/engine/test_transaction.py
+++ b/test/engine/test_transaction.py
@@ -47,12 +47,12 @@ class TransactionTest(fixtures.TablesTest):
         users = self.tables.users
         connection = local_connection
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         transaction.commit()
 
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.commit()
 
         transaction = connection.begin()
@@ -67,9 +67,9 @@ class TransactionTest(fixtures.TablesTest):
         users = self.tables.users
         connection = local_connection
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.rollback()
         result = connection.exec_driver_sql("select * from users")
         assert len(result.fetchall()) == 0
@@ -80,9 +80,15 @@ class TransactionTest(fixtures.TablesTest):
 
         transaction = connection.begin()
         try:
-            connection.execute(users.insert(), user_id=1, user_name="user1")
-            connection.execute(users.insert(), user_id=2, user_name="user2")
-            connection.execute(users.insert(), user_id=1, user_name="user3")
+            connection.execute(
+                users.insert(), dict(user_id=1, user_name="user1")
+            )
+            connection.execute(
+                users.insert(), dict(user_id=2, user_name="user2")
+            )
+            connection.execute(
+                users.insert(), dict(user_id=1, user_name="user3")
+            )
             transaction.commit()
             assert False
         except Exception as e:
@@ -242,9 +248,9 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         conn2 = connection.execution_options(dummy=True)
-        conn2.execute(users.insert(), user_id=2, user_name="user2")
+        conn2.execute(users.insert(), dict(user_id=2, user_name="user2"))
         transaction.rollback()
         eq_(
             connection.exec_driver_sql("select count(*) from users").scalar(),
@@ -255,10 +261,12 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         trans = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         try:
-            connection.execute(users.insert(), user_id=2, user_name="user2.5")
+            connection.execute(
+                users.insert(), dict(user_id=2, user_name="user2.5")
+            )
         except Exception:
             trans.__exit__(*sys.exc_info())
 
@@ -271,7 +279,7 @@ class TransactionTest(fixtures.TablesTest):
         )
 
         trans = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans.__exit__(None, None, None)
         assert not trans.is_active
         self.assert_(
@@ -285,9 +293,9 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         assert connection.in_transaction()
         transaction.commit()
         assert not connection.in_transaction()
@@ -298,9 +306,9 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
-        connection.execute(users.insert(), user_id=2, user_name="user2")
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         assert connection.in_transaction()
         transaction.close()
         assert not connection.in_transaction()
@@ -312,11 +320,11 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans2 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         trans2.rollback()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.commit()
         eq_(
             connection.execute(
@@ -330,11 +338,11 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         trans2 = connection.begin_nested()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         trans2.commit()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.commit()
         eq_(
             connection.execute(
@@ -348,18 +356,18 @@ class TransactionTest(fixtures.TablesTest):
         connection = local_connection
         users = self.tables.users
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), user_id=1, user_name="user1")
+        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
         transaction.prepare()
         transaction.commit()
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), user_id=2, user_name="user2")
+        connection.execute(users.insert(), dict(user_id=2, user_name="user2"))
         transaction.commit()
         transaction.close()
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), user_id=3, user_name="user3")
+        connection.execute(users.insert(), dict(user_id=3, user_name="user3"))
         transaction.rollback()
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), user_id=4, user_name="user4")
+        connection.execute(users.insert(), dict(user_id=4, user_name="user4"))
         transaction.prepare()
         transaction.rollback()
         transaction.close()
@@ -386,7 +394,9 @@ class TransactionTest(fixtures.TablesTest):
         connection = testing.db.connect()
 
         transaction = connection.begin_twophase()
-        connection.execute(users.insert(), dict(user_id=1, user_name="user1"))
+        connection.execute(
+            users.insert(), dict(dict(user_id=1, user_name="user1"))
+        )
         transaction.prepare()
         connection.invalidate()
 
@@ -415,18 +425,18 @@ class TransactionTest(fixtures.TablesTest):
         conn = local_connection
         users = self.tables.users
         xa = conn.begin_twophase()
-        conn.execute(users.insert(), user_id=1, user_name="user1")
+        conn.execute(users.insert(), dict(user_id=1, user_name="user1"))
         xa.prepare()
         xa.commit()
         xa = conn.begin_twophase()
-        conn.execute(users.insert(), user_id=2, user_name="user2")
+        conn.execute(users.insert(), dict(user_id=2, user_name="user2"))
         xa.prepare()
         xa.rollback()
         xa = conn.begin_twophase()
-        conn.execute(users.insert(), user_id=3, user_name="user3")
+        conn.execute(users.insert(), dict(user_id=3, user_name="user3"))
         xa.rollback()
         xa = conn.begin_twophase()
-        conn.execute(users.insert(), user_id=4, user_name="user4")
+        conn.execute(users.insert(), dict(user_id=4, user_name="user4"))
         xa.prepare()
         xa.commit()
         result = conn.execute(
@@ -456,7 +466,7 @@ class TransactionTest(fixtures.TablesTest):
             rec = conn.connection._connection_record
             raw_dbapi_con = rec.connection
             conn.begin_twophase()
-            conn.execute(users.insert(), user_id=1, user_name="user1")
+            conn.execute(users.insert(), dict(user_id=1, user_name="user1"))
 
         assert rec.connection is raw_dbapi_con
 
diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py
index 15063ebe92..ce012d381f 100644
--- a/test/orm/test_deprecations.py
+++ b/test/orm/test_deprecations.py
@@ -2201,6 +2201,10 @@ class AutocommitClosesOnFailTest(fixtures.MappedTest):
     __requires__ = ("deferrable_fks",)
     __only_on__ = ("postgresql+psycopg2",)  # needs #5824 for asyncpg
 
+    # this test has a lot of problems, am investigating asyncpg
+    # issues separately.  just get this legacy use case to pass for now.
+    __only_on__ = ("postgresql+psycopg2",)
+
     @classmethod
     def define_tables(cls, metadata):
         Table("t1", metadata, Column("id", Integer, primary_key=True))
@@ -2239,7 +2243,7 @@ class AutocommitClosesOnFailTest(fixtures.MappedTest):
     def test_close_transaction_on_commit_fail(self):
         T2 = self.classes.T2
 
-        session = fixture_session(autocommit=True)
+        session = Session(testing.db, autocommit=True)
 
         # with a deferred constraint, this fails at COMMIT time instead
         # of at INSERT time.
diff --git a/test/orm/test_eager_relations.py b/test/orm/test_eager_relations.py
index 7eedb37c92..0f67aa94db 100644
--- a/test/orm/test_eager_relations.py
+++ b/test/orm/test_eager_relations.py
@@ -4969,19 +4969,23 @@ class CorrelatedSubqueryTest(fixtures.MappedTest):
 
         connection.execute(
             users.insert(),
-            {"id": 1, "name": "user1"},
-            {"id": 2, "name": "user2"},
-            {"id": 3, "name": "user3"},
+            [
+                {"id": 1, "name": "user1"},
+                {"id": 2, "name": "user2"},
+                {"id": 3, "name": "user3"},
+            ],
         )
 
         connection.execute(
             stuff.insert(),
-            {"id": 1, "user_id": 1, "date": datetime.date(2007, 10, 15)},
-            {"id": 2, "user_id": 1, "date": datetime.date(2007, 12, 15)},
-            {"id": 3, "user_id": 1, "date": datetime.date(2007, 11, 15)},
-            {"id": 4, "user_id": 2, "date": datetime.date(2008, 1, 15)},
-            {"id": 5, "user_id": 3, "date": datetime.date(2007, 6, 15)},
-            {"id": 6, "user_id": 3, "date": datetime.date(2007, 3, 15)},
+            [
+                {"id": 1, "user_id": 1, "date": datetime.date(2007, 10, 15)},
+                {"id": 2, "user_id": 1, "date": datetime.date(2007, 12, 15)},
+                {"id": 3, "user_id": 1, "date": datetime.date(2007, 11, 15)},
+                {"id": 4, "user_id": 2, "date": datetime.date(2008, 1, 15)},
+                {"id": 5, "user_id": 3, "date": datetime.date(2007, 6, 15)},
+                {"id": 6, "user_id": 3, "date": datetime.date(2007, 3, 15)},
+            ],
         )
 
     def test_labeled_on_date_noalias(self):
diff --git a/test/orm/test_expire.py b/test/orm/test_expire.py
index 5771ee5385..95efae850e 100644
--- a/test/orm/test_expire.py
+++ b/test/orm/test_expire.py
@@ -1392,14 +1392,18 @@ class PolymorphicExpireTest(fixtures.MappedTest):
 
         connection.execute(
             people.insert(),
-            {"person_id": 1, "name": "person1", "type": "person"},
-            {"person_id": 2, "name": "engineer1", "type": "engineer"},
-            {"person_id": 3, "name": "engineer2", "type": "engineer"},
+            [
+                {"person_id": 1, "name": "person1", "type": "person"},
+                {"person_id": 2, "name": "engineer1", "type": "engineer"},
+                {"person_id": 3, "name": "engineer2", "type": "engineer"},
+            ],
         )
         connection.execute(
             engineers.insert(),
-            {"person_id": 2, "status": "new engineer"},
-            {"person_id": 3, "status": "old engineer"},
+            [
+                {"person_id": 2, "status": "new engineer"},
+                {"person_id": 3, "status": "old engineer"},
+            ],
         )
 
     @classmethod
diff --git a/test/orm/test_lazy_relations.py b/test/orm/test_lazy_relations.py
index 43cf81e6d4..921a1b15de 100644
--- a/test/orm/test_lazy_relations.py
+++ b/test/orm/test_lazy_relations.py
@@ -1184,18 +1184,22 @@ class CorrelatedTest(fixtures.MappedTest):
 
         connection.execute(
             user_t.insert(),
-            {"id": 1, "name": "user1"},
-            {"id": 2, "name": "user2"},
-            {"id": 3, "name": "user3"},
+            [
+                {"id": 1, "name": "user1"},
+                {"id": 2, "name": "user2"},
+                {"id": 3, "name": "user3"},
+            ],
         )
 
         connection.execute(
             stuff.insert(),
-            {"id": 1, "user_id": 1, "date": datetime.date(2007, 10, 15)},
-            {"id": 2, "user_id": 1, "date": datetime.date(2007, 12, 15)},
-            {"id": 3, "user_id": 1, "date": datetime.date(2007, 11, 15)},
-            {"id": 4, "user_id": 2, "date": datetime.date(2008, 1, 15)},
-            {"id": 5, "user_id": 3, "date": datetime.date(2007, 6, 15)},
+            [
+                {"id": 1, "user_id": 1, "date": datetime.date(2007, 10, 15)},
+                {"id": 2, "user_id": 1, "date": datetime.date(2007, 12, 15)},
+                {"id": 3, "user_id": 1, "date": datetime.date(2007, 11, 15)},
+                {"id": 4, "user_id": 2, "date": datetime.date(2008, 1, 15)},
+                {"id": 5, "user_id": 3, "date": datetime.date(2007, 6, 15)},
+            ],
         )
 
     def test_correlated_lazyload(self):
@@ -1308,8 +1312,10 @@ class O2MWOSideFixedTest(fixtures.MappedTest):
 
                 conn.execute(
                     person.insert(),
-                    {"id": 1, "city_id": 1},
-                    {"id": 2, "city_id": 1},
+                    [
+                        {"id": 1, "city_id": 1},
+                        {"id": 2, "city_id": 1},
+                    ],
                 )
 
             conn.execute(city.insert(), {"id": 2, "deleted": True})
diff --git a/test/orm/test_naturalpks.py b/test/orm/test_naturalpks.py
index 4a3fee6343..6ad612b740 100644
--- a/test/orm/test_naturalpks.py
+++ b/test/orm/test_naturalpks.py
@@ -315,9 +315,15 @@ class NaturalPKTest(fixtures.MappedTest):
         )
 
         with testing.db.begin() as conn:
-            conn.execute(users.insert(), username="jack", fullname="jack")
-            conn.execute(addresses.insert(), email="jack1", username="jack")
-            conn.execute(addresses.insert(), email="jack2", username="jack")
+            conn.execute(
+                users.insert(), dict(username="jack", fullname="jack")
+            )
+            conn.execute(
+                addresses.insert(), dict(email="jack1", username="jack")
+            )
+            conn.execute(
+                addresses.insert(), dict(email="jack2", username="jack")
+            )
 
         mapper(User, users)
         mapper(
diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py
index 8be7eed1f5..7f83917085 100644
--- a/test/sql/test_defaults.py
+++ b/test/sql/test_defaults.py
@@ -980,12 +980,12 @@ class PKDefaultTest(fixtures.TablesTest):
                 options={"implicit_returning": returning}
             )
         with engine.begin() as conn:
-            conn.execute(t2.insert(), nextid=1)
-            r = conn.execute(t1.insert(), data="hi")
+            conn.execute(t2.insert(), dict(nextid=1))
+            r = conn.execute(t1.insert(), dict(data="hi"))
             eq_((1,), r.inserted_primary_key)
 
-            conn.execute(t2.insert(), nextid=2)
-            r = conn.execute(t1.insert(), data="there")
+            conn.execute(t2.insert(), dict(nextid=2))
+            r = conn.execute(t1.insert(), dict(data="there"))
             eq_((2,), r.inserted_primary_key)
 
             r = conn.execute(date_table.insert())
@@ -1015,19 +1015,19 @@ class PKIncrementTest(fixtures.TablesTest):
         aitable = self.tables.aitable
 
         ids = set()
-        rs = connection.execute(aitable.insert(), int1=1)
+        rs = connection.execute(aitable.insert(), dict(int1=1))
         last = rs.inserted_primary_key[0]
         self.assert_(last)
         self.assert_(last not in ids)
         ids.add(last)
 
-        rs = connection.execute(aitable.insert(), str1="row 2")
+        rs = connection.execute(aitable.insert(), dict(str1="row 2"))
         last = rs.inserted_primary_key[0]
         self.assert_(last)
         self.assert_(last not in ids)
         ids.add(last)
 
-        rs = connection.execute(aitable.insert(), int1=3, str1="row 3")
+        rs = connection.execute(aitable.insert(), dict(int1=3, str1="row 3"))
         last = rs.inserted_primary_key[0]
         self.assert_(last)
         self.assert_(last not in ids)
@@ -1066,14 +1066,13 @@ class EmptyInsertTest(fixtures.TestBase):
     __backend__ = True
 
     @testing.fails_on("oracle", "FIXME: unknown")
-    @testing.provide_metadata
-    def test_empty_insert(self, connection):
+    def test_empty_insert(self, metadata, connection):
         t1 = Table(
             "t1",
-            self.metadata,
+            metadata,
             Column("is_true", Boolean, server_default=("1")),
         )
-        self.metadata.create_all(connection)
+        metadata.create_all(connection)
         connection.execute(t1.insert())
         eq_(
             1,
diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py
index 7775652208..903da2f344 100644
--- a/test/sql/test_deprecations.py
+++ b/test/sql/test_deprecations.py
@@ -1089,7 +1089,7 @@ class KeyTargetingTest(fixtures.TablesTest):
         conn.execute(cls.tables.keyed2.insert(), dict(a="a2", b="b2"))
         conn.execute(cls.tables.keyed3.insert(), dict(a="a3", d="d3"))
         conn.execute(cls.tables.keyed4.insert(), dict(b="b4", q="q4"))
-        conn.execute(cls.tables.content.insert(), type="t1")
+        conn.execute(cls.tables.content.insert(), dict(type="t1"))
 
         if testing.requires.schemas.enabled:
             conn.execute(
@@ -1475,8 +1475,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
 
     def test_column_accessor_textual_select(self, connection):
@@ -1602,9 +1604,11 @@ class CursorResultTest(fixtures.TablesTest):
             conn.execute(users.delete())
             conn.execute(
                 users.insert(),
-                {"user_id": 7, "user_name": "jack"},
-                {"user_id": 8, "user_name": "ed"},
-                {"user_id": 9, "user_name": "fred"},
+                [
+                    {"user_id": 7, "user_name": "jack"},
+                    {"user_id": 8, "user_name": "ed"},
+                    {"user_id": 9, "user_name": "fred"},
+                ],
             )
 
             for pickle in False, True:
diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py
index 32ea642d74..50f50f0f0f 100644
--- a/test/sql/test_functions.py
+++ b/test/sql/test_functions.py
@@ -1024,7 +1024,7 @@ class ExecuteTest(fixtures.TestBase):
         connection.execute(t2.insert().values(value=func.length("one")))
         connection.execute(
             t2.insert().values(value=func.length("asfda") + -19),
-            stuff="hi",
+            dict(stuff="hi"),
         )
 
         res = sorted(connection.execute(select(t2.c.value, t2.c.stuff)))
@@ -1032,7 +1032,7 @@ class ExecuteTest(fixtures.TestBase):
 
         connection.execute(
             t2.update().values(value=func.length("asdsafasd")),
-            stuff="some stuff",
+            dict(stuff="some stuff"),
         )
         eq_(
             connection.execute(select(t2.c.value, t2.c.stuff)).fetchall(),
diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py
index 198ff48c08..ba763772c7 100644
--- a/test/sql/test_insert_exec.py
+++ b/test/sql/test_insert_exec.py
@@ -82,9 +82,11 @@ class InsertExecTest(fixtures.TablesTest):
         # a length check on all subsequent parameters.
         connection.execute(
             users.insert(),
-            {"user_id": 7},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9},
+            [
+                {"user_id": 7},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9},
+            ],
         )
 
     def _test_lastrow_accessor(self, table_, values, assertvalues):
@@ -107,7 +109,7 @@ class InsertExecTest(fixtures.TablesTest):
                     is_(bool(comp.returning), True)
 
             with engine.begin() as connection:
-                result = connection.execute(table_.insert(), **values)
+                result = connection.execute(table_.insert(), values)
                 ret = values.copy()
 
                 for col, id_ in zip(
diff --git a/test/sql/test_query.py b/test/sql/test_query.py
index 3047b5d096..903a6f23e4 100644
--- a/test/sql/test_query.py
+++ b/test/sql/test_query.py
@@ -86,9 +86,11 @@ class QueryTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
 
         concat = ("test: " + users.c.user_name).label("thedata")
@@ -115,9 +117,11 @@ class QueryTest(fixtures.TablesTest):
         users = self.tables.users
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
 
         concat = ("test: " + users.c.user_name).label("thedata")
@@ -171,11 +175,13 @@ class QueryTest(fixtures.TablesTest):
         users = self.tables.users
         connection.execute(
             users.insert(),
-            {"user_id": 1, "user_name": "apples"},
-            {"user_id": 2, "user_name": "oranges"},
-            {"user_id": 3, "user_name": "bananas"},
-            {"user_id": 4, "user_name": "legumes"},
-            {"user_id": 5, "user_name": "hi % there"},
+            [
+                {"user_id": 1, "user_name": "apples"},
+                {"user_id": 2, "user_name": "oranges"},
+                {"user_id": 3, "user_name": "bananas"},
+                {"user_id": 4, "user_name": "legumes"},
+                {"user_id": 5, "user_name": "hi % there"},
+            ],
         )
 
         for expr, result in (
@@ -223,10 +229,12 @@ class QueryTest(fixtures.TablesTest):
         users = self.tables.users
         connection.execute(
             users.insert(),
-            {"user_id": 1, "user_name": "one"},
-            {"user_id": 2, "user_name": "TwO"},
-            {"user_id": 3, "user_name": "ONE"},
-            {"user_id": 4, "user_name": "OnE"},
+            [
+                {"user_id": 1, "user_name": "one"},
+                {"user_id": 2, "user_name": "TwO"},
+                {"user_id": 3, "user_name": "ONE"},
+                {"user_id": 4, "user_name": "OnE"},
+            ],
         )
 
         eq_(
@@ -263,25 +271,26 @@ class QueryTest(fixtures.TablesTest):
 
     def test_compiled_execute(self, connection):
         users = self.tables.users
-        connection.execute(users.insert(), user_id=7, user_name="jack")
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
         s = (
             select(users)
             .where(users.c.user_id == bindparam("id"))
             .compile(connection)
         )
-        eq_(connection.execute(s, id=7).first()._mapping["user_id"], 7)
+        eq_(connection.execute(s, dict(id=7)).first()._mapping["user_id"], 7)
 
     def test_compiled_insert_execute(self, connection):
         users = self.tables.users
         connection.execute(
-            users.insert().compile(connection), user_id=7, user_name="jack"
+            users.insert().compile(connection),
+            dict(user_id=7, user_name="jack"),
         )
         s = (
             select(users)
             .where(users.c.user_id == bindparam("id"))
             .compile(connection)
         )
-        eq_(connection.execute(s, id=7).first()._mapping["user_id"], 7)
+        eq_(connection.execute(s, dict(id=7)).first()._mapping["user_id"], 7)
 
     def test_repeated_bindparams(self, connection):
         """Tests that a BindParam can be used more than once.
@@ -291,12 +300,12 @@ class QueryTest(fixtures.TablesTest):
         """
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="jack")
-        connection.execute(users.insert(), user_id=8, user_name="fred")
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
+        connection.execute(users.insert(), dict(user_id=8, user_name="fred"))
 
         u = bindparam("userid")
         s = users.select(and_(users.c.user_name == u, users.c.user_name == u))
-        r = connection.execute(s, userid="fred").fetchall()
+        r = connection.execute(s, dict(userid="fred")).fetchall()
         assert len(r) == 1
 
     def test_bindparam_detection(self):
@@ -365,9 +374,9 @@ class QueryTest(fixtures.TablesTest):
 
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="c")
-        connection.execute(users.insert(), user_id=2, user_name="b")
-        connection.execute(users.insert(), user_id=3, user_name="a")
+        connection.execute(users.insert(), dict(user_id=1, user_name="c"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="b"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="a"))
 
         def a_eq(executable, wanted):
             got = list(connection.execute(executable))
@@ -467,9 +476,9 @@ class QueryTest(fixtures.TablesTest):
 
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1)
-        connection.execute(users.insert(), user_id=2, user_name="b")
-        connection.execute(users.insert(), user_id=3, user_name="a")
+        connection.execute(users.insert(), dict(user_id=1))
+        connection.execute(users.insert(), dict(user_id=2, user_name="b"))
+        connection.execute(users.insert(), dict(user_id=3, user_name="a"))
 
         def a_eq(executable, wanted):
             got = list(connection.execute(executable))
@@ -563,9 +572,9 @@ class QueryTest(fixtures.TablesTest):
         """test the behavior of the in_() function."""
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="jack")
-        connection.execute(users.insert(), user_id=8, user_name="fred")
-        connection.execute(users.insert(), user_id=9, user_name=None)
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
+        connection.execute(users.insert(), dict(user_id=8, user_name="fred"))
+        connection.execute(users.insert(), dict(user_id=9, user_name=None))
 
         s = users.select(users.c.user_name.in_([]))
         r = connection.execute(s).fetchall()
@@ -821,16 +830,16 @@ class QueryTest(fixtures.TablesTest):
 
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="jack")
-        connection.execute(users.insert(), user_id=8, user_name="fred")
-        connection.execute(users.insert(), user_id=9, user_name=None)
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
+        connection.execute(users.insert(), dict(user_id=8, user_name="fred"))
+        connection.execute(users.insert(), dict(user_id=9, user_name=None))
 
         u = bindparam("search_key", type_=String)
 
         s = users.select(not_(u.in_([])))
-        r = connection.execute(s, search_key="john").fetchall()
+        r = connection.execute(s, dict(search_key="john")).fetchall()
         assert len(r) == 3
-        r = connection.execute(s, search_key=None).fetchall()
+        r = connection.execute(s, dict(search_key=None)).fetchall()
         assert len(r) == 3
 
     def test_literal_in(self, connection):
@@ -838,9 +847,9 @@ class QueryTest(fixtures.TablesTest):
 
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="jack")
-        connection.execute(users.insert(), user_id=8, user_name="fred")
-        connection.execute(users.insert(), user_id=9, user_name=None)
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
+        connection.execute(users.insert(), dict(user_id=8, user_name="fred"))
+        connection.execute(users.insert(), dict(user_id=9, user_name=None))
 
         s = users.select(not_(literal("john").in_([])))
         r = connection.execute(s).fetchall()
@@ -891,14 +900,6 @@ class RequiredBindTest(fixtures.TablesTest):
 
     def _assert_raises(self, stmt, params):
         with testing.db.connect() as conn:
-            assert_raises_message(
-                exc.StatementError,
-                "A value is required for bind parameter 'x'",
-                conn.execute,
-                stmt,
-                **params
-            )
-
             assert_raises_message(
                 exc.StatementError,
                 "A value is required for bind parameter 'x'",
@@ -967,33 +968,33 @@ class LimitTest(fixtures.TablesTest):
     def insert_data(cls, connection):
         users, addresses = cls.tables("users", "addresses")
         conn = connection
-        conn.execute(users.insert(), user_id=1, user_name="john")
+        conn.execute(users.insert(), dict(user_id=1, user_name="john"))
         conn.execute(
-            addresses.insert(), address_id=1, user_id=1, address="addr1"
+            addresses.insert(), dict(address_id=1, user_id=1, address="addr1")
         )
-        conn.execute(users.insert(), user_id=2, user_name="jack")
+        conn.execute(users.insert(), dict(user_id=2, user_name="jack"))
         conn.execute(
-            addresses.insert(), address_id=2, user_id=2, address="addr1"
+            addresses.insert(), dict(address_id=2, user_id=2, address="addr1")
         )
-        conn.execute(users.insert(), user_id=3, user_name="ed")
+        conn.execute(users.insert(), dict(user_id=3, user_name="ed"))
         conn.execute(
-            addresses.insert(), address_id=3, user_id=3, address="addr2"
+            addresses.insert(), dict(address_id=3, user_id=3, address="addr2")
         )
-        conn.execute(users.insert(), user_id=4, user_name="wendy")
+        conn.execute(users.insert(), dict(user_id=4, user_name="wendy"))
         conn.execute(
-            addresses.insert(), address_id=4, user_id=4, address="addr3"
+            addresses.insert(), dict(address_id=4, user_id=4, address="addr3")
         )
-        conn.execute(users.insert(), user_id=5, user_name="laura")
+        conn.execute(users.insert(), dict(user_id=5, user_name="laura"))
         conn.execute(
-            addresses.insert(), address_id=5, user_id=5, address="addr4"
+            addresses.insert(), dict(address_id=5, user_id=5, address="addr4")
         )
-        conn.execute(users.insert(), user_id=6, user_name="ralph")
+        conn.execute(users.insert(), dict(user_id=6, user_name="ralph"))
         conn.execute(
-            addresses.insert(), address_id=6, user_id=6, address="addr5"
+            addresses.insert(), dict(address_id=6, user_id=6, address="addr5")
         )
-        conn.execute(users.insert(), user_id=7, user_name="fido")
+        conn.execute(users.insert(), dict(user_id=7, user_name="fido"))
         conn.execute(
-            addresses.insert(), address_id=7, user_id=7, address="addr5"
+            addresses.insert(), dict(address_id=7, user_id=7, address="addr5")
         )
 
     def test_select_limit(self, connection):
@@ -1510,16 +1511,22 @@ class JoinTest(fixtures.TablesTest):
 
         conn.execute(
             t1.insert(),
-            {"t1_id": 10, "name": "t1 #10"},
-            {"t1_id": 11, "name": "t1 #11"},
-            {"t1_id": 12, "name": "t1 #12"},
+            [
+                {"t1_id": 10, "name": "t1 #10"},
+                {"t1_id": 11, "name": "t1 #11"},
+                {"t1_id": 12, "name": "t1 #12"},
+            ],
         )
         conn.execute(
             t2.insert(),
-            {"t2_id": 20, "t1_id": 10, "name": "t2 #20"},
-            {"t2_id": 21, "t1_id": 11, "name": "t2 #21"},
+            [
+                {"t2_id": 20, "t1_id": 10, "name": "t2 #20"},
+                {"t2_id": 21, "t1_id": 11, "name": "t2 #21"},
+            ],
+        )
+        conn.execute(
+            t3.insert(), [{"t3_id": 30, "t2_id": 20, "name": "t3 #30"}]
         )
-        conn.execute(t3.insert(), {"t3_id": 30, "t2_id": 20, "name": "t3 #30"})
 
     def assertRows(self, statement, expected):
         """Execute a statement and assert that rows returned equal expected."""
diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py
index 7ad12c6203..23aa703d36 100644
--- a/test/sql/test_resultset.py
+++ b/test/sql/test_resultset.py
@@ -95,9 +95,11 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
         r = connection.execute(users.select())
         rows = []
@@ -110,9 +112,11 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
         r = connection.execute(users.select())
         rows = []
@@ -129,9 +133,11 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
 
         sel = (
@@ -148,7 +154,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_row_comparison(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="jack")
+        connection.execute(users.insert(), dict(user_id=7, user_name="jack"))
         rp = connection.execute(users.select()).first()
 
         eq_(rp, rp)
@@ -222,9 +228,11 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            {"user_id": 7, "user_name": "jack"},
-            {"user_id": 8, "user_name": "ed"},
-            {"user_id": 9, "user_name": "fred"},
+            [
+                {"user_id": 7, "user_name": "jack"},
+                {"user_id": 8, "user_name": "ed"},
+                {"user_id": 9, "user_name": "fred"},
+            ],
         )
 
         for pickle in False, True:
@@ -330,10 +338,11 @@ class CursorResultTest(fixtures.TablesTest):
         users = self.tables.users
         addresses = self.tables.addresses
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
-        connection.execute(users.insert(), user_id=2, user_name="jack")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="jack"))
         connection.execute(
-            addresses.insert(), address_id=1, user_id=2, address="foo@bar.com"
+            addresses.insert(),
+            dict(address_id=1, user_id=2, address="foo@bar.com"),
         )
 
         r = connection.execute(text("select * from addresses")).first()
@@ -345,10 +354,11 @@ class CursorResultTest(fixtures.TablesTest):
         users = self.tables.users
         addresses = self.tables.addresses
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
-        connection.execute(users.insert(), user_id=2, user_name="jack")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
+        connection.execute(users.insert(), dict(user_id=2, user_name="jack"))
         connection.execute(
-            addresses.insert(), address_id=1, user_id=2, address="foo@bar.com"
+            addresses.insert(),
+            dict(address_id=1, user_id=2, address="foo@bar.com"),
         )
 
         r = connection.execute(text("select * from addresses"))
@@ -362,8 +372,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
 
         r = connection.execute(users.select(users.c.user_id == 2)).first()
@@ -380,8 +392,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
 
         r = connection.execute(users.select(users.c.user_id == 2)).first()
@@ -399,8 +413,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
 
         r = connection.execute(
@@ -414,8 +430,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
         r = connection.execute(
             text("select * from users where user_id=2")
@@ -435,8 +453,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
         r = connection.execute(
             text("select * from users where user_id=2").columns(
@@ -457,8 +477,10 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="john"),
-            dict(user_id=2, user_name="jack"),
+            [
+                dict(user_id=1, user_name="john"),
+                dict(user_id=2, user_name="jack"),
+            ],
         )
         # this will create column() objects inside
         # the select(), these need to match on name anyway
@@ -619,7 +641,7 @@ class CursorResultTest(fixtures.TablesTest):
             lambda r: r.cursor_strategy.fetchone(r, r.cursor),
         ]:
             trans = conn.begin()
-            result = conn.execute(users.insert(), user_id=1)
+            result = conn.execute(users.insert(), dict(user_id=1))
             assert_raises_message(
                 exc.ResourceClosedError,
                 "This result object does not return rows. "
@@ -691,7 +713,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_row_as_args(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
         r = connection.execute(users.select(users.c.user_id == 1)).first()
         connection.execute(users.delete())
         connection.execute(users.insert(), r._mapping)
@@ -719,7 +741,7 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(users2.delete())
         r = connection.execute(users.select())
-        connection.execute(users2.insert(), *[row._mapping for row in r])
+        connection.execute(users2.insert(), [row._mapping for row in r])
         eq_(
             connection.execute(
                 users2.select().order_by(users2.c.user_id)
@@ -732,7 +754,7 @@ class CursorResultTest(fixtures.TablesTest):
         users = self.tables.users
         addresses = self.tables.addresses
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
         result = connection.execute(users.outerjoin(addresses).select())
         r = result.first()
 
@@ -775,7 +797,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_ambiguous_column_by_col(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
         ua = users.alias()
         u2 = users.alias()
         result = connection.execute(
@@ -807,7 +829,7 @@ class CursorResultTest(fixtures.TablesTest):
         # ticket 2702.  in 0.7 we'd get True, False.
         # in 0.8, both columns are present so it's True;
         # but when they're fetched you'll get the ambiguous error.
-        connection.execute(users.insert(), user_id=1, user_name="john")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
         result = connection.execute(
             select(users.c.user_id, addresses.c.user_id).select_from(
                 users.outerjoin(addresses)
@@ -896,7 +918,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_ambiguous_column_by_col_plus_label(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="john")
+        connection.execute(users.insert(), dict(user_id=1, user_name="john"))
         result = connection.execute(
             select(
                 users.c.user_id,
@@ -910,7 +932,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_fetch_partial_result_map(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="ed")
+        connection.execute(users.insert(), dict(user_id=7, user_name="ed"))
 
         t = text("select * from users").columns(user_name=String())
         eq_(connection.execute(t).fetchall(), [(7, "ed")])
@@ -918,7 +940,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_fetch_unordered_result_map(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="ed")
+        connection.execute(users.insert(), dict(user_id=7, user_name="ed"))
 
         class Goofy1(TypeDecorator):
             impl = String
@@ -948,7 +970,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_column_label_targeting(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=7, user_name="ed")
+        connection.execute(users.insert(), dict(user_id=7, user_name="ed"))
 
         for s in (
             users.select().alias("foo"),
@@ -962,7 +984,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_ro_mapping_py3k(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
 
         row = result.first()
@@ -985,7 +1007,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_ro_mapping_py2k(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
 
         row = result.first()
@@ -1012,7 +1034,7 @@ class CursorResultTest(fixtures.TablesTest):
         users = self.tables.users
         addresses = self.tables.addresses
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
 
         obj = get_object(result)
@@ -1041,7 +1063,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_row_mapping_keys(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
         eq_(result.keys(), ["user_id", "user_name"])
         row = result.first()
@@ -1055,7 +1077,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_row_keys_legacy_dont_warn(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
         row = result.first()
         # DO NOT WARN DEPRECATED IN 1.x, ONLY 2.0 WARNING
@@ -1065,7 +1087,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_row_namedtuple_legacy_ok(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(users.select())
         row = result.first()
         eq_(row.user_id, 1)
@@ -1076,7 +1098,7 @@ class CursorResultTest(fixtures.TablesTest):
 
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         result = connection.execute(
             select(
                 users.c.user_id,
@@ -1093,7 +1115,7 @@ class CursorResultTest(fixtures.TablesTest):
     def test_items(self, connection):
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         r = connection.execute(users.select()).first()
         eq_(
             [(x[0].lower(), x[1]) for x in list(r._mapping.items())],
@@ -1119,9 +1141,11 @@ class CursorResultTest(fixtures.TablesTest):
 
         connection.execute(
             users.insert(),
-            dict(user_id=1, user_name="foo"),
-            dict(user_id=2, user_name="bar"),
-            dict(user_id=3, user_name="def"),
+            [
+                dict(user_id=1, user_name="foo"),
+                dict(user_id=2, user_name="bar"),
+                dict(user_id=3, user_name="def"),
+            ],
         )
 
         rows = connection.execute(
@@ -1136,7 +1160,7 @@ class CursorResultTest(fixtures.TablesTest):
         # should return values in column definition order
         users = self.tables.users
 
-        connection.execute(users.insert(), user_id=1, user_name="foo")
+        connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
         r = connection.execute(users.select(users.c.user_id == 1)).first()
         eq_(r[0], 1)
         eq_(r[1], "foo")
@@ -1174,12 +1198,14 @@ class CursorResultTest(fixtures.TablesTest):
         self.metadata.create_all(connection)
         connection.execute(
             shadowed.insert(),
-            shadow_id=1,
-            shadow_name="The Shadow",
-            parent="The Light",
-            row="Without light there is no shadow",
-            _parent="Hidden parent",
-            _row="Hidden row",
+            dict(
+                shadow_id=1,
+                shadow_name="The Shadow",
+                parent="The Light",
+                row="Without light there is no shadow",
+                _parent="Hidden parent",
+                _row="Hidden row",
+            ),
         )
         r = connection.execute(
             shadowed.select(shadowed.c.shadow_id == 1)
@@ -1254,7 +1280,8 @@ class CursorResultTest(fixtures.TablesTest):
             with engine.begin() as conn:
                 mock_rowcount.__get__ = Mock()
                 conn.execute(
-                    t.insert(), {"data": "d1"}, {"data": "d2"}, {"data": "d3"}
+                    t.insert(),
+                    [{"data": "d1"}, {"data": "d2"}, {"data": "d3"}],
                 )
 
                 eq_(len(mock_rowcount.__get__.mock_calls), 0)
diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py
index 187cf0dd02..62d9ab75ec 100644
--- a/test/sql/test_returning.py
+++ b/test/sql/test_returning.py
@@ -466,7 +466,7 @@ class KeyReturningTest(fixtures.TablesTest, AssertsExecutionResults):
     def test_insert(self, connection):
         table = self.tables.tables
         result = connection.execute(
-            table.insert().returning(table.c.foo_id), data="somedata"
+            table.insert().returning(table.c.foo_id), dict(data="somedata")
         )
         row = result.first()._mapping
         assert row[table.c.foo_id] == row["id"] == 1
diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py
index 719f8e3187..e6f7dbdaff 100644
--- a/test/sql/test_type_expressions.py
+++ b/test/sql/test_type_expressions.py
@@ -336,9 +336,11 @@ class RoundTripTestBase(object):
     def test_round_trip(self, connection):
         connection.execute(
             self.tables.test_table.insert(),
-            {"x": "X1", "y": "Y1"},
-            {"x": "X2", "y": "Y2"},
-            {"x": "X3", "y": "Y3"},
+            [
+                {"x": "X1", "y": "Y1"},
+                {"x": "X2", "y": "Y2"},
+                {"x": "X3", "y": "Y3"},
+            ],
         )
 
         # test insert coercion alone
diff --git a/test/sql/test_types.py b/test/sql/test_types.py
index 64ace87dfa..0a85414676 100644
--- a/test/sql/test_types.py
+++ b/test/sql/test_types.py
@@ -1494,7 +1494,7 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL):
         t = Table("t", self.metadata, Column("x", variant))
         t.create(connection)
 
-        connection.execute(t.insert(), x="foo")
+        connection.execute(t.insert(), dict(x="foo"))
 
         eq_(connection.scalar(select(t.c.x).where(t.c.x == "foo")), "fooUTWO")
 
@@ -1509,7 +1509,8 @@ class VariantTest(fixtures.TestBase, AssertsCompiledSQL):
         t.create(connection)
 
         connection.execute(
-            t.insert(), x=datetime.datetime(2015, 4, 18, 10, 15, 17, 4839)
+            t.insert(),
+            dict(x=datetime.datetime(2015, 4, 18, 10, 15, 17, 4839)),
         )
 
         eq_(
@@ -2418,28 +2419,34 @@ class BinaryTest(fixtures.TablesTest, AssertsExecutionResults):
         stream2 = self.load_stream("binary_data_two.dat")
         connection.execute(
             binary_table.insert(),
-            primary_id=1,
-            misc="binary_data_one.dat",
-            data=stream1,
-            data_slice=stream1[0:100],
-            pickled=testobj1,
-            mypickle=testobj3,
+            dict(
+                primary_id=1,
+                misc="binary_data_one.dat",
+                data=stream1,
+                data_slice=stream1[0:100],
+                pickled=testobj1,
+                mypickle=testobj3,
+            ),
         )
         connection.execute(
             binary_table.insert(),
-            primary_id=2,
-            misc="binary_data_two.dat",
-            data=stream2,
-            data_slice=stream2[0:99],
-            pickled=testobj2,
+            dict(
+                primary_id=2,
+                misc="binary_data_two.dat",
+                data=stream2,
+                data_slice=stream2[0:99],
+                pickled=testobj2,
+            ),
         )
         connection.execute(
             binary_table.insert(),
-            primary_id=3,
-            misc="binary_data_two.dat",
-            data=None,
-            data_slice=stream2[0:99],
-            pickled=None,
+            dict(
+                primary_id=3,
+                misc="binary_data_two.dat",
+                data=None,
+                data_slice=stream2[0:99],
+                pickled=None,
+            ),
         )
 
         for stmt in (
@@ -2475,7 +2482,7 @@ class BinaryTest(fixtures.TablesTest, AssertsExecutionResults):
         assert isinstance(expr.right.type, LargeBinary)
 
         data = os.urandom(32)
-        connection.execute(binary_table.insert(), data=data)
+        connection.execute(binary_table.insert(), dict(data=data))
         eq_(
             connection.scalar(
                 select(func.count("*"))
@@ -3299,7 +3306,7 @@ class NumericRawSQLTest(fixtures.TestBase):
     def _fixture(self, connection, metadata, type_, data):
         t = Table("t", metadata, Column("val", type_))
         metadata.create_all(connection)
-        connection.execute(t.insert(), val=data)
+        connection.execute(t.insert(), dict(val=data))
 
     @testing.fails_on("sqlite", "Doesn't provide Decimal results natively")
     @testing.provide_metadata
@@ -3379,9 +3386,11 @@ class IntervalTest(fixtures.TablesTest, AssertsExecutionResults):
         delta = datetime.timedelta(14)
         connection.execute(
             interval_table.insert(),
-            native_interval=small_delta,
-            native_interval_args=delta,
-            non_native_interval=delta,
+            dict(
+                native_interval=small_delta,
+                native_interval_args=delta,
+                non_native_interval=delta,
+            ),
         )
         row = connection.execute(interval_table.select()).first()
         eq_(row.native_interval, small_delta)
@@ -3393,9 +3402,11 @@ class IntervalTest(fixtures.TablesTest, AssertsExecutionResults):
 
         connection.execute(
             interval_table.insert(),
-            id=1,
-            native_inverval=None,
-            non_native_interval=None,
+            dict(
+                id=1,
+                native_inverval=None,
+                non_native_interval=None,
+            ),
         )
         row = connection.execute(interval_table.select()).first()
         eq_(row.native_interval, None)