Merge "Create initial future package, RemovedIn20Warning"

11 files changed, 133 insertions, 42 deletions

diff --git a/test/orm/inheritance/test_single.py b/test/orm/inheritance/test_single.py
index 25349157c..9426847ba 100644
--- a/test/orm/inheritance/test_single.py
+++ b/test/orm/inheritance/test_single.py
@@ -199,7 +199,7 @@ class SingleInheritanceTest(testing.AssertsCompiledSQL, fixtures.MappedTest):
 
         eq_(
             session.query(Manager.name)
-            .add_column(ealias.name)
+            .add_columns(ealias.name)
             .join(ealias, true())
             .all(),
             [("Tom", "Kurt"), ("Tom", "Ed")],
diff --git a/test/orm/test_deferred.py b/test/orm/test_deferred.py
index f55eefc4a..5acfa3f79 100644
--- a/test/orm/test_deferred.py
+++ b/test/orm/test_deferred.py
@@ -834,7 +834,7 @@ class DeferredOptionsTest(AssertsCompiledSQL, _fixtures.FixtureTest):
         o1 = (
             sess.query(Order)
             .order_by(Order.id)
-            .add_column(orders.c.description)
+            .add_columns(orders.c.description)
             .first()
         )[0]
 
diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py
index d5a46e9ea..cb41b384c 100644
--- a/test/orm/test_deprecations.py
+++ b/test/orm/test_deprecations.py
@@ -416,6 +416,20 @@ class DeprecatedQueryTest(_fixtures.FixtureTest, AssertsCompiledSQL):
             "subquery object."
         )
 
+    def test_invalid_column(self):
+        User = self.classes.User
+
+        s = create_session()
+        q = s.query(User.id)
+
+        with testing.expect_deprecated(r"Query.add_column\(\) is deprecated"):
+            q = q.add_column(User.name)
+
+        self.assert_compile(
+            q,
+            "SELECT users.id AS users_id, users.name AS users_name FROM users",
+        )
+
     def test_via_textasfrom_select_from(self):
         User = self.classes.User
         s = create_session()
