Modernize tests - dml_values

Change-Id: Ida86ed40c43d91813151621b847376976773a5f9

diff --git a/lib/sqlalchemy/testing/warnings.py b/lib/sqlalchemy/testing/warnings.py
index 39dc7da58db44f745cd5db87e608566d37ec562d..f9d90179c8ac384d6b2f64179596ba1fb89f705b 100644 (file)
--- a/lib/sqlalchemy/testing/warnings.py
+++ b/lib/sqlalchemy/testing/warnings.py
@@ -76,8 +76,6 @@ def setup_filters():
         #
         # DML
         #
-        r"The (?:insert|update).values parameter will be removed in "
-        "SQLAlchemy 2.0.",
         r"The update.preserve_parameter_order parameter will be removed in "
         "SQLAlchemy 2.0.",
         r"Passing dialect keyword arguments directly to the "

diff --git a/test/dialect/mssql/test_compiler.py b/test/dialect/mssql/test_compiler.py
index c512ae44182b541c936ae1cd984f0bdf0d053dbe..6afd90e87f8437fd528ec694b5381eca22d056f0 100644 (file)
--- a/test/dialect/mssql/test_compiler.py
+++ b/test/dialect/mssql/test_compiler.py
@@ -864,15 +864,17 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             column("name", String(128)),
             column("description", String(128)),
         )
-        u = update(table1, values=dict(name="foo")).returning(
-            table1.c.myid, table1.c.name
+        u = (
+            update(table1)
+            .values(dict(name="foo"))
+            .returning(table1.c.myid, table1.c.name)
         )
         self.assert_compile(
             u,
             "UPDATE mytable SET name=:name OUTPUT "
             "inserted.myid, inserted.name",
         )
-        u = update(table1, values=dict(name="foo")).returning(table1)
+        u = update(table1).values(dict(name="foo")).returning(table1)
         self.assert_compile(
             u,
             "UPDATE mytable SET name=:name OUTPUT "
@@ -880,7 +882,8 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "inserted.description",
         )
         u = (
-            update(table1, values=dict(name="foo"))
+            update(table1)
+            .values(dict(name="foo"))
             .returning(table1)
             .where(table1.c.name == "bar")
         )
@@ -891,8 +894,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "inserted.description WHERE mytable.name = "
             ":name_1",
         )
