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 2e1809b0719255bee0c6af1b7e151a196a0d1824..04ae2532bf8e0c8b67795c44d4423bad787b19fd 100644 (file)
--- 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 6bada51dd11aa3f5e9a98a81ee8da3095ef879bc..097c513b4f2e40ecf4343d49c4b2b07534f88d41 100644 (file)
--- 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 d055ba86e70f50e4dfb28bf9f4dc2b9001e3bb68..f5325b0cb15cf015ebdaed1499d25a914592fed9 100644 (file)
--- 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 ad27828a4daec90a55db168628fec442dee95987..831f2a680c06f2a7d11cd82edb1a29ead31d9a11 100644 (file)
--- 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 ba6048f071de0907837bdcfdbb89455077a4284f..8bdba279313997d7c9e610e76397ea8398bad184 100644 (file)
--- 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 f4516f94293428dd98dfdbba0923ed2b2c739113..7508ee6c71e591561bd8d7d0e760d1d45de15b52 100644 (file)
--- 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 2021c030c4e268e321eee2eb8a026bf231c92460..9f9525f3cf5aa535aed83b79c6fc69a82a410441 100644 (file)
--- 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 68db6270f2727cfa7cca547ca43552f1b1109db8..78eecdf21c2357818844c7e1c3c7b09e3bda7ba4 100644 (file)
--- 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):