From: Mike Bayer Date: Sat, 22 Feb 2020 15:22:18 +0000 (-0500) Subject: Repair inline flag X-Git-Tag: rel_1_4_0b1~508^2 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=ffc375d1f02205838485dd1e3e181037b2c0a580;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git Repair inline flag In 9fca5d827d we attempted to deprecate the "inline=True" flag and add a generative inline() method, however failed to include any tests and the method was implemented incorrectly such that it would get overwritten with the boolean flag immediately. Rename the internal "inline" flag to "_inline" and add test support both for the method as well as deprecated support for the flag, including a fixture addition to assert the expected value of the flag as it generally does not affect the actual compiled SQL string. Change-Id: I0450049f17f1f0d91e22d27f1a973a2b6c0e59f7 --- diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py index 2e1809b071..04ae2532bf 100644 --- a/lib/sqlalchemy/sql/compiler.py +++ b/lib/sqlalchemy/sql/compiler.py @@ -682,7 +682,7 @@ class SQLCompiler(Compiled): # compile INSERT/UPDATE defaults/sequences inlined (no pre- # execute) - self.inline = inline or getattr(statement, "inline", False) + self.inline = inline or getattr(statement, "_inline", False) self.linting = linting diff --git a/lib/sqlalchemy/sql/dml.py b/lib/sqlalchemy/sql/dml.py index 6bada51dd1..097c513b4f 100644 --- a/lib/sqlalchemy/sql/dml.py +++ b/lib/sqlalchemy/sql/dml.py @@ -628,7 +628,7 @@ class Insert(ValuesBase): self._bind = bind self.select = self.select_names = None self.include_insert_from_select_defaults = False - self.inline = inline + self._inline = inline self._returning = returning self._validate_dialect_kwargs(dialect_kw) self._return_defaults = return_defaults @@ -656,7 +656,7 @@ class Insert(ValuesBase): is now superseded by the :meth:`.Insert.inline` method. """ - self.inline = True + self._inline = True @_generative def from_select(self, names, select, include_defaults=True): @@ -715,7 +715,7 @@ class Insert(ValuesBase): ) self.select_names = names - self.inline = True + self._inline = True self.include_insert_from_select_defaults = include_defaults self.select = coercions.expect(roles.DMLSelectRole, select) @@ -869,7 +869,6 @@ class Update(ValuesBase): """ - self._preserve_parameter_order = preserve_parameter_order super(Update, self).__init__(table, values, prefixes) self._bind = bind @@ -880,7 +879,7 @@ class Update(ValuesBase): ) else: self._whereclause = None - self.inline = inline + self._inline = inline self._validate_dialect_kwargs(dialect_kw) self._return_defaults = return_defaults @@ -944,7 +943,7 @@ class Update(ValuesBase): is now superseded by the :meth:`.Update.inline` method. """ - self.inline = True + self._inline = True @_generative def where(self, whereclause): diff --git a/lib/sqlalchemy/testing/assertions.py b/lib/sqlalchemy/testing/assertions.py index d055ba86e7..f5325b0cb1 100644 --- a/lib/sqlalchemy/testing/assertions.py +++ b/lib/sqlalchemy/testing/assertions.py @@ -312,6 +312,7 @@ class AssertsCompiledSQL(object): literal_binds=False, render_postcompile=False, schema_translate_map=None, + inline_flag=None, ): if use_default_dialect: dialect = default.DefaultDialect() @@ -402,6 +403,8 @@ class AssertsCompiledSQL(object): }, check_post_param, ) + if inline_flag is not None: + eq_(c.inline, inline_flag) class ComparesTables(object): diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py index ad27828a4d..831f2a680c 100644 --- a/test/sql/test_defaults.py +++ b/test/sql/test_defaults.py @@ -460,7 +460,7 @@ class DefaultTest(fixtures.TestBase): set([t.c.col3, t.c.col5, t.c.col4, t.c.col6]), ) - r = t.insert(inline=True).execute() + r = t.insert().inline().execute() assert r.lastrow_has_defaults() eq_( set(r.context.postfetch_cols), diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py index ba6048f071..8bdba27931 100644 --- a/test/sql/test_deprecations.py +++ b/test/sql/test_deprecations.py @@ -1731,3 +1731,96 @@ class DefaultTest(fixtures.TestBase): conn.execute(table.insert().values(x=5)) eq_(conn.execute(select([table])).first(), (5, 12)) + + +class DMLTest(fixtures.TestBase, AssertsCompiledSQL): + __dialect__ = "default" + + def test_insert_inline_kw_defaults(self): + m = MetaData() + foo = Table("foo", m, Column("id", Integer)) + + t = Table( + "test", + m, + Column("col1", Integer, default=func.foo(1)), + Column( + "col2", + Integer, + default=select([func.coalesce(func.max(foo.c.id))]), + ), + ) + + with testing.expect_deprecated_20( + "The insert.inline parameter will be removed in SQLAlchemy 2.0." + ): + stmt = t.insert(inline=True, values={}) + + self.assert_compile( + stmt, + "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " + "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " + "foo))", + inline_flag=True, + ) + + def test_insert_inline_kw_default(self): + metadata = MetaData() + table = Table( + "sometable", + metadata, + Column("id", Integer, primary_key=True), + Column("foo", Integer, default=func.foobar()), + ) + + with testing.expect_deprecated_20( + "The insert.inline parameter will be removed in SQLAlchemy 2.0." + ): + stmt = table.insert(values={}, inline=True) + + self.assert_compile( + stmt, + "INSERT INTO sometable (foo) VALUES (foobar())", + inline_flag=True, + ) + + with testing.expect_deprecated_20( + "The insert.inline parameter will be removed in SQLAlchemy 2.0." + ): + stmt = table.insert(inline=True) + + self.assert_compile( + stmt, + "INSERT INTO sometable (foo) VALUES (foobar())", + params={}, + inline_flag=True, + ) + + def test_update_inline_kw_defaults(self): + m = MetaData() + foo = Table("foo", m, Column("id", Integer)) + + t = Table( + "test", + m, + Column("col1", Integer, onupdate=func.foo(1)), + Column( + "col2", + Integer, + onupdate=select([func.coalesce(func.max(foo.c.id))]), + ), + Column("col3", String(30)), + ) + + with testing.expect_deprecated_20( + "The update.inline parameter will be removed in SQLAlchemy 2.0." + ): + stmt = t.update(inline=True, values={"col3": "foo"}) + + self.assert_compile( + stmt, + "UPDATE test SET col1=foo(:foo_1), col2=(SELECT " + "coalesce(max(foo.id)) AS coalesce_1 FROM foo), " + "col3=:col3", + inline_flag=True, + ) diff --git a/test/sql/test_insert.py b/test/sql/test_insert.py index f4516f9429..7508ee6c71 100644 --- a/test/sql/test_insert.py +++ b/test/sql/test_insert.py @@ -135,10 +135,19 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): ) self.assert_compile( - t.insert(inline=True, values={}), + t.insert().values({}), "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " "foo))", + inline_flag=False, + ) + + self.assert_compile( + t.insert().inline().values({}), + "INSERT INTO test (col1, col2) VALUES (foo(:foo_1), " + "(SELECT coalesce(max(foo.id)) AS coalesce_1 FROM " + "foo))", + inline_flag=True, ) def test_generic_insert_bind_params_all_columns(self): @@ -290,14 +299,29 @@ class InsertTest(_InsertTestBase, fixtures.TablesTest, AssertsCompiledSQL): ) self.assert_compile( - table.insert(values={}, inline=True), + table.insert().values(), + "INSERT INTO sometable (foo) VALUES (foobar())", + inline_flag=False, + ) + + self.assert_compile( + table.insert(), + "INSERT INTO sometable (foo) VALUES (foobar())", + params={}, + inline_flag=False, + ) + + self.assert_compile( + table.insert().values().inline(), "INSERT INTO sometable (foo) VALUES (foobar())", + inline_flag=True, ) self.assert_compile( - table.insert(inline=True), + table.insert().inline(), "INSERT INTO sometable (foo) VALUES (foobar())", params={}, + inline_flag=True, ) def test_insert_returning_not_in_default(self): diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py index 2021c030c4..9f9525f3cf 100644 --- a/test/sql/test_insert_exec.py +++ b/test/sql/test_insert_exec.py @@ -338,7 +338,7 @@ class InsertExecTest(fixtures.TablesTest): class TableInsertTest(fixtures.TablesTest): """test for consistent insert behavior across dialects - regarding the inline=True flag, lower-case 't' tables. + regarding the inline() method, lower-case 't' tables. """ @@ -410,7 +410,7 @@ class TableInsertTest(fixtures.TablesTest): def test_uppercase_inline(self): t = self.tables.foo self._test( - t.insert(inline=True).values(id=1, data="data", x=5), + t.insert().inline().values(id=1, data="data", x=5), (1, "data", 5), inserted_primary_key=[1], ) @@ -422,7 +422,7 @@ class TableInsertTest(fixtures.TablesTest): def test_uppercase_inline_implicit(self): t = self.tables.foo self._test( - t.insert(inline=True).values(data="data", x=5), + t.insert().inline().values(data="data", x=5), (1, "data", 5), inserted_primary_key=[None], ) @@ -501,7 +501,7 @@ class TableInsertTest(fixtures.TablesTest): def test_implicit_pk_inline(self): t = self._fixture() self._test( - t.insert(inline=True).values(data="data", x=5), + t.insert().inline().values(data="data", x=5), (1, "data", 5), inserted_primary_key=[], ) diff --git a/test/sql/test_update.py b/test/sql/test_update.py index 68db6270f2..78eecdf21c 100644 --- a/test/sql/test_update.py +++ b/test/sql/test_update.py @@ -329,10 +329,19 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL): ) self.assert_compile( - t.update(inline=True, values={"col3": "foo"}), + t.update().values({"col3": "foo"}), "UPDATE test SET col1=foo(:foo_1), col2=(SELECT " "coalesce(max(foo.id)) AS coalesce_1 FROM foo), " "col3=:col3", + inline_flag=False, + ) + + self.assert_compile( + t.update().inline().values({"col3": "foo"}), + "UPDATE test SET col1=foo(:foo_1), col2=(SELECT " + "coalesce(max(foo.id)) AS coalesce_1 FROM foo), " + "col3=:col3", + inline_flag=True, ) def test_update_1(self):