-        u = update(table1, values=dict(name="foo")).returning(
-            func.length(table1.c.name)
+        u = (
+            update(table1)
+            .values(dict(name="foo"))
+            .returning(func.length(table1.c.name))
         )
         self.assert_compile(
             u,
@@ -929,8 +934,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             column("name", String(128)),
             column("description", String(128)),
         )
-        i = insert(table1, values=dict(name="foo")).returning(
-            table1.c.myid, table1.c.name
+        i = (
+            insert(table1)
+            .values(dict(name="foo"))
+            .returning(table1.c.myid, table1.c.name)
         )
         self.assert_compile(
             i,
@@ -938,15 +945,17 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "inserted.myid, inserted.name VALUES "
             "(:name)",
         )
-        i = insert(table1, values=dict(name="foo")).returning(table1)
+        i = insert(table1).values(dict(name="foo")).returning(table1)
         self.assert_compile(
             i,
             "INSERT INTO mytable (name) OUTPUT "
             "inserted.myid, inserted.name, "
             "inserted.description VALUES (:name)",
         )
-        i = insert(table1, values=dict(name="foo")).returning(
-            func.length(table1.c.name)
+        i = (
+            insert(table1)
+            .values(dict(name="foo"))
+            .returning(func.length(table1.c.name))
         )
         self.assert_compile(
             i,

diff --git a/test/dialect/mssql/test_sequence.py b/test/dialect/mssql/test_sequence.py
index 44a8f402072edcbf6f46dee59ab6656bb92b00ee..5afe9c075fe61847b67da6765544df27540bef9d 100644 (file)
--- a/test/dialect/mssql/test_sequence.py
+++ b/test/dialect/mssql/test_sequence.py
@@ -55,18 +55,18 @@ class SequenceTest(fixtures.TablesTest):
 
     def test_int_seq(self, connection):
         t = self.tables.int_seq_t
-        connection.execute(t.insert({"txt": "int_seq test"}))
+        connection.execute(t.insert().values({"txt": "int_seq test"}))
         result = connection.scalar(select(t.c.id))
         eq_(result, 1)
 
     def test_bigint_seq(self, connection):
         t = self.tables.bigint_seq_t
-        connection.execute(t.insert({"txt": "bigint_seq test"}))
+        connection.execute(t.insert().values({"txt": "bigint_seq test"}))
         result = connection.scalar(select(t.c.id))
         eq_(result, 3000000000)
 
     def test_decimal_seq(self, connection):
         t = self.tables.decimal_seq_t
-        connection.execute(t.insert({"txt": "decimal_seq test"}))
+        connection.execute(t.insert().values({"txt": "decimal_seq test"}))
         result = connection.scalar(select(t.c.id))
         eq_(result, Decimal("3000000000"))

diff --git a/test/dialect/mysql/test_compiler.py b/test/dialect/mysql/test_compiler.py
index 6929d7d4e889495ff7679404c7a609fc82ce4cd7..c6c3bf99d50d8fcd1170b5e24489d198c6b8537e 100644 (file)
--- a/test/dialect/mysql/test_compiler.py
+++ b/test/dialect/mysql/test_compiler.py
@@ -575,7 +575,7 @@ class SQLTest(fixtures.TestBase, AssertsCompiledSQL):
         t = sql.table("t", sql.column("col1"), sql.column("col2"))
 
         self.assert_compile(
-            t.update(values={"col1": 123}), "UPDATE t SET col1=%s"
+            t.update().values({"col1": 123}), "UPDATE t SET col1=%s"
         )
         self.assert_compile(
             t.update()

diff --git a/test/dialect/mysql/test_on_duplicate.py b/test/dialect/mysql/test_on_duplicate.py
index dc86aaeb05d486e0d6ca842872f714f6ca8062cb..65d5b8364e7df44ac00101fdcbe174b91f5e01de 100644 (file)
--- a/test/dialect/mysql/test_on_duplicate.py
+++ b/test/dialect/mysql/test_on_duplicate.py
@@ -30,18 +30,18 @@ class OnDuplicateTest(fixtures.TablesTest):
     def test_bad_args(self):
         assert_raises(
             ValueError,
-            insert(self.tables.foos, values={}).on_duplicate_key_update,
+            insert(self.tables.foos).values({}).on_duplicate_key_update,
         )
         assert_raises(
             exc.ArgumentError,
-            insert(self.tables.foos, values={}).on_duplicate_key_update,
+            insert(self.tables.foos).values({}).on_duplicate_key_update,
             {"id": 1, "bar": "b"},
             id=1,
             bar="b",
         )
         assert_raises(
             exc.ArgumentError,
-            insert(self.tables.foos, values={}).on_duplicate_key_update,
+            insert(self.tables.foos).values({}).on_duplicate_key_update,
             {"id": 1, "bar": "b"},
             {"id": 2, "bar": "baz"},
         )
@@ -49,7 +49,7 @@ class OnDuplicateTest(fixtures.TablesTest):
     def test_on_duplicate_key_update_multirow(self, connection):
         foos = self.tables.foos
         conn = connection
-        conn.execute(insert(foos, dict(id=1, bar="b", baz="bz")))
+        conn.execute(insert(foos).values(dict(id=1, bar="b", baz="bz")))
         stmt = insert(foos).values([dict(id=1, bar="ab"), dict(id=2, bar="b")])
         stmt = stmt.on_duplicate_key_update(bar=stmt.inserted.bar)
 
@@ -66,7 +66,7 @@ class OnDuplicateTest(fixtures.TablesTest):
     def test_on_duplicate_key_update_singlerow(self, connection):
         foos = self.tables.foos
         conn = connection
-        conn.execute(insert(foos, dict(id=1, bar="b", baz="bz")))
+        conn.execute(insert(foos).values(dict(id=1, bar="b", baz="bz")))
         stmt = insert(foos).values(dict(id=2, bar="b"))
         stmt = stmt.on_duplicate_key_update(bar=stmt.inserted.bar)
 
@@ -82,7 +82,7 @@ class OnDuplicateTest(fixtures.TablesTest):
     def test_on_duplicate_key_update_null_multirow(self, connection):
         foos = self.tables.foos
         conn = connection
-        conn.execute(insert(foos, dict(id=1, bar="b", baz="bz")))
+        conn.execute(insert(foos).values(dict(id=1, bar="b", baz="bz")))
         stmt = insert(foos).values([dict(id=1, bar="ab"), dict(id=2, bar="b")])
         stmt = stmt.on_duplicate_key_update(updated_once=None)
         result = conn.execute(stmt)
@@ -97,7 +97,7 @@ class OnDuplicateTest(fixtures.TablesTest):
     def test_on_duplicate_key_update_expression_multirow(self, connection):
         foos = self.tables.foos
         conn = connection
-        conn.execute(insert(foos, dict(id=1, bar="b", baz="bz")))
+        conn.execute(insert(foos).values(dict(id=1, bar="b", baz="bz")))
         stmt = insert(foos).values([dict(id=1, bar="ab"), dict(id=2, bar="b")])
         stmt = stmt.on_duplicate_key_update(
             bar=func.concat(stmt.inserted.bar, "_foo")
@@ -113,8 +113,7 @@ class OnDuplicateTest(fixtures.TablesTest):
         foos = self.tables.foos
         conn = connection
         conn.execute(
-            insert(
-                foos,
+            insert(foos).values(
                 [
                     dict(id=1, bar="b", baz="bz"),
                     dict(id=2, bar="b", baz="bz2"),

diff --git a/test/dialect/postgresql/test_compiler.py b/test/dialect/postgresql/test_compiler.py
index cd360c2d4d5347745b3715ec8e36c8f976b5bcdc..d2c81e63f8da02c825b1913f01fab53922746e5a 100644 (file)
--- a/test/dialect/postgresql/test_compiler.py
+++ b/test/dialect/postgresql/test_compiler.py
@@ -129,8 +129,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             column("name", String(128)),
             column("description", String(128)),
         )
-        u = update(table1, values=dict(name="foo")).returning(
-            table1.c.myid, table1.c.name
+        u = (
+            update(table1)
+            .values(dict(name="foo"))
+            .returning(table1.c.myid, table1.c.name)
         )
         self.assert_compile(
             u,
@@ -138,7 +140,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "RETURNING mytable.myid, mytable.name",
             dialect=dialect,
         )
-        u = update(table1, values=dict(name="foo")).returning(table1)
+        u = update(table1).values(dict(name="foo")).returning(table1)
         self.assert_compile(
             u,
             "UPDATE mytable SET name=%(name)s "
@@ -146,8 +148,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "mytable.description",
             dialect=dialect,
         )
-        u = update(table1, values=dict(name="foo")).returning(
-            func.length(table1.c.name)
+        u = (
+            update(table1)
+            .values(dict(name="foo"))
+            .returning(func.length(table1.c.name))
         )
         self.assert_compile(
             u,
@@ -165,8 +169,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             column("description", String(128)),
         )
 
-        i = insert(table1, values=dict(name="foo")).returning(
-            table1.c.myid, table1.c.name
+        i = (
+            insert(table1)
+            .values(dict(name="foo"))
+            .returning(table1.c.myid, table1.c.name)
         )
         self.assert_compile(
             i,
@@ -175,7 +181,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "mytable.name",
             dialect=dialect,
         )
-        i = insert(table1, values=dict(name="foo")).returning(table1)
+        i = insert(table1).values(dict(name="foo")).returning(table1)
         self.assert_compile(
             i,
             "INSERT INTO mytable (name) VALUES "
@@ -183,8 +189,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             "mytable.name, mytable.description",
             dialect=dialect,
         )
-        i = insert(table1, values=dict(name="foo")).returning(
-            func.length(table1.c.name)
+        i = (
+            insert(table1)
+            .values(dict(name="foo"))
+            .returning(func.length(table1.c.name))
         )
         self.assert_compile(
             i,
@@ -1742,7 +1750,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
         )
         self.assert_compile(stmt, expected)
 
-        stmt = update(tbl1, values=dict(id=1))
+        stmt = update(tbl1).values(dict(id=1))
         stmt = stmt.with_hint("ONLY", dialect_name="postgresql")
         expected = "UPDATE ONLY testtbl1 SET id=%(id)s"
         self.assert_compile(stmt, expected)
@@ -2240,9 +2248,11 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_do_nothing_no_target(self):
 
-        i = insert(
-            self.table1, values=dict(name="foo")
-        ).on_conflict_do_nothing()
+        i = (
+            insert(self.table1)
+            .values(dict(name="foo"))
+            .on_conflict_do_nothing()
+        )
         self.assert_compile(
             i,
             "INSERT INTO mytable (name) VALUES "
@@ -2251,9 +2261,11 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_do_nothing_index_elements_target(self):
 
-        i = insert(
-            self.table1, values=dict(name="foo")
-        ).on_conflict_do_nothing(index_elements=["myid"])
+        i = (
+            insert(self.table1)
+            .values(dict(name="foo"))
+            .on_conflict_do_nothing(index_elements=["myid"])
+        )
         self.assert_compile(
             i,
             "INSERT INTO mytable (name) VALUES "
@@ -2342,7 +2354,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_str_index_elements_target_two(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             index_elements=["myid"], set_=dict(name=i.excluded.name)
         )
@@ -2354,7 +2366,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_col_index_elements_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             index_elements=[self.table1.c.myid],
             set_=dict(name=i.excluded.name),
@@ -2367,7 +2379,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_unnamed_pk_constraint_target(self):
-        i = insert(self.table_with_metadata, values=dict(myid=1, name="foo"))
+        i = insert(self.table_with_metadata).values(dict(myid=1, name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.table_with_metadata.primary_key,
             set_=dict(name=i.excluded.name),
@@ -2380,7 +2392,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_pk_constraint_index_elements_target(self):
-        i = insert(self.table_with_metadata, values=dict(myid=1, name="foo"))
+        i = insert(self.table_with_metadata).values(dict(myid=1, name="foo"))
         i = i.on_conflict_do_update(
             index_elements=self.table_with_metadata.primary_key,
             set_=dict(name=i.excluded.name),
@@ -2393,7 +2405,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_named_unique_constraint_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.unique_constr, set_=dict(myid=i.excluded.myid)
         )
@@ -2405,7 +2417,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_string_constraint_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.unique_constr.name, set_=dict(myid=i.excluded.myid)
         )
@@ -2418,7 +2430,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_do_nothing_quoted_string_constraint_target(self):
         """test #6696"""
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_nothing(constraint="Some Constraint Name")
         self.assert_compile(
             i,
@@ -2442,7 +2454,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
             uq,
         )
 
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
 
         i = i.on_conflict_do_nothing(constraint=uq)
         self.assert_compile(
@@ -2455,7 +2467,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_do_nothing_quoted_named_constraint_target(self):
         """test #6696"""
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         unique_constr = UniqueConstraint(
             self.table1.c.myid, name="Some Constraint Name"
         )
@@ -2468,7 +2480,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_index_elements_where_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             index_elements=self.goofy_index.expressions,
             index_where=self.goofy_index.dialect_options["postgresql"][
@@ -2485,9 +2497,8 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_index_elements_where_target_multivalues(self):
-        i = insert(
-            self.table1,
-            values=[dict(name="foo"), dict(name="bar"), dict(name="bat")],
+        i = insert(self.table1).values(
+            [dict(name="foo"), dict(name="bar"), dict(name="bat")],
         )
         i = i.on_conflict_do_update(
             index_elements=self.goofy_index.expressions,
@@ -2512,7 +2523,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_unnamed_index_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
 
         unnamed_goofy = Index(
             None, self.table1.c.name, postgresql_where=self.table1.c.name > "m"
@@ -2530,7 +2541,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_unnamed_exclude_constraint_target(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.excl_constr_anon, set_=dict(name=i.excluded.name)
         )
@@ -2543,7 +2554,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_add_whereclause(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.excl_constr_anon,
             set_=dict(name=i.excluded.name),
@@ -2563,7 +2574,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_add_whereclause_references_excluded(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = i.on_conflict_do_update(
             constraint=self.excl_constr_anon,
             set_=dict(name=i.excluded.name),
@@ -2579,7 +2590,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_do_update_additional_colnames(self):
-        i = insert(self.table1, values=dict(name="bar"))
+        i = insert(self.table1).values(dict(name="bar"))
         i = i.on_conflict_do_update(
             constraint=self.excl_constr_anon,
             set_=dict(name="somename", unknown="unknown"),
@@ -2604,7 +2615,7 @@ class InsertOnConflictTest(fixtures.TestBase, AssertsCompiledSQL):
             )
 
     def test_on_conflict_as_cte(self):
-        i = insert(self.table1, values=dict(name="foo"))
+        i = insert(self.table1).values(dict(name="foo"))
         i = (
             i.on_conflict_do_update(
                 constraint=self.excl_constr_anon,

diff --git a/test/ext/test_horizontal_shard.py b/test/ext/test_horizontal_shard.py
index 76e94918a8bfc5567f5042a7cb7b094c1dd6ecf1..2df955037a35c6a8e6a477582437d87b607ce4e5 100644 (file)
--- a/test/ext/test_horizontal_shard.py
+++ b/test/ext/test_horizontal_shard.py
@@ -54,7 +54,9 @@ class ShardTest(object):
 
             with db1.begin() as c:
                 nextid = c.execute(ids.select().with_for_update()).scalar()
-                c.execute(ids.update(values={ids.c.nextid: ids.c.nextid + 1}))
+                c.execute(
+                    ids.update().values({ids.c.nextid: ids.c.nextid + 1})
+                )
                 return nextid
 
         weather_locations = Table(

diff --git a/test/orm/test_expire.py b/test/orm/test_expire.py
index 497dbdb0377f8d987a64fbfb0956bbeb95080d90..6c6c795b1a9e6bb16097916b5a1a772e8aba8657 100644 (file)
--- a/test/orm/test_expire.py
+++ b/test/orm/test_expire.py
@@ -69,7 +69,7 @@ class ExpireTest(_fixtures.FixtureTest):
         sess.flush()
         # change the value in the DB
         sess.execute(
-            users.update(values=dict(name="jack")).where(users.c.id == 7)
+            users.update().values(dict(name="jack")).where(users.c.id == 7)
         )
         sess.expire(u)
         # object isn't refreshed yet, using dict to bypass trigger

diff --git a/test/orm/test_naturalpks.py b/test/orm/test_naturalpks.py
index 4c2e84208d6eea7617e1e9ca430846674cc0a33b..422b72bb3625cb081322fdf4d8fa52181e010ba7 100644 (file)
--- a/test/orm/test_naturalpks.py
+++ b/test/orm/test_naturalpks.py
@@ -144,7 +144,7 @@ class NaturalPKTest(fixtures.MappedTest):
         assert sess.query(User).get("jack") is u1
 
         sess.execute(
-            users.update(values={User.username: "jack"}), dict(username="ed")
+            users.update().values({User.username: "jack"}), dict(username="ed")
         )
 
         # expire/refresh works off of primary key.  the PK is gone