Merge "Add future=True to create_engine/Session; unify select()"

1 files changed, 226 insertions, 256 deletions

diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py
index d53ee3385..55875632a 100644
--- a/test/sql/test_selectable.py
+++ b/test/sql/test_selectable.py
@@ -88,11 +88,9 @@ class SelectableTest(
         # same column three times
 
         s = select(
-            [
-                table1.c.col1.label("c2"),
-                table1.c.col1,
-                table1.c.col1.label("c1"),
-            ]
+            table1.c.col1.label("c2"),
+            table1.c.col1,
+            table1.c.col1.label("c1"),
         ).subquery()
 
         # this tests the same thing as
@@ -104,10 +102,10 @@ class SelectableTest(
         assert s.corresponding_column(s.c.c1) is s.c.c1
 
     def test_labeled_select_twice(self):
-        scalar_select = select([table1.c.col1]).label("foo")
+        scalar_select = select(table1.c.col1).label("foo")
 
-        s1 = select([scalar_select])
-        s2 = select([scalar_select, scalar_select])
+        s1 = select(scalar_select)
+        s2 = select(scalar_select, scalar_select)
 
         eq_(
             s1.selected_columns.foo.proxy_set,
@@ -130,10 +128,10 @@ class SelectableTest(
         )
 
     def test_labeled_subquery_twice(self):
-        scalar_select = select([table1.c.col1]).label("foo")
+        scalar_select = select(table1.c.col1).label("foo")
 
-        s1 = select([scalar_select]).subquery()
-        s2 = select([scalar_select, scalar_select]).subquery()
+        s1 = select(scalar_select).subquery()
+        s2 = select(scalar_select, scalar_select).subquery()
 
         eq_(
             s1.c.foo.proxy_set,
@@ -148,10 +146,10 @@ class SelectableTest(
         assert s2.corresponding_column(scalar_select) is s2.c.foo
 
     def test_labels_name_w_separate_key(self):
-        label = select([table1.c.col1]).label("foo")
+        label = select(table1.c.col1).label("foo")
         label.key = "bar"
 
-        s1 = select([label])
+        s1 = select(label)
         assert s1.corresponding_column(label) is s1.selected_columns.bar
 
         # renders as foo
@@ -160,10 +158,10 @@ class SelectableTest(
         )
 
     def test_labels_anon_w_separate_key(self):
-        label = select([table1.c.col1]).label(None)
+        label = select(table1.c.col1).label(None)
         label.key = "bar"
 
-        s1 = select([label])
+        s1 = select(label)
 
         # .bar is there
         assert s1.corresponding_column(label) is s1.selected_columns.bar
@@ -174,14 +172,14 @@ class SelectableTest(
         )
 
     def test_labels_anon_w_separate_key_subquery(self):
-        label = select([table1.c.col1]).label(None)
+        label = select(table1.c.col1).label(None)
         label.key = label._key_label = "bar"
 
-        s1 = select([label])
+        s1 = select(label)
 
         subq = s1.subquery()
 
-        s2 = select([subq]).where(subq.c.bar > 5)
+        s2 = select(subq).where(subq.c.bar > 5)
         self.assert_compile(
             s2,
             "SELECT anon_2.anon_1 FROM (SELECT (SELECT table1.col1 "
@@ -191,14 +189,14 @@ class SelectableTest(
         )
 
     def test_labels_anon_generate_binds_subquery(self):
-        label = select([table1.c.col1]).label(None)
+        label = select(table1.c.col1).label(None)
         label.key = label._key_label = "bar"
 
-        s1 = select([label])
+        s1 = select(label)
 
         subq = s1.subquery()
 
-        s2 = select([subq]).where(subq.c[0] > 5)
+        s2 = select(subq).where(subq.c[0] > 5)
         self.assert_compile(
             s2,
             "SELECT anon_2.anon_1 FROM (SELECT (SELECT table1.col1 "
@@ -208,20 +206,20 @@ class SelectableTest(
         )
 
     def test_select_label_grouped_still_corresponds(self):
-        label = select([table1.c.col1]).label("foo")
+        label = select(table1.c.col1).label("foo")
         label2 = label.self_group()
 
-        s1 = select([label])
-        s2 = select([label2])
+        s1 = select(label)
+        s2 = select(label2)
         assert s1.corresponding_column(label) is s1.selected_columns.foo
         assert s2.corresponding_column(label) is s2.selected_columns.foo
 
     def test_subquery_label_grouped_still_corresponds(self):
-        label = select([table1.c.col1]).label("foo")
+        label = select(table1.c.col1).label("foo")
         label2 = label.self_group()
 
-        s1 = select([label]).subquery()
-        s2 = select([label2]).subquery()
+        s1 = select(label).subquery()
+        s2 = select(label2).subquery()
         assert s1.corresponding_column(label) is s1.c.foo
         assert s2.corresponding_column(label) is s2.c.foo
 
@@ -230,20 +228,20 @@ class SelectableTest(
         # of the proxy set to get the right result
 
         l1, l2 = table1.c.col1.label("foo"), table1.c.col1.label("bar")
-        sel = select([l1, l2])
+        sel = select(l1, l2)
 
         sel2 = sel.alias()
         assert sel2.corresponding_column(l1) is sel2.c.foo
         assert sel2.corresponding_column(l2) is sel2.c.bar
 
-        sel2 = select([table1.c.col1.label("foo"), table1.c.col2.label("bar")])
+        sel2 = select(table1.c.col1.label("foo"), table1.c.col2.label("bar"))
 
         sel3 = sel.union(sel2).alias()
         assert sel3.corresponding_column(l1) is sel3.c.foo
         assert sel3.corresponding_column(l2) is sel3.c.bar
 
     def test_keyed_gen(self):
-        s = select([keyed])
+        s = select(keyed)
         eq_(s.selected_columns.colx.key, "colx")
 
         eq_(s.selected_columns.colx.name, "x")
@@ -267,7 +265,7 @@ class SelectableTest(
         assert sel2.corresponding_column(keyed.c.z) is sel2.c.z
 
     def test_keyed_label_gen(self):
-        s = select([keyed]).apply_labels()
+        s = select(keyed).apply_labels()
 
         assert (
             s.selected_columns.corresponding_column(keyed.c.colx)
@@ -301,20 +299,20 @@ class SelectableTest(
     def test_clone_c_proxy_key_upper(self):
         c = Column("foo", Integer, key="bar")
         t = Table("t", MetaData(), c)
-        s = select([t])._clone()
+        s = select(t)._clone()
         assert c in s.selected_columns.bar.proxy_set
 
-        s = select([t]).subquery()._clone()
+        s = select(t).subquery()._clone()
         assert c in s.c.bar.proxy_set
 
     def test_clone_c_proxy_key_lower(self):
         c = column("foo")
         c.key = "bar"
         t = table("t", c)
-        s = select([t])._clone()
+        s = select(t)._clone()
         assert c in s.selected_columns.bar.proxy_set
 
-        s = select([t]).subquery()._clone()
+        s = select(t).subquery()._clone()
         assert c in s.c.bar.proxy_set
 
     def test_no_error_on_unsupported_expr_key(self):
@@ -327,14 +325,14 @@ class SelectableTest(
 
         expr = BinaryExpression(t.c.x, t.c.y, myop)
 
-        s = select([t, expr])
+        s = select(t, expr)
 
         # anon_label, e.g. a truncated_label, is used here because
         # the expr has no name, no key, and myop() can't create a
         # string, so this is the last resort
         eq_(s.selected_columns.keys(), ["x", "y", expr.anon_label])
 
-        s = select([t, expr]).subquery()
+        s = select(t, expr).subquery()
         eq_(s.c.keys(), ["x", "y", expr.anon_label])
 
     def test_cloned_intersection(self):
@@ -380,7 +378,7 @@ class SelectableTest(
             assert s.corresponding_column(a1.c.col1) is s.c.a1_col1
 
     def test_join_against_self(self):
-        jj = select([table1.c.col1.label("bar_col1")]).subquery()
+        jj = select(table1.c.col1.label("bar_col1")).subquery()
         jjj = join(table1, jj, table1.c.col1 == jj.c.bar_col1)
 
         # test column directly against itself
@@ -403,7 +401,7 @@ class SelectableTest(
         assert j2.corresponding_column(table1.c.col1) is j2.c.table1_col1
 
     def test_clone_append_column(self):
-        sel = select([literal_column("1").label("a")])
+        sel = select(literal_column("1").label("a"))
         eq_(list(sel.selected_columns.keys()), ["a"])
         cloned = visitors.ReplacingCloningVisitor().traverse(sel)
         cloned.add_columns.non_generative(
@@ -414,7 +412,7 @@ class SelectableTest(
 
     def test_clone_col_list_changes_then_proxy(self):
         t = table("t", column("q"), column("p"))
-        stmt = select([t.c.q]).subquery()
+        stmt = select(t.c.q).subquery()
 
         def add_column(stmt):
             stmt.add_columns.non_generative(stmt, t.c.p)
@@ -425,7 +423,7 @@ class SelectableTest(
 
     def test_clone_col_list_changes_then_schema_proxy(self):
         t = Table("t", MetaData(), Column("q", Integer), Column("p", Integer))
-        stmt = select([t.c.q]).subquery()
+        stmt = select(t.c.q).subquery()
 
         def add_column(stmt):
             stmt.add_columns.non_generative(stmt, t.c.p)
@@ -437,13 +435,13 @@ class SelectableTest(
     def test_append_column_after_visitor_replace(self):
         # test for a supported idiom that matches the deprecated / removed
         # replace_selectable method
-        basesel = select([literal_column("1").label("a")])
+        basesel = select(literal_column("1").label("a"))
         tojoin = select(
-            [literal_column("1").label("a"), literal_column("2").label("b")]
+            literal_column("1").label("a"), literal_column("2").label("b")
         )
         basefrom = basesel.alias("basefrom")
         joinfrom = tojoin.alias("joinfrom")
-        sel = select([basefrom.c.a])
+        sel = select(basefrom.c.a)
 
         replace_from = basefrom.join(joinfrom, basefrom.c.a == joinfrom.c.a)
 
@@ -470,7 +468,7 @@ class SelectableTest(
         # test that corresponding column digs across
         # clone boundaries with anonymous labeled elements
         col = func.count().label("foo")
-        sel = select([col]).subquery()
+        sel = select(col).subquery()
 
         sel2 = visitors.ReplacingCloningVisitor().traverse(sel)
         assert sel2.corresponding_column(col) is sel2.c.foo
@@ -490,7 +488,7 @@ class SelectableTest(
         class MyType(TypeDecorator):
             impl = Integer
 
-        stmt = select([type_coerce(column("x"), MyType).label("foo")])
+        stmt = select(type_coerce(column("x"), MyType).label("foo"))
         subq = stmt.subquery()
         stmt2 = subq.select()
         subq2 = stmt2.subquery()
@@ -553,14 +551,14 @@ class SelectableTest(
 
         j2 = t4.join(j, onclause=t4.c.d == t2.c.b)
 
-        stmt = select([t1, t2, t3, t4]).select_from(j2)
+        stmt = select(t1, t2, t3, t4).select_from(j2)
         self.assert_compile(
             stmt,
             "SELECT t1.a, t2.b, t3.c, t4.d FROM t3, "
             "t4 JOIN (t1 JOIN t2 ON t1.a = t3.c) ON t4.d = t2.b",
         )
 
-        stmt = select([t1]).select_from(t3).select_from(j2)
+        stmt = select(t1).select_from(t3).select_from(j2)
         self.assert_compile(
             stmt,
             "SELECT t1.a FROM t3, t4 JOIN (t1 JOIN t2 ON t1.a = t3.c) "
@@ -572,7 +570,7 @@ class SelectableTest(
         # not quite a use case yet but this is expected to become
         # prominent w/ PostgreSQL's tuple functions
 
-        stmt = select([table1.c.col1, table1.c.col2])
+        stmt = select(table1.c.col1, table1.c.col2)
         a = stmt.alias("a")
 
         # TODO: this case is crazy, sending SELECT or FROMCLAUSE has to
@@ -580,7 +578,7 @@ class SelectableTest(
         # statements go into functions in PG. seems likely select statement,
         # but not alias, subquery or other FROM object
         self.assert_compile(
-            select([func.foo(a)]),
+            select(func.foo(a)),
             "SELECT foo(SELECT table1.col1, table1.col2 FROM table1) "
             "AS foo_1 FROM "
             "(SELECT table1.col1 AS col1, table1.col2 AS col2 FROM table1) "
@@ -594,22 +592,18 @@ class SelectableTest(
         # its underlying Selects matches to that same Table
 
         u = select(
-            [
-                table1.c.col1,
-                table1.c.col2,
-                table1.c.col3,
-                table1.c.colx,
-                null().label("coly"),
-            ]
+            table1.c.col1,
+            table1.c.col2,
+            table1.c.col3,
+            table1.c.colx,
+            null().label("coly"),
         ).union(
             select(
-                [
-                    table2.c.col1,
-                    table2.c.col2,
-                    table2.c.col3,
-                    null().label("colx"),
-                    table2.c.coly,
-                ]
+                table2.c.col1,
+                table2.c.col2,
+                table2.c.col3,
+                null().label("colx"),
+                table2.c.coly,
             )
         )
         s1 = table1.select(use_labels=True)
@@ -648,10 +642,10 @@ class SelectableTest(
         # conflicting column correspondence should be resolved based on
         # the order of the select()s in the union
 
-        s1 = select([table1.c.col1, table1.c.col2])
-        s2 = select([table1.c.col2, table1.c.col1])
-        s3 = select([table1.c.col3, table1.c.colx])
-        s4 = select([table1.c.colx, table1.c.col3])
+        s1 = select(table1.c.col1, table1.c.col2)
+        s2 = select(table1.c.col2, table1.c.col1)
+        s3 = select(table1.c.col3, table1.c.colx)
+        s4 = select(table1.c.colx, table1.c.col3)
 
         u1 = union(s1, s2).subquery()
         assert u1.corresponding_column(table1.c.col1) is u1.c.col1
@@ -664,8 +658,8 @@ class SelectableTest(
         assert u1.corresponding_column(table1.c.col3) is u1.c.col1
 
     def test_proxy_set_pollution(self):
-        s1 = select([table1.c.col1, table1.c.col2])
-        s2 = select([table1.c.col2, table1.c.col1])
+        s1 = select(table1.c.col1, table1.c.col2)
+        s2 = select(table1.c.col2, table1.c.col1)
 
         for c in s1.selected_columns:
             c.proxy_set
@@ -677,10 +671,10 @@ class SelectableTest(
 
     def test_singular_union(self):
         u = union(
-            select([table1.c.col1, table1.c.col2, table1.c.col3]),
-            select([table1.c.col1, table1.c.col2, table1.c.col3]),
+            select(table1.c.col1, table1.c.col2, table1.c.col3),
+            select(table1.c.col1, table1.c.col2, table1.c.col3),
         )
-        u = union(select([table1.c.col1, table1.c.col2, table1.c.col3]))
+        u = union(select(table1.c.col1, table1.c.col2, table1.c.col3))
         assert u.selected_columns.col1 is not None
         assert u.selected_columns.col2 is not None
         assert u.selected_columns.col3 is not None
@@ -691,23 +685,19 @@ class SelectableTest(
 
         u = (
             select(
-                [
-                    table1.c.col1,
-                    table1.c.col2,
-                    table1.c.col3,
-                    table1.c.colx,
-                    null().label("coly"),
-                ]
+                table1.c.col1,
+                table1.c.col2,
+                table1.c.col3,
+                table1.c.colx,
+                null().label("coly"),
             )
             .union(
                 select(
-                    [
-                        table2.c.col1,
-                        table2.c.col2,
-                        table2.c.col3,
-                        null().label("colx"),
-                        table2.c.coly,
-                    ]
+                    table2.c.col1,
+                    table2.c.col2,
+                    table2.c.col3,
+                    null().label("colx"),
+                    table2.c.coly,
                 )
             )
             .alias("analias")
@@ -720,8 +710,8 @@ class SelectableTest(
         assert s2.corresponding_column(u.c.coly) is s2.c.table2_coly
 
     def test_union_of_alias(self):
-        s1 = select([table1.c.col1, table1.c.col2])
-        s2 = select([table1.c.col1, table1.c.col2]).alias()
+        s1 = select(table1.c.col1, table1.c.col2)
+        s2 = select(table1.c.col1, table1.c.col2).alias()
 
         # previously this worked
         assert_raises_message(
@@ -734,7 +724,7 @@ class SelectableTest(
         )
 
     def test_union_of_text(self):
-        s1 = select([table1.c.col1, table1.c.col2])
+        s1 = select(table1.c.col1, table1.c.col2)
         s2 = text("select col1, col2 from foo").columns(
             column("col1"), column("col2")
         )
@@ -748,8 +738,8 @@ class SelectableTest(
         assert u2.corresponding_column(s2.selected_columns.col1) is u2.c.col1
 
     def test_foo(self):
-        s1 = select([table1.c.col1, table1.c.col2])
-        s2 = select([table1.c.col2, table1.c.col1])
+        s1 = select(table1.c.col1, table1.c.col2)
+        s2 = select(table1.c.col2, table1.c.col1)
 
         u1 = union(s1, s2).subquery()
         assert u1.corresponding_column(table1.c.col2) is u1.c.col2
@@ -765,16 +755,16 @@ class SelectableTest(
         )
         # table1_new = table1
 
-        s1 = select([table1_new.c.col1, table1_new.c.col2])
-        s2 = select([table1_new.c.col2, table1_new.c.col1])
+        s1 = select(table1_new.c.col1, table1_new.c.col2)
+        s2 = select(table1_new.c.col2, table1_new.c.col1)
         u1 = union(s1, s2).subquery()
 
         # TODO: failing due to proxy_set not correct
         assert u1.corresponding_column(table1_new.c.col2) is u1.c.col2
 
     def test_union_alias_dupe_keys(self):
-        s1 = select([table1.c.col1, table1.c.col2, table2.c.col1])
-        s2 = select([table2.c.col1, table2.c.col2, table2.c.col3])
+        s1 = select(table1.c.col1, table1.c.col2, table2.c.col1)
+        s2 = select(table2.c.col1, table2.c.col2, table2.c.col3)
         u1 = union(s1, s2).subquery()
 
         assert (
@@ -818,13 +808,13 @@ class SelectableTest(
         assert u1.corresponding_column(table2.c.col3) is u1.c._all_columns[2]
 
     def test_union_alias_dupe_keys_disambiguates_in_subq_compile_one(self):
-        s1 = select([table1.c.col1, table1.c.col2, table2.c.col1]).limit(1)
-        s2 = select([table2.c.col1, table2.c.col2, table2.c.col3]).limit(1)
+        s1 = select(table1.c.col1, table1.c.col2, table2.c.col1).limit(1)
+        s2 = select(table2.c.col1, table2.c.col2, table2.c.col3).limit(1)
         u1 = union(s1, s2).subquery()
 
         eq_(u1.c.keys(), ["col1", "col2", "col1_1"])
 
-        stmt = select([u1])
+        stmt = select(u1)
 
         eq_(stmt.selected_columns.keys(), ["col1", "col2", "col1_1"])
 
@@ -850,7 +840,7 @@ class SelectableTest(
 
         eq_(u1.c.keys(), ["a_id", "b_id", "b_aid"])
 
-        stmt = select([u1])
+        stmt = select(u1)
 
         eq_(stmt.selected_columns.keys(), ["a_id", "b_id", "b_aid"])
 
@@ -866,8 +856,8 @@ class SelectableTest(
         )
 
     def test_union_alias_dupe_keys_grouped(self):
-        s1 = select([table1.c.col1, table1.c.col2, table2.c.col1]).limit(1)
-        s2 = select([table2.c.col1, table2.c.col2, table2.c.col3]).limit(1)
+        s1 = select(table1.c.col1, table1.c.col2, table2.c.col1).limit(1)
+        s2 = select(table2.c.col1, table2.c.col2, table2.c.col3).limit(1)
         u1 = union(s1, s2).subquery()
 
         assert (
@@ -916,28 +906,24 @@ class SelectableTest(
 
         u = (
             select(
-                [
-                    table1.c.col1,
-                    table1.c.col2,
-                    table1.c.col3,
-                    table1.c.colx,
-                    null().label("coly"),
-                ]
+                table1.c.col1,
+                table1.c.col2,
+                table1.c.col3,
+                table1.c.colx,
+                null().label("coly"),
             )
             .union(
                 select(
-                    [
-                        table2.c.col1,
-                        table2.c.col2,
-                        table2.c.col3,
-                        null().label("colx"),
-                        table2.c.coly,
-                    ]
+                    table2.c.col1,
+                    table2.c.col2,
+                    table2.c.col3,
+                    null().label("colx"),
+                    table2.c.coly,
                 )
             )
             .alias("analias")
         )
-        s = select([u]).subquery()
+        s = select(u).subquery()
         s1 = table1.select(use_labels=True).subquery()
         s2 = table2.select(use_labels=True).subquery()
         assert s.corresponding_column(s1.c.table1_col2) is s.c.col2
@@ -949,23 +935,19 @@ class SelectableTest(
 
         u = (
             select(
-                [
-                    table1.c.col1,
-                    table1.c.col2,
-                    table1.c.col3,
-                    table1.c.colx,
-                    null().label("coly"),
-                ]
+                table1.c.col1,
+                table1.c.col2,
+                table1.c.col3,
+                table1.c.colx,
+                null().label("coly"),
             )
             .union(
                 select(
-                    [
-                        table2.c.col1,
-                        table2.c.col2,
-                        table2.c.col3,
-                        null().label("colx"),
-                        table2.c.coly,
-                    ]
+                    table2.c.col1,
+                    table2.c.col2,
+                    table2.c.col3,
+                    null().label("colx"),
+                    table2.c.coly,
                 )
             )
             .alias("analias")
@@ -998,7 +980,7 @@ class SelectableTest(
         self.assert_(criterion.compare(j.onclause))
 
     def test_scalar_cloned_comparator(self):
-        sel = select([table1.c.col1]).scalar_subquery()
+        sel = select(table1.c.col1).scalar_subquery()
         sel == table1.c.col1
 
         sel2 = visitors.ReplacingCloningVisitor().traverse(sel)
@@ -1008,32 +990,30 @@ class SelectableTest(
 
     def test_column_labels(self):
         a = select(
-            [
-                table1.c.col1.label("acol1"),
-                table1.c.col2.label("acol2"),
-                table1.c.col3.label("acol3"),
-            ]
+            table1.c.col1.label("acol1"),
+            table1.c.col2.label("acol2"),
+            table1.c.col3.label("acol3"),
         ).subquery()
         j = join(a, table2)
         criterion = a.c.acol1 == table2.c.col2
         self.assert_(criterion.compare(j.onclause))
 
     def test_labeled_select_corresponding(self):
-        l1 = select([func.max(table1.c.col1)]).label("foo")
+        l1 = select(func.max(table1.c.col1)).label("foo")
 
-        s = select([l1])
+        s = select(l1)
         eq_(s.corresponding_column(l1), s.selected_columns.foo)
 
-        s = select([table1.c.col1, l1])
+        s = select(table1.c.col1, l1)
         eq_(s.corresponding_column(l1), s.selected_columns.foo)
 
     def test_labeled_subquery_corresponding(self):
-        l1 = select([func.max(table1.c.col1)]).label("foo")
-        s = select([l1]).subquery()
+        l1 = select(func.max(table1.c.col1)).label("foo")
+        s = select(l1).subquery()
 
         eq_(s.corresponding_column(l1), s.c.foo)
 
-        s = select([table1.c.col1, l1]).subquery()
+        s = select(table1.c.col1, l1).subquery()
         eq_(s.corresponding_column(l1), s.c.foo)
 
     def test_select_alias_labels(self):
@@ -1047,11 +1027,11 @@ class SelectableTest(
         metadata = MetaData()
         a = Table("a", metadata, Column("id", Integer, primary_key=True))
 
-        j2 = select([a.c.id.label("aid")]).alias("bar")
+        j2 = select(a.c.id.label("aid")).alias("bar")
 
         j3 = a.join(j2, j2.c.aid == a.c.id)
 
-        j4 = select([j3]).alias("foo")
+        j4 = select(j3).alias("foo")
         assert j4.corresponding_column(j2.c.aid) is j4.c.aid
         assert j4.corresponding_column(a.c.id) is j4.c.id
 
@@ -1070,8 +1050,8 @@ class SelectableTest(
     def test_multi_label_chain_naming_col(self):
         # See [ticket:2167] for this one.
         l1 = table1.c.col1.label("a")
-        l2 = select([l1]).label("b")
-        s = select([l2]).subquery()
+        l2 = select(l1).label("b")
+        s = select(l2).subquery()
         assert s.c.b is not None
         self.assert_compile(
             s.select(),
@@ -1079,7 +1059,7 @@ class SelectableTest(
             "(SELECT (SELECT table1.col1 AS a FROM table1) AS b) AS anon_1",
         )
 
-        s2 = select([s.element.label("c")]).subquery()
+        s2 = select(s.element.label("c")).subquery()
         self.assert_compile(
             s2.select(),
             "SELECT anon_1.c FROM (SELECT (SELECT ("
@@ -1093,7 +1073,7 @@ class SelectableTest(
         # style to the select, eliminating the self-referential call unless
         # the select already had labeling applied
 
-        s = select([t]).apply_labels()
+        s = select(t).apply_labels()
 
         with testing.expect_deprecated("The SelectBase.c"):
             s.where.non_generative(s, s.c.t_x > 5)
@@ -1107,7 +1087,7 @@ class SelectableTest(
     def test_unusual_column_elements_text(self):
         """test that .c excludes text()."""
 
-        s = select([table1.c.col1, text("foo")]).subquery()
+        s = select(table1.c.col1, text("foo")).subquery()
         eq_(list(s.c), [s.c.col1])
 
     def test_unusual_column_elements_clauselist(self):
@@ -1116,7 +1096,7 @@ class SelectableTest(
         from sqlalchemy.sql.expression import ClauseList
 
         s = select(
-            [table1.c.col1, ClauseList(table1.c.col2, table1.c.col3)]
+            table1.c.col1, ClauseList(table1.c.col2, table1.c.col3)
         ).subquery()
         eq_(list(s.c), [s.c.col1, s.c.col2, s.c.col3])
 
@@ -1124,56 +1104,56 @@ class SelectableTest(
         """test that BooleanClauseList is placed as single element in .c."""
 
         c2 = and_(table1.c.col2 == 5, table1.c.col3 == 4)
-        s = select([table1.c.col1, c2]).subquery()
+        s = select(table1.c.col1, c2).subquery()
         eq_(list(s.c), [s.c.col1, s.corresponding_column(c2)])
 
     def test_from_list_deferred_constructor(self):
         c1 = Column("c1", Integer)
         c2 = Column("c2", Integer)
 
-        select([c1])
+        select(c1)
 
         t = Table("t", MetaData(), c1, c2)
 
         eq_(c1._from_objects, [t])
         eq_(c2._from_objects, [t])
 
-        self.assert_compile(select([c1]), "SELECT t.c1 FROM t")
-        self.assert_compile(select([c2]), "SELECT t.c2 FROM t")
+        self.assert_compile(select(c1), "SELECT t.c1 FROM t")
+        self.assert_compile(select(c2), "SELECT t.c2 FROM t")
 
     def test_from_list_deferred_whereclause(self):
         c1 = Column("c1", Integer)
         c2 = Column("c2", Integer)
 
-        select([c1]).where(c1 == 5)
+        select(c1).where(c1 == 5)
 
         t = Table("t", MetaData(), c1, c2)
 
         eq_(c1._from_objects, [t])
         eq_(c2._from_objects, [t])
 
-        self.assert_compile(select([c1]), "SELECT t.c1 FROM t")
-        self.assert_compile(select([c2]), "SELECT t.c2 FROM t")
+        self.assert_compile(select(c1), "SELECT t.c1 FROM t")
+        self.assert_compile(select(c2), "SELECT t.c2 FROM t")
 
     def test_from_list_deferred_fromlist(self):
         m = MetaData()
         t1 = Table("t1", m, Column("x", Integer))
 
         c1 = Column("c1", Integer)
-        select([c1]).where(c1 == 5).select_from(t1)
+        select(c1).where(c1 == 5).select_from(t1)
 
         t2 = Table("t2", MetaData(), c1)
 
         eq_(c1._from_objects, [t2])
 
-        self.assert_compile(select([c1]), "SELECT t2.c1 FROM t2")
+        self.assert_compile(select(c1), "SELECT t2.c1 FROM t2")
 
     def test_from_list_deferred_cloning(self):
         c1 = Column("c1", Integer)
         c2 = Column("c2", Integer)
 
-        s = select([c1])
-        s2 = select([c2])
+        s = select(c1)
+        s2 = select(c2)
         s3 = sql_util.ClauseAdapter(s).traverse(s2)
 
         Table("t", MetaData(), c1, c2)
@@ -1183,7 +1163,7 @@ class SelectableTest(
     def test_from_list_with_columns(self):
         table1 = table("t1", column("a"))
         table2 = table("t2", column("b"))
-        s1 = select([table1.c.a, table2.c.b])
+        s1 = select(table1.c.a, table2.c.b)
         self.assert_compile(s1, "SELECT t1.a, t2.b FROM t1, t2")
         s2 = s1.with_only_columns([table2.c.b])
         self.assert_compile(s2, "SELECT t2.b FROM t2")
@@ -1195,7 +1175,7 @@ class SelectableTest(
 
     def test_from_list_against_existing_one(self):
         c1 = Column("c1", Integer)
-        s = select([c1])
+        s = select(c1)
 
         # force a compile.
         self.assert_compile(s, "SELECT c1")
@@ -1208,7 +1188,7 @@ class SelectableTest(
         c1 = Column("c1", Integer)
         c2 = Column("c2", Integer)
 
-        s = select([c1])
+        s = select(c1)
 
         # force a compile.
         eq_(str(s), "SELECT c1")
@@ -1219,8 +1199,8 @@ class SelectableTest(
         eq_(c2._from_objects, [t])
 
         self.assert_compile(s, "SELECT t.c1 FROM t")
-        self.assert_compile(select([c1]), "SELECT t.c1 FROM t")
-        self.assert_compile(select([c2]), "SELECT t.c2 FROM t")
+        self.assert_compile(select(c1), "SELECT t.c1 FROM t")
+        self.assert_compile(select(c2), "SELECT t.c2 FROM t")
 
     def test_label_gen_resets_on_table(self):
         c1 = Column("c1", Integer)
@@ -1243,13 +1223,13 @@ class SelectableTest(
     def test_whereclause_adapted(self):
         table1 = table("t1", column("a"))
 
-        s1 = select([table1]).subquery()
+        s1 = select(table1).subquery()
 
-        s2 = select([s1]).where(s1.c.a == 5)
+        s2 = select(s1).where(s1.c.a == 5)
 
         assert s2._whereclause.left.table is s1
 
-        ta = select([table1]).subquery()
+        ta = select(table1).subquery()
 
         s3 = sql_util.ClauseAdapter(ta).traverse(s2)
 
@@ -1297,7 +1277,7 @@ class RefreshForNewColTest(fixtures.TestBase):
     def test_select_samename_init(self):
         a = table("a", column("x"))
         b = table("b", column("y"))
-        s = select([a, b]).apply_labels()
+        s = select(a, b).apply_labels()
         s.selected_columns
         q = column("x")
         b.append_column(q)
@@ -1307,7 +1287,7 @@ class RefreshForNewColTest(fixtures.TestBase):
     def test_alias_alias_samename_init(self):
         a = table("a", column("x"))
         b = table("b", column("y"))
-        s1 = select([a, b]).apply_labels().alias()
+        s1 = select(a, b).apply_labels().alias()
         s2 = s1.alias()
 
         s1.c
@@ -1326,7 +1306,7 @@ class RefreshForNewColTest(fixtures.TestBase):
     def test_aliased_select_samename_uninit(self):
         a = table("a", column("x"))
         b = table("b", column("y"))
-        s = select([a, b]).apply_labels().alias()
+        s = select(a, b).apply_labels().alias()
         q = column("x")
         b.append_column(q)
         s._refresh_for_new_column(q)
@@ -1335,7 +1315,7 @@ class RefreshForNewColTest(fixtures.TestBase):
     def test_aliased_select_samename_init(self):
         a = table("a", column("x"))
         b = table("b", column("y"))
-        s = select([a, b]).apply_labels().alias()
+        s = select(a, b).apply_labels().alias()
         s.c
         q = column("x")
         b.append_column(q)
@@ -1346,7 +1326,7 @@ class RefreshForNewColTest(fixtures.TestBase):
         a = table("a", column("x"))
         b = table("b", column("y"))
         c = table("c", column("z"))
-        s = select([a, b]).apply_labels().alias()
+        s = select(a, b).apply_labels().alias()
         s.c
         q = column("x")
         c.append_column(q)
@@ -1355,7 +1335,7 @@ class RefreshForNewColTest(fixtures.TestBase):
 
     def test_aliased_select_no_cols_clause(self):
         a = table("a", column("x"))
-        s = select([a.c.x]).apply_labels().alias()
+        s = select(a.c.x).apply_labels().alias()
         s.c
         q = column("q")
         a.append_column(q)
@@ -1364,8 +1344,8 @@ class RefreshForNewColTest(fixtures.TestBase):
 
     def test_union_uninit(self):
         a = table("a", column("x"))
-        s1 = select([a])
-        s2 = select([a])
+        s1 = select(a)
+        s2 = select(a)
         s3 = s1.union(s2)
         q = column("q")
         a.append_column(q)
@@ -1374,8 +1354,8 @@ class RefreshForNewColTest(fixtures.TestBase):
 
     def test_union_init(self):
         a = table("a", column("x"))
-        s1 = select([a])
-        s2 = select([a])
+        s1 = select(a)
+        s2 = select(a)
         s3 = s1.union(s2)
         s3.selected_columns
         q = column("q")
@@ -1453,29 +1433,29 @@ class AnonLabelTest(fixtures.TestBase):
         c1 = column("x")
 
         assert c1.label(None) is not c1
-        eq_(str(select([c1.label(None)])), "SELECT x AS x_1")
+        eq_(str(select(c1.label(None))), "SELECT x AS x_1")
 
     def test_anon_labels_literal_column(self):
         c1 = literal_column("x")
         assert c1.label(None) is not c1
-        eq_(str(select([c1.label(None)])), "SELECT x AS x_1")
+        eq_(str(select(c1.label(None))), "SELECT x AS x_1")
 
     def test_anon_labels_func(self):
         c1 = func.count("*")
         assert c1.label(None) is not c1
 
-        eq_(str(select([c1])), "SELECT count(:count_2) AS count_1")
-        select([c1]).compile()
+        eq_(str(select(c1)), "SELECT count(:count_2) AS count_1")
+        select(c1).compile()
 
-        eq_(str(select([c1.label(None)])), "SELECT count(:count_2) AS count_1")
+        eq_(str(select(c1.label(None))), "SELECT count(:count_2) AS count_1")
 
     def test_named_labels_named_column(self):
         c1 = column("x")
-        eq_(str(select([c1.label("y")])), "SELECT x AS y")
+        eq_(str(select(c1.label("y"))), "SELECT x AS y")
 
     def test_named_labels_literal_column(self):
         c1 = literal_column("x")
-        eq_(str(select([c1.label("y")])), "SELECT x AS y")
+        eq_(str(select(c1.label("y"))), "SELECT x AS y")
 
 
 class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL):
@@ -1544,7 +1524,7 @@ class JoinAliasingTest(fixtures.TestBase, AssertsCompiledSQL):
         j1 = a.join(b, a.c.a == b.c.b)
         j2 = c.join(d, c.c.c == d.c.d)
         self.assert_compile(
-            select([j1.join(j2, b.c.b == c.c.c).alias()]),
+            select(j1.join(j2, b.c.b == c.c.c).alias()),
             "SELECT anon_1.a_a, anon_1.b_b, anon_1.c_c, anon_1.d_d "
             "FROM (SELECT a.a AS a_a, b.b AS b_b, c.c AS c_c, d.d AS d_d "
             "FROM a JOIN b ON a.a = b.b "
@@ -2013,7 +1993,7 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
             Column("manager_name", String(50)),
         )
         s = (
-            select([engineers, managers])
+            select(engineers, managers)
             .where(engineers.c.engineer_name == managers.c.manager_name)
             .subquery()
         )
@@ -2038,7 +2018,7 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
             Column("z", Integer, ForeignKey("t1.x")),
             Column("q", Integer),
         )
-        s1 = select([t1, t2])
+        s1 = select(t1, t2)
         s2 = s1.reduce_columns(only_synonyms=False)
         eq_(set(s2.selected_columns), set([t1.c.x, t1.c.y, t2.c.q]))
 
@@ -2059,7 +2039,7 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
             Column("x", Integer, ForeignKey("t1.x")),
             Column("q", Integer, ForeignKey("t1.y")),
         )
-        s1 = select([t1, t2])
+        s1 = select(t1, t2)
         s1 = s1.reduce_columns(only_synonyms=True)
         eq_(
             set(s1.selected_columns),
@@ -2083,16 +2063,16 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
         )
         # test that the first appearance in the columns clause
         # wins - t1 is first, t1.c.x wins
-        s1 = select([t1]).subquery()
-        s2 = select([t1, s1]).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z)
+        s1 = select(t1).subquery()
+        s2 = select(t1, s1).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z)
         eq_(
             set(s2.reduce_columns().selected_columns),
             set([t1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]),
         )
 
         # reverse order, s1.c.x wins
-        s1 = select([t1]).subquery()
-        s2 = select([s1, t1]).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z)
+        s1 = select(t1).subquery()
+        s2 = select(s1, t1).where(t1.c.x == s1.c.x).where(s1.c.y == t1.c.z)
         eq_(
             set(s2.reduce_columns().selected_columns),
             set([s1.c.x, t1.c.y, t1.c.z, s1.c.y, s1.c.z]),
@@ -2229,22 +2209,18 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
 
         pjoin = union(
             select(
-                [
-                    page_table.c.id,
-                    magazine_page_table.c.page_id,
-                    classified_page_table.c.magazine_page_id,
-                ]
+                page_table.c.id,
+                magazine_page_table.c.page_id,
+                classified_page_table.c.magazine_page_id,
             ).select_from(
                 page_table.join(magazine_page_table).join(
                     classified_page_table
                 )
             ),
             select(
-                [
-                    page_table.c.id,
-                    magazine_page_table.c.page_id,
-                    cast(null(), Integer).label("magazine_page_id"),
-                ]
+                page_table.c.id,
+                magazine_page_table.c.page_id,
+                cast(null(), Integer).label("magazine_page_id"),
             ).select_from(page_table.join(magazine_page_table)),
         ).alias("pjoin")
         eq_(
@@ -2265,18 +2241,14 @@ class ReduceTest(fixtures.TestBase, AssertsExecutionResults):
 
         pjoin = union(
             select(
-                [
-                    page_table.c.id,
-                    magazine_page_table.c.page_id,
-                    cast(null(), Integer).label("magazine_page_id"),
-                ]
+                page_table.c.id,
+                magazine_page_table.c.page_id,
+                cast(null(), Integer).label("magazine_page_id"),
             ).select_from(page_table.join(magazine_page_table)),
             select(
-                [
-                    page_table.c.id,
-                    magazine_page_table.c.page_id,
-                    classified_page_table.c.magazine_page_id,
-                ]
+                page_table.c.id,
+                magazine_page_table.c.page_id,
+                classified_page_table.c.magazine_page_id,
             ).select_from(
                 page_table.join(magazine_page_table).join(
                     classified_page_table
@@ -2352,10 +2324,10 @@ class DerivedTest(fixtures.TestBase, AssertsExecutionResults):
         assert t1.select().is_derived_from(t1)
         assert not t2.select().is_derived_from(t1)
 
-        assert select([t1, t2]).is_derived_from(t1)
+        assert select(t1, t2).is_derived_from(t1)
 
         assert t1.select().alias("foo").is_derived_from(t1)
-        assert select([t1, t2]).alias("foo").is_derived_from(t1)
+        assert select(t1, t2).alias("foo").is_derived_from(t1)
         assert not t2.select().alias("foo").is_derived_from(t1)
 
 
@@ -2385,7 +2357,7 @@ class AnnotationsTest(fixtures.TestBase):
 
         c1 = Column("foo", Integer)
 
-        stmt = select([c1]).alias()
+        stmt = select(c1).alias()
         proxy = stmt.c.foo
 
         proxy.proxy_set
@@ -2406,7 +2378,7 @@ class AnnotationsTest(fixtures.TestBase):
 
         c1 = Column("foo", Integer)
 
-        stmt = select([c1]).alias()
+        stmt = select(c1).alias()
         proxy = stmt.c.foo
         c1.proxy_set
 
@@ -2462,7 +2434,7 @@ class AnnotationsTest(fixtures.TestBase):
         assert isinstance(s1.c.foo, Column)
 
         annot_1 = t1.c.foo._annotate({})
-        s2 = select([annot_1]).subquery()
+        s2 = select(annot_1).subquery()
         assert isinstance(s2.c.foo, Column)
         annot_2 = s1._annotate({})
         assert isinstance(annot_2.c.foo, Column)
@@ -2496,7 +2468,7 @@ class AnnotationsTest(fixtures.TestBase):
     def test_annotated_corresponding_column(self):
         table1 = table("table1", column("col1"))
 
-        s1 = select([table1.c.col1]).subquery()
+        s1 = select(table1.c.col1).subquery()
         t1 = s1._annotate({})
         t2 = s1
 
@@ -2507,7 +2479,7 @@ class AnnotationsTest(fixtures.TestBase):
         assert t1.c is t2.c
         assert t1.c.col1 is t2.c.col1
 
-        inner = select([s1]).subquery()
+        inner = select(s1).subquery()
 
         assert (
             inner.corresponding_column(t2.c.col1, require_embedded=False)
@@ -2555,7 +2527,7 @@ class AnnotationsTest(fixtures.TestBase):
 
     def test_annotate_aliased(self):
         t1 = table("t1", column("c1"))
-        s = select([(t1.c.c1 + 3).label("bat")])
+        s = select((t1.c.c1 + 3).label("bat"))
         a = s.alias()
         a = sql_util._deep_annotate(a, {"foo": "bar"})
         eq_(a._annotations["foo"], "bar")
@@ -2614,11 +2586,9 @@ class AnnotationsTest(fixtures.TestBase):
         table1 = table("table1", column("col1"), column("col2"))
 
         subq = (
-            select([table1])
-            .where(table1.c.col1 == bindparam("foo"))
-            .subquery()
+            select(table1).where(table1.c.col1 == bindparam("foo")).subquery()
         )
-        stmt = select([subq])
+        stmt = select(subq)
 
         s2 = sql_util._deep_annotate(stmt, {"_orm_adapt": True})
         s3 = sql_util._deep_deannotate(s2)
@@ -2654,7 +2624,7 @@ class AnnotationsTest(fixtures.TestBase):
         table1 = table("table1", column("x"))
         table2 = table("table2", column("y"))
         a1 = table1.alias()
-        s = select([a1.c.x]).select_from(a1.join(table2, a1.c.x == table2.c.y))
+        s = select(a1.c.x).select_from(a1.join(table2, a1.c.x == table2.c.y))
         for sel in (
             sql_util._deep_deannotate(s),
             visitors.cloned_traverse(s, {}, {}),
@@ -2687,8 +2657,8 @@ class AnnotationsTest(fixtures.TestBase):
 
         """
         t1 = table("table1", column("col1"), column("col2"))
-        s = select([t1.c.col1._annotate({"foo": "bar"})])
-        s2 = select([t1.c.col1._annotate({"bat": "hoho"})])
+        s = select(t1.c.col1._annotate({"foo": "bar"}))
+        s2 = select(t1.c.col1._annotate({"bat": "hoho"}))
         s3 = s.union(s2)
         sel = sql_util._deep_annotate(s3, {"new": "thing"})
 
@@ -2740,9 +2710,9 @@ class AnnotationsTest(fixtures.TestBase):
         table1 = table("table1", column("x"))
         table2 = table("table2", column("y"))
         a1 = table1.alias()
-        s = select([a1.c.x]).select_from(a1.join(table2, a1.c.x == table2.c.y))
+        s = select(a1.c.x).select_from(a1.join(table2, a1.c.x == table2.c.y))
 
-        assert_s = select([select([s.subquery()]).subquery()])
+        assert_s = select([select(s.subquery()).subquery()])
         for fn in (
             sql_util._deep_deannotate,
             lambda s: sql_util._deep_annotate(s, {"foo": "bar"}),
@@ -2750,7 +2720,7 @@ class AnnotationsTest(fixtures.TestBase):
             lambda s: visitors.replacement_traverse(s, {}, lambda x: None),
         ):
 
-            sel = fn(select([fn(select([fn(s.subquery())]).subquery())]))
+            sel = fn(select([fn(select(fn(s.subquery())).subquery())]))
             eq_(str(assert_s), str(sel))
 
     def test_bind_unique_test(self):
@@ -2832,7 +2802,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t1", m, Column("x", Integer))
         t2 = Table("t2", m, Column("x", Integer))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_names_overlap_nolabel(self):
         sel = self._names_overlap()
@@ -2850,7 +2820,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t1", m, Column("x", Integer, key="a"))
         t2 = Table("t2", m, Column("x", Integer, key="b"))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_names_overlap_keys_dont_nolabel(self):
         sel = self._names_overlap_keys_dont()
@@ -2869,7 +2839,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t", m, Column("x_id", Integer))
         t2 = Table("t_x", m, Column("id", Integer))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_labels_overlap_nolabel(self):
         sel = self._labels_overlap()
@@ -2894,7 +2864,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t", m, Column("x_id", Integer, key="a"))
         t2 = Table("t_x", m, Column("id", Integer, key="b"))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_labels_overlap_keylabels_dont_nolabel(self):
         sel = self._labels_overlap_keylabels_dont()
@@ -2912,7 +2882,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t", m, Column("a", Integer, key="x_id"))
         t2 = Table("t_x", m, Column("b", Integer, key="id"))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_keylabels_overlap_labels_dont_nolabel(self):
         sel = self._keylabels_overlap_labels_dont()
@@ -2935,7 +2905,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t", m, Column("x_id", Integer, key="x_a"))
         t2 = Table("t_x", m, Column("id", Integer, key="a"))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_keylabels_overlap_labels_overlap_nolabel(self):
         sel = self._keylabels_overlap_labels_overlap()
@@ -2963,7 +2933,7 @@ class WithLabelsTest(fixtures.TestBase):
         m = MetaData()
         t1 = Table("t1", m, Column("a", Integer, key="x"))
         t2 = Table("t2", m, Column("b", Integer, key="x"))
-        return select([t1, t2])
+        return select(t1, t2)
 
     def test_keys_overlap_names_dont_nolabel(self):
         sel = self._keys_overlap_names_dont()
@@ -2993,7 +2963,7 @@ class ResultMapTest(fixtures.TestBase):
     def test_select_label_alt_name(self):
         t = self._fixture()
         l1, l2 = t.c.x.label("a"), t.c.y.label("b")
-        s = select([l1, l2])
+        s = select(l1, l2)
         mapping = self._mapping(s)
         assert l1 in mapping
 
@@ -3002,7 +2972,7 @@ class ResultMapTest(fixtures.TestBase):
     def test_select_alias_label_alt_name(self):
         t = self._fixture()
         l1, l2 = t.c.x.label("a"), t.c.y.label("b")
-        s = select([l1, l2]).alias()
+        s = select(l1, l2).alias()
         mapping = self._mapping(s)
         assert l1 in mapping
 
@@ -3011,7 +2981,7 @@ class ResultMapTest(fixtures.TestBase):
     def test_select_alias_column(self):
         t = self._fixture()
         x, y = t.c.x, t.c.y
-        s = select([x, y]).alias()
+        s = select(x, y).alias()
         mapping = self._mapping(s)
 
         assert t.c.x in mapping
@@ -3019,7 +2989,7 @@ class ResultMapTest(fixtures.TestBase):
     def test_select_alias_column_apply_labels(self):
         t = self._fixture()
         x, y = t.c.x, t.c.y
-        s = select([x, y]).apply_labels().alias()
+        s = select(x, y).apply_labels().alias()
         mapping = self._mapping(s)
         assert t.c.x in mapping
 
@@ -3028,7 +2998,7 @@ class ResultMapTest(fixtures.TestBase):
         x = t.c.x
 
         ta = t.alias()
-        s = select([ta.c.x, ta.c.y])
+        s = select(ta.c.x, ta.c.y)
         mapping = self._mapping(s)
         assert x not in mapping
 
@@ -3039,7 +3009,7 @@ class ResultMapTest(fixtures.TestBase):
         ta = t.alias()
         l1, l2 = ta.c.x.label("a"), ta.c.y.label("b")
 
-        s = select([l1, l2])
+        s = select(l1, l2)
         mapping = self._mapping(s)
         assert x not in mapping
         assert l1 in mapping
@@ -3061,7 +3031,7 @@ class ResultMapTest(fixtures.TestBase):
         eq_(
             [
                 type(entry[-1])
-                for entry in select([expr]).compile()._result_columns
+                for entry in select(expr).compile()._result_columns
             ],
             [Boolean],
         )
@@ -3072,7 +3042,7 @@ class ResultMapTest(fixtures.TestBase):
         eq_(
             [
                 type(entry[-1])
-                for entry in select([expr]).compile()._result_columns
+                for entry in select(expr).compile()._result_columns
             ],
             [Boolean],
         )
@@ -3083,15 +3053,15 @@ class ResultMapTest(fixtures.TestBase):
         eq_(
             [
                 type(entry[-1])
-                for entry in select([expr]).compile()._result_columns
+                for entry in select(expr).compile()._result_columns
             ],
             [Boolean],
         )
 
     def test_column_subquery_plain(self):
         t = self._fixture()
-        s1 = select([t.c.x]).where(t.c.x > 5).scalar_subquery()
-        s2 = select([s1])
+        s1 = select(t.c.x).where(t.c.x > 5).scalar_subquery()
+        s2 = select(s1)
         mapping = self._mapping(s2)
         assert t.c.x not in mapping
         assert s1 in mapping
@@ -3114,7 +3084,7 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_basic_clone(self):
         t = table("t", column("c"))
-        s = select([t]).with_for_update(read=True, of=t.c.c)
+        s = select(t).with_for_update(read=True, of=t.c.c)
         s2 = visitors.ReplacingCloningVisitor().traverse(s)
         assert s2._for_update_arg is not s._for_update_arg
         eq_(s2._for_update_arg.read, True)
@@ -3125,7 +3095,7 @@ class ForUpdateTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_adapt(self):
         t = table("t", column("c"))
-        s = select([t]).with_for_update(read=True, of=t.c.c)
+        s = select(t).with_for_update(read=True, of=t.c.c)
         a = t.alias()
         s2 = sql_util.ClauseAdapter(a).traverse(s)
         eq_(s2._for_update_arg.of, [a.c.c])
@@ -3151,14 +3121,14 @@ class AliasTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_get_children_preserves_multiple_nesting(self):
         t = table("t", column("c"))
-        stmt = select([t])
+        stmt = select(t)
         a1 = stmt.alias()
         a2 = a1.alias()
         eq_(set(a2.get_children(column_collections=False)), {a1})
 
     def test_correspondence_multiple_nesting(self):
         t = table("t", column("c"))
-        stmt = select([t])
+        stmt = select(t)
         a1 = stmt.alias()
         a2 = a1.alias()
 
@@ -3166,7 +3136,7 @@ class AliasTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_copy_internals_multiple_nesting(self):
         t = table("t", column("c"))
-        stmt = select([t])
+        stmt = select(t)
         a1 = stmt.alias()
         a2 = a1.alias()