diff --git a/test/orm/test_froms.py b/test/orm/test_froms.py
index 7195f53cb..08b68232b 100644
--- a/test/orm/test_froms.py
+++ b/test/orm/test_froms.py
@@ -252,7 +252,7 @@ class QueryCorrelatesLikeSelect(QueryTest, AssertsCompiledSQL):
         orm_subq = sess.query(u_alias).filter(u_alias.id > User.id).exists()
 
         self.assert_compile(
-            q.add_column(raw_subq),
+            q.add_columns(raw_subq),
             "SELECT anon_1.users_id AS anon_1_users_id, "
             "anon_1.users_name AS anon_1_users_name, "
             "EXISTS (SELECT * FROM users AS users_1 "
@@ -265,7 +265,7 @@ class QueryCorrelatesLikeSelect(QueryTest, AssertsCompiledSQL):
 
         # only difference is "1" vs. "*" (not sure why that is)
         self.assert_compile(
-            q.add_column(orm_subq),
+            q.add_columns(orm_subq),
             "SELECT anon_1.users_id AS anon_1_users_id, "
             "anon_1.users_name AS anon_1_users_name, "
             "EXISTS (SELECT 1 FROM users AS users_1 "
@@ -545,7 +545,7 @@ class FromSelfTest(QueryTest, AssertsCompiledSQL):
         eq_(
             sess.query(User.id)
             .from_self()
-            .add_column(func.count().label("foo"))
+            .add_columns(func.count().label("foo"))
             .group_by(User.id)
             .order_by(User.id)
             .from_self()
@@ -1835,7 +1835,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
                 sess.query(User)
                 .limit(1)
                 .options(joinedload("addresses"))
-                .add_column(User.name)
+                .add_columns(User.name)
                 .all()
             )
             eq_(results, [(User(name="jack"), "jack")])
@@ -2109,11 +2109,11 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         expected = [(u, u.name) for u in sess.query(User).all()]
 
         for add_col in (User.name, users.c.name):
-            assert sess.query(User).add_column(add_col).all() == expected
+            assert sess.query(User).add_columns(add_col).all() == expected
             sess.expunge_all()
 
         assert_raises(
-            sa_exc.ArgumentError, sess.query(User).add_column, object()
+            sa_exc.ArgumentError, sess.query(User).add_columns, object()
         )
 
     def test_add_multi_columns(self):
@@ -2124,12 +2124,12 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         sess = create_session()
 
         eq_(
-            sess.query(User.id).add_column(users).all(),
+            sess.query(User.id).add_columns(users).all(),
             [(7, 7, "jack"), (8, 8, "ed"), (9, 9, "fred"), (10, 10, "chuck")],
         )
 
     def test_multi_columns_2(self):
-        """test aliased/nonalised joins with the usage of add_column()"""
+        """test aliased/nonalised joins with the usage of add_columns()"""
 
         User, Address, addresses, users = (
             self.classes.User,
@@ -2148,7 +2148,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
             q.group_by(users)
             .order_by(User.id)
             .outerjoin("addresses")
-            .add_column(func.count(Address.id).label("count"))
+            .add_columns(func.count(Address.id).label("count"))
         )
         eq_(q.all(), expected)
         sess.expunge_all()
@@ -2159,7 +2159,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
             q.group_by(users)
             .order_by(User.id)
             .outerjoin(adalias, "addresses")
-            .add_column(func.count(adalias.id).label("count"))
+            .add_columns(func.count(adalias.id).label("count"))
         )
         eq_(q.all(), expected)
         sess.expunge_all()
@@ -2173,7 +2173,9 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
             .order_by(User.id)
         )
         q = sess.query(User)
-        result = q.add_column(s.selected_columns.count).from_statement(s).all()
+        result = (
+            q.add_columns(s.selected_columns.count).from_statement(s).all()
+        )
         assert result == expected
 
     def test_raw_columns(self):
@@ -2196,8 +2198,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         q = (
             create_session()
             .query(User)
-            .add_column(func.count(adalias.c.id))
-            .add_column(("Name:" + users.c.name))
+            .add_columns(func.count(adalias.c.id), ("Name:" + users.c.name))
             .outerjoin(adalias, "addresses")
             .group_by(users)
             .order_by(users.c.id)
@@ -2218,8 +2219,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         )
         q = create_session().query(User)
         result = (
-            q.add_column(s.selected_columns.count)
-            .add_column(s.selected_columns.concat)
+            q.add_columns(s.selected_columns.count, s.selected_columns.concat)
             .from_statement(s)
             .all()
         )
