Merge "Repair inline flag"

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):