Create initial future package, RemovedIn20Warning

Reorganization of Select() is the first major element
of the 2.0 restructuring.   In order to start this we need
to first create the new Select constructor and apply legacy
elements to the old one.    This in turn necessitates
starting up the RemovedIn20Warning concept which itself
need to refer to "sqlalchemy.future", so begin to establish
this basic framework.   Additionally, update the
DML constructors with the newer no-keyword style.  Remove
the use of the "pending deprecation" and fix Query.add_column()
deprecation which was not acting as deprecated.

Fixes: #4845
Fixes: #4648
Change-Id: I0c7a22b2841a985e1c379a0bb6c94089aae6264c

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