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

8 files changed, 144 insertions, 16 deletions

diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py
index 2e1809b07..04ae2532b 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 6bada51dd..097c513b4 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 d055ba86e..f5325b0cb 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 ad27828a4..831f2a680 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 ba6048f07..8bdba2793 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 f4516f942..7508ee6c7 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 2021c030c..9f9525f3c 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 68db6270f..78eecdf21 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):