@@ -2231,8 +2231,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         q = (
             create_session()
             .query(User)
-            .add_column(func.count(addresses.c.id))
-            .add_column(("Name:" + users.c.name))
+            .add_columns(func.count(addresses.c.id), ("Name:" + users.c.name))
             .select_entity_from(users.outerjoin(addresses))
             .group_by(users)
             .order_by(users.c.id)
@@ -2244,8 +2243,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         q = (
             create_session()
             .query(User)
-            .add_column(func.count(addresses.c.id))
-            .add_column(("Name:" + users.c.name))
+            .add_columns(func.count(addresses.c.id), ("Name:" + users.c.name))
             .outerjoin("addresses")
             .group_by(users)
             .order_by(users.c.id)
@@ -2257,8 +2255,7 @@ class MixedEntitiesTest(QueryTest, AssertsCompiledSQL):
         q = (
             create_session()
             .query(User)
-            .add_column(func.count(adalias.c.id))
-            .add_column(("Name:" + users.c.name))
+            .add_columns(func.count(adalias.c.id), ("Name:" + users.c.name))
             .outerjoin(adalias, "addresses")
             .group_by(users)
             .order_by(users.c.id)
diff --git a/test/orm/test_query.py b/test/orm/test_query.py
index 55809ad38..882255cc8 100644
--- a/test/orm/test_query.py
+++ b/test/orm/test_query.py
@@ -1045,14 +1045,14 @@ class InvalidGenerationsTest(QueryTest, AssertsCompiledSQL):
 
         s = create_session()
         q = s.query(User)
-        assert_raises(sa_exc.ArgumentError, q.add_column, object())
+        assert_raises(sa_exc.ArgumentError, q.add_columns, object())
 
     def test_invalid_column_tuple(self):
         User = self.classes.User
 
         s = create_session()
         q = s.query(User)
-        assert_raises(sa_exc.ArgumentError, q.add_column, (1, 1))
+        assert_raises(sa_exc.ArgumentError, q.add_columns, (1, 1))
 
     def test_distinct(self):
         """test that a distinct() call is not valid before 'clauseelement'
diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py
index b53acf61e..a7e9916cd 100644
--- a/test/sql/test_compiler.py
+++ b/test/sql/test_compiler.py
@@ -963,7 +963,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL):
         s = select(
             [], exists([1], table2.c.otherid == table1.c.myid), from_obj=table1
         )
-        s.column.non_generative(s, table1)
+        s.add_columns.non_generative(s, table1)
         self.assert_compile(
             s,
             "SELECT mytable.myid, mytable.name, "
@@ -4932,7 +4932,7 @@ class ResultMapTest(fixtures.TestBase):
         orig = [t.c.x, t.c.y, l1, l2, l3]
         stmt = select(orig)
         wrapped = stmt._generate()
-        wrapped = wrapped.column(
+        wrapped = wrapped.add_columns(
             func.ROW_NUMBER().over(order_by=t.c.z)
         ).alias()
 
@@ -4968,7 +4968,7 @@ class ResultMapTest(fixtures.TestBase):
         eq_(len(stmt._columns_plus_names), 7)
 
         wrapped = stmt._generate()
-        wrapped = wrapped.column(
+        wrapped = wrapped.add_columns(
             func.ROW_NUMBER().over(order_by=t.c.z)
         ).alias()
 
diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py
index 4e88dcdb8..b2b1f470b 100644
--- a/test/sql/test_deprecations.py
+++ b/test/sql/test_deprecations.py
@@ -132,6 +132,17 @@ class DeprecationWarningsTest(fixtures.TestBase, AssertsCompiledSQL):
         ):
             self.assert_compile(or_(and_()), "")
 
+    def test_fromclause_count(self):
+        with testing.expect_deprecated(
+            r"The FromClause.count\(\) method is deprecated, and will be "
+            r"removed in a future release."
+        ):
+            self.assert_compile(
+                table("q", column("x")).count(),
+                "SELECT count(q.x) AS tbl_row_count FROM q",
+                dialect="default",
+            )
+
 
 class ConvertUnicodeDeprecationTest(fixtures.TestBase):
 
@@ -645,6 +656,16 @@ class SelectableTest(fixtures.TestBase, AssertsCompiledSQL):
             "SELECT anon_1.a FROM (SELECT 1 AS a ORDER BY 1) AS anon_1",
         )
 
+    def test_column(self):
+        stmt = select([column("x")])
+        with testing.expect_deprecated(
+            r"The Select.column\(\) method is deprecated and will be "
+            "removed in a future release."
+        ):
+            stmt = stmt.column(column("q"))
+
+        self.assert_compile(stmt, "SELECT x, q")
+
     def test_append_column_after_replace_selectable(self):
         basesel = select([literal_column("1").label("a")])
         tojoin = select(
diff --git a/test/sql/test_external_traversal.py b/test/sql/test_external_traversal.py
index 7001f757f..84d99d886 100644
--- a/test/sql/test_external_traversal.py
+++ b/test/sql/test_external_traversal.py
@@ -1831,7 +1831,7 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL):
         self.assert_compile(
             s, "SELECT table1.col1, table1.col2, " "table1.col3 FROM table1"
         )
-        select_copy = s.column(column("yyy"))
+        select_copy = s.add_columns(column("yyy"))
         self.assert_compile(
             select_copy,
             "SELECT table1.col1, table1.col2, " "table1.col3, yyy FROM table1",
diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py
index c3655efd2..cc2df16a9 100644
--- a/test/sql/test_selectable.py
+++ b/test/sql/test_selectable.py
@@ -346,8 +346,10 @@ class SelectableTest(
         sel = select([literal_column("1").label("a")])
         eq_(list(sel.selected_columns.keys()), ["a"])
         cloned = visitors.ReplacingCloningVisitor().traverse(sel)
-        cloned.column.non_generative(cloned, literal_column("2").label("b"))
-        cloned.column.non_generative(cloned, func.foo())
+        cloned.add_columns.non_generative(
+            cloned, literal_column("2").label("b")
+        )
+        cloned.add_columns.non_generative(cloned, func.foo())
         eq_(list(cloned.selected_columns.keys()), ["a", "b", "foo()"])
 
     def test_clone_col_list_changes_then_proxy(self):
@@ -355,7 +357,7 @@ class SelectableTest(
         stmt = select([t.c.q]).subquery()
 
         def add_column(stmt):
-            stmt.column.non_generative(stmt, t.c.p)
+            stmt.add_columns.non_generative(stmt, t.c.p)
 
         stmt2 = visitors.cloned_traverse(stmt, {}, {"select": add_column})
         eq_(list(stmt.c.keys()), ["q"])
@@ -366,7 +368,7 @@ class SelectableTest(
         stmt = select([t.c.q]).subquery()
 
         def add_column(stmt):
-            stmt.column.non_generative(stmt, t.c.p)
+            stmt.add_columns.non_generative(stmt, t.c.p)
 
         stmt2 = visitors.cloned_traverse(stmt, {}, {"select": add_column})
         eq_(list(stmt.c.keys()), ["q"])
@@ -396,7 +398,7 @@ class SelectableTest(
             "JOIN (SELECT 1 AS a, 2 AS b) AS joinfrom "
             "ON basefrom.a = joinfrom.a",
         )
-        replaced.column.non_generative(replaced, joinfrom.c.b)
+        replaced.add_columns.non_generative(replaced, joinfrom.c.b)
         self.assert_compile(
             replaced,
             "SELECT basefrom.a, joinfrom.b FROM (SELECT 1 AS a) AS basefrom "
@@ -859,7 +861,7 @@ class SelectableTest(
 
     def test_join(self):
         a = join(table1, table2)
-        print(str(a.select(use_labels=True)))
+        print(str(a.select().apply_labels()))
         b = table2.alias("b")
         j = join(a, b)
         print(str(j))
@@ -874,7 +876,7 @@ class SelectableTest(
         self.assert_(criterion.compare(j.onclause))
 
     def test_subquery_labels_join(self):
-        a = table1.select(use_labels=True).subquery()
+        a = table1.select().apply_labels().subquery()
         j = join(a, table2)
 
         criterion = a.c.table1_col1 == table2.c.col2
@@ -1580,7 +1582,7 @@ class JoinConditionTest(fixtures.TestBase, AssertsCompiledSQL):
         t1t2 = t1.join(t2)
         t2t3 = t2.join(t3)
 
-        st2t3 = t2t3.select(use_labels=True).subquery()
+        st2t3 = t2t3.select().apply_labels().subquery()
         j = t1t2.join(st2t3)
         assert j.onclause.compare(t2.c.id == st2t3.c.t3_t2id)
         self.assert_compile(
@@ -2016,7 +2018,8 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
         pjoin = (
             people.outerjoin(engineers)
             .outerjoin(managers)
-            .select(use_labels=True)
+            .select()
+            .apply_labels()
             .alias("pjoin")
         )
         eq_(
diff --git a/test/sql/test_text.py b/test/sql/test_text.py
index ae4be65ad..58de41709 100644
--- a/test/sql/test_text.py
+++ b/test/sql/test_text.py
@@ -91,8 +91,7 @@ class SelectCompositionTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_select_composition_two(self):
         s = select()
-        s = s.column(column("column1"))
-        s = s.column(column("column2"))
+        s = s.add_columns(column("column1"), column("column2"))
         s = s.where(text("column1=12"))
         s = s.where(text("column2=19"))
         s = s.order_by("column1")
diff --git a/test/sql/test_update.py b/test/sql/test_update.py
index 0313db832..68db6270f 100644
--- a/test/sql/test_update.py
+++ b/test/sql/test_update.py
@@ -505,7 +505,7 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL):
             column_keys=["j"],
         )
 
-    def test_update_ordered_parameters_1(self):
+    def test_update_ordered_parameters_oldstyle_1(self):
         table1 = self.tables.mytable
 
         # Confirm that we can pass values as list value pairs
@@ -534,7 +534,35 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL):
             "mytable.name = :param_2 || mytable.name || :param_3",
         )
 
-    def test_update_ordered_parameters_2(self):
+    def test_update_ordered_parameters_newstyle_1(self):
+        table1 = self.tables.mytable
+
+        # Confirm that we can pass values as list value pairs
+        # note these are ordered *differently* from table.c
+        values = [
+            (table1.c.name, table1.c.name + "lala"),
+            (table1.c.myid, func.do_stuff(table1.c.myid, literal("hoho"))),
+        ]
+        self.assert_compile(
+            update(table1)
+            .where(
+                (table1.c.myid == func.hoho(4))
+                & (
+                    table1.c.name
+                    == literal("foo") + table1.c.name + literal("lala")
+                )
+            )
+            .ordered_values(*values),
+            "UPDATE mytable "
+            "SET "
+            "name=(mytable.name || :name_1), "
+            "myid=do_stuff(mytable.myid, :param_1) "
+            "WHERE "
+            "mytable.myid = hoho(:hoho_1) AND "
+            "mytable.name = :param_2 || mytable.name || :param_3",
+        )
+
+    def test_update_ordered_parameters_oldstyle_2(self):
         table1 = self.tables.mytable
 
         # Confirm that we can pass values as list value pairs
@@ -564,6 +592,35 @@ class UpdateTest(_UpdateFromTestBase, fixtures.TablesTest, AssertsCompiledSQL):
             "mytable.name = :param_2 || mytable.name || :param_3",
         )
 
+    def test_update_ordered_parameters_newstyle_2(self):
+        table1 = self.tables.mytable
+
+        # Confirm that we can pass values as list value pairs
+        # note these are ordered *differently* from table.c
+        values = [
+            (table1.c.name, table1.c.name + "lala"),
+            ("description", "some desc"),
+            (table1.c.myid, func.do_stuff(table1.c.myid, literal("hoho"))),
+        ]
+        self.assert_compile(
+            update(
+                table1,
+                (table1.c.myid == func.hoho(4))
+                & (
+                    table1.c.name
+                    == literal("foo") + table1.c.name + literal("lala")
+                ),
+            ).ordered_values(*values),
+            "UPDATE mytable "
+            "SET "
+            "name=(mytable.name || :name_1), "
+            "description=:description, "
+            "myid=do_stuff(mytable.myid, :param_1) "
+            "WHERE "
+            "mytable.myid = hoho(:hoho_1) AND "
+            "mytable.name = :param_2 || mytable.name || :param_3",
+        )
+
     def test_update_ordered_parameters_fire_onupdate(self):
         table = self.tables.update_w_default