Update select usage to use the new 1.4 format

This change includes mainly that the bracketed use within
select() is moved to positional, and keyword arguments are
removed from calls to the select() function.  it does not
yet fully address other issues such as keyword arguments passed
to the table.select().

Additionally, allows False / None to both be considered
as "disable" for all of select.correlate(), select.correlate_except(),
query.correlate(), which establishes consistency with
passing of ``False`` for the legact select(correlate=False)
argument.

Change-Id: Ie6c6e6abfbd3d75d4c8de504c0cf0159e6999108

3 files changed, 80 insertions, 122 deletions

diff --git a/test/dialect/postgresql/test_compiler.py b/test/dialect/postgresql/test_compiler.py
index 556601fc6..ddf03daf1 100644
--- a/test/dialect/postgresql/test_compiler.py
+++ b/test/dialect/postgresql/test_compiler.py
@@ -1646,7 +1646,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
         series = func.generate_series(1, 100).alias("series")
         series_col = column("series")
         query = select(
-            [func.array_agg(series_col).filter(series_col % 2 == 0)[3]]
+            func.array_agg(series_col).filter(series_col % 2 == 0)[3]
         ).select_from(series)
         self.assert_compile(
             query,
@@ -2143,22 +2143,22 @@ class DistinctOnTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_plain_inline(self):
         self.assert_compile(
-            select([self.table], distinct=True),
+            select(self.table).distinct(),
             "SELECT DISTINCT t.id, t.a, t.b FROM t",
         )
 
     def test_on_columns_inline_list(self):
         self.assert_compile(
-            select(
-                [self.table], distinct=[self.table.c.a, self.table.c.b]
-            ).order_by(self.table.c.a, self.table.c.b),
+            select(self.table)
+            .distinct(self.table.c.a, self.table.c.b)
+            .order_by(self.table.c.a, self.table.c.b),
             "SELECT DISTINCT ON (t.a, t.b) t.id, "
             "t.a, t.b FROM t ORDER BY t.a, t.b",
         )
 
     def test_on_columns_inline_scalar(self):
         self.assert_compile(
-            select([self.table], distinct=self.table.c.a),
+            select(self.table).distinct(self.table.c.a),
             "SELECT DISTINCT ON (t.a) t.id, t.a, t.b FROM t",
         )
 
diff --git a/test/dialect/postgresql/test_query.py b/test/dialect/postgresql/test_query.py
index eb96eaabb..eec6eed4a 100644
--- a/test/dialect/postgresql/test_query.py
+++ b/test/dialect/postgresql/test_query.py
@@ -863,21 +863,19 @@ class TupleTest(fixtures.TestBase):
             eq_(
                 connection.execute(
                     select(
-                        [
-                            tuple_(
-                                literal_column("'a'"), literal_column("'b'")
-                            ).in_(
-                                [
-                                    tuple_(
-                                        *[
-                                            literal_column("'%s'" % letter)
-                                            for letter in elem
-                                        ]
-                                    )
-                                    for elem in test
-                                ]
-                            )
-                        ]
+                        tuple_(
+                            literal_column("'a'"), literal_column("'b'")
+                        ).in_(
+                            [
+                                tuple_(
+                                    *[
+                                        literal_column("'%s'" % letter)
+                                        for letter in elem
+                                    ]
+                                )
+                                for elem in test
+                            ]
+                        )
                     )
                 ).scalar(),
                 exp,
diff --git a/test/dialect/postgresql/test_types.py b/test/dialect/postgresql/test_types.py
index 8ec848bb5..2d1fd4ee8 100644
--- a/test/dialect/postgresql/test_types.py
+++ b/test/dialect/postgresql/test_types.py
@@ -991,7 +991,7 @@ class TimezoneTest(fixtures.TestBase):
         assert somedate.tzinfo
         connection.execute(tztable.insert(), id=1, name="row1", date=somedate)
         row = connection.execute(
-            select([tztable.c.date], tztable.c.id == 1)
+            select(tztable.c.date).where(tztable.c.id == 1)
         ).first()
         eq_(row[0], somedate)
         eq_(
@@ -1015,7 +1015,7 @@ class TimezoneTest(fixtures.TestBase):
             notztable.insert(), id=1, name="row1", date=somedate
         )
         row = connection.execute(
-            select([notztable.c.date], notztable.c.id == 1)
+            select(notztable.c.date).where(notztable.c.id == 1)
         ).first()
         eq_(row[0], somedate)
         eq_(row[0].tzinfo, None)
@@ -1171,7 +1171,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_int_index(self):
         col = column("x", postgresql.ARRAY(Integer))
         self.assert_compile(
-            select([col[3]]),
+            select(col[3]),
             "SELECT x[%(x_1)s] AS anon_1",
             checkparams={"x_1": 3},
         )
@@ -1195,7 +1195,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_contains(self):
         col = column("x", postgresql.ARRAY(Integer))
         self.assert_compile(
-            select([col.contains(array([4, 5, 6]))]),
+            select(col.contains(array([4, 5, 6]))),
             "SELECT x @> ARRAY[%(param_1)s, %(param_2)s, %(param_3)s] "
             "AS anon_1",
             checkparams={"param_1": 4, "param_3": 6, "param_2": 5},
@@ -1213,7 +1213,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_contained_by(self):
         col = column("x", postgresql.ARRAY(Integer))
         self.assert_compile(
-            select([col.contained_by(array([4, 5, 6]))]),
+            select(col.contained_by(array([4, 5, 6]))),
             "SELECT x <@ ARRAY[%(param_1)s, %(param_2)s, %(param_3)s] "
             "AS anon_1",
             checkparams={"param_1": 4, "param_3": 6, "param_2": 5},
@@ -1222,7 +1222,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_overlap(self):
         col = column("x", postgresql.ARRAY(Integer))
         self.assert_compile(
-            select([col.overlap(array([4, 5, 6]))]),
+            select(col.overlap(array([4, 5, 6]))),
             "SELECT x && ARRAY[%(param_1)s, %(param_2)s, %(param_3)s] "
             "AS anon_1",
             checkparams={"param_1": 4, "param_3": 6, "param_2": 5},
@@ -1231,7 +1231,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_slice_index(self):
         col = column("x", postgresql.ARRAY(Integer))
         self.assert_compile(
-            select([col[5:10]]),
+            select(col[5:10]),
             "SELECT x[%(x_1)s:%(x_2)s] AS anon_1",
             checkparams={"x_2": 10, "x_1": 5},
         )
@@ -1239,7 +1239,7 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
     def test_array_dim_index(self):
         col = column("x", postgresql.ARRAY(Integer, dimensions=2))
         self.assert_compile(
-            select([col[3][5]]),
+            select(col[3][5]),
             "SELECT x[%(x_1)s][%(param_1)s] AS anon_1",
             checkparams={"x_1": 3, "param_1": 5},
         )
@@ -1298,13 +1298,11 @@ class ArrayTest(AssertsCompiledSQL, fixtures.TestBase):
 
         """
         stmt = select(
-            [
-                func.array_cat(
-                    array([1, 2, 3]),
-                    array([4, 5, 6]),
-                    type_=postgresql.ARRAY(Integer),
-                )[2:5]
-            ]
+            func.array_cat(
+                array([1, 2, 3]),
+                array([4, 5, 6]),
+                type_=postgresql.ARRAY(Integer),
+            )[2:5]
         )
         self.assert_compile(
             stmt,
@@ -1412,53 +1410,47 @@ class ArrayRoundTripTest(object):
         stmt = select(func.array_agg(values_table.c.value))
         eq_(connection.execute(stmt).scalar(), list(range(1, 10)))
 
-        stmt = select([func.array_agg(values_table.c.value)[3]])
+        stmt = select(func.array_agg(values_table.c.value)[3])
         eq_(connection.execute(stmt).scalar(), 3)
 
-        stmt = select([func.array_agg(values_table.c.value)[2:4]])
+        stmt = select(func.array_agg(values_table.c.value)[2:4])
         eq_(connection.execute(stmt).scalar(), [2, 3, 4])
 
     def test_array_index_slice_exprs(self, connection):
         """test a variety of expressions that sometimes need parenthesizing"""
 
-        stmt = select([array([1, 2, 3, 4])[2:3]])
+        stmt = select(array([1, 2, 3, 4])[2:3])
         eq_(connection.execute(stmt).scalar(), [2, 3])
 
-        stmt = select([array([1, 2, 3, 4])[2]])
+        stmt = select(array([1, 2, 3, 4])[2])
         eq_(connection.execute(stmt).scalar(), 2)
 
-        stmt = select([(array([1, 2]) + array([3, 4]))[2:3]])
+        stmt = select((array([1, 2]) + array([3, 4]))[2:3])
         eq_(connection.execute(stmt).scalar(), [2, 3])
 
-        stmt = select([array([1, 2]) + array([3, 4])[2:3]])
+        stmt = select(array([1, 2]) + array([3, 4])[2:3])
         eq_(connection.execute(stmt).scalar(), [1, 2, 4])
 
-        stmt = select([array([1, 2])[2:3] + array([3, 4])])
+        stmt = select(array([1, 2])[2:3] + array([3, 4]))
         eq_(connection.execute(stmt).scalar(), [2, 3, 4])
 
         stmt = select(
-            [
-                func.array_cat(
-                    array([1, 2, 3]),
-                    array([4, 5, 6]),
-                    type_=self.ARRAY(Integer),
-                )[2:5]
-            ]
+            func.array_cat(
+                array([1, 2, 3]), array([4, 5, 6]), type_=self.ARRAY(Integer),
+            )[2:5]
         )
         eq_(connection.execute(stmt).scalar(), [2, 3, 4, 5])
 
     def test_any_all_exprs_array(self, connection):
         stmt = select(
-            [
-                3
-                == any_(
-                    func.array_cat(
-                        array([1, 2, 3]),
-                        array([4, 5, 6]),
-                        type_=self.ARRAY(Integer),
-                    )
+            3
+            == any_(
+                func.array_cat(
+                    array([1, 2, 3]),
+                    array([4, 5, 6]),
+                    type_=self.ARRAY(Integer),
                 )
-            ]
+            )
         )
         eq_(connection.execute(stmt).scalar(), True)
 
@@ -1510,7 +1502,7 @@ class ArrayRoundTripTest(object):
             strarr=[util.u("abc"), util.u("def")],
         )
         results = connection.execute(
-            select([arrtable.c.intarr + [4, 5, 6]])
+            select(arrtable.c.intarr + [4, 5, 6])
         ).fetchall()
         eq_(len(results), 1)
         eq_(results[0][0], [1, 2, 3, 4, 5, 6])
@@ -1554,9 +1546,7 @@ class ArrayRoundTripTest(object):
     def test_array_literal_roundtrip(self, connection):
         eq_(
             connection.scalar(
-                select(
-                    [postgresql.array([1, 2]) + postgresql.array([3, 4, 5])]
-                )
+                select(postgresql.array([1, 2]) + postgresql.array([3, 4, 5]))
             ),
             [1, 2, 3, 4, 5],
         )
@@ -1564,12 +1554,7 @@ class ArrayRoundTripTest(object):
         eq_(
             connection.scalar(
                 select(
-                    [
-                        (
-                            postgresql.array([1, 2])
-                            + postgresql.array([3, 4, 5])
-                        )[3]
-                    ]
+                    (postgresql.array([1, 2]) + postgresql.array([3, 4, 5]))[3]
                 )
             ),
             3,
@@ -1578,11 +1563,8 @@ class ArrayRoundTripTest(object):
         eq_(
             connection.scalar(
                 select(
-                    [
-                        (
-                            postgresql.array([1, 2])
-                            + postgresql.array([3, 4, 5])
-                        )[2:4]
+                    (postgresql.array([1, 2]) + postgresql.array([3, 4, 5]))[
+                        2:4
                     ]
                 )
             ),
@@ -1593,14 +1575,9 @@ class ArrayRoundTripTest(object):
         eq_(
             connection.scalar(
                 select(
-                    [
-                        postgresql.array(
-                            [
-                                postgresql.array([1, 2]),
-                                postgresql.array([3, 4]),
-                            ]
-                        )
-                    ]
+                    postgresql.array(
+                        [postgresql.array([1, 2]), postgresql.array([3, 4])]
+                    )
                 )
             ),
             [[1, 2], [3, 4]],
@@ -1609,14 +1586,9 @@ class ArrayRoundTripTest(object):
         eq_(
             connection.scalar(
                 select(
-                    [
-                        postgresql.array(
-                            [
-                                postgresql.array([1, 2]),
-                                postgresql.array([3, 4]),
-                            ]
-                        )[2][1]
-                    ]
+                    postgresql.array(
+                        [postgresql.array([1, 2]), postgresql.array([3, 4])]
+                    )[2][1]
                 )
             ),
             3,
@@ -1624,16 +1596,16 @@ class ArrayRoundTripTest(object):
 
     def test_array_literal_compare(self, connection):
         eq_(
-            connection.scalar(select([postgresql.array([1, 2]) < [3, 4, 5]])),
+            connection.scalar(select(postgresql.array([1, 2]) < [3, 4, 5])),
             True,
         )
 
     def test_array_getitem_single_exec(self, connection):
         arrtable = self.tables.arrtable
         self._fixture_456(arrtable)
-        eq_(connection.scalar(select([arrtable.c.intarr[2]])), 5)
+        eq_(connection.scalar(select(arrtable.c.intarr[2])), 5)
         connection.execute(arrtable.update().values({arrtable.c.intarr[2]: 7}))
-        eq_(connection.scalar(select([arrtable.c.intarr[2]])), 7)
+        eq_(connection.scalar(select(arrtable.c.intarr[2])), 7)
 
     def test_array_getitem_slice_exec(self, connection):
         arrtable = self.tables.arrtable
@@ -1642,11 +1614,11 @@ class ArrayRoundTripTest(object):
             intarr=[4, 5, 6],
             strarr=[util.u("abc"), util.u("def")],
         )
-        eq_(connection.scalar(select([arrtable.c.intarr[2:3]])), [5, 6])
+        eq_(connection.scalar(select(arrtable.c.intarr[2:3])), [5, 6])
         connection.execute(
             arrtable.update().values({arrtable.c.intarr[2:3]: [7, 8]})
         )
-        eq_(connection.scalar(select([arrtable.c.intarr[2:3]])), [7, 8])
+        eq_(connection.scalar(select(arrtable.c.intarr[2:3])), [7, 8])
 
     def test_multi_dim_roundtrip(self, connection):
         arrtable = self.tables.arrtable
@@ -1791,7 +1763,7 @@ class PGArrayRoundTripTest(
         connection.execute(arrtable.insert(), intarr=[6, 5, 4])
         eq_(
             connection.scalar(
-                select([arrtable.c.intarr.contained_by([4, 5, 6, 7])])
+                select(arrtable.c.intarr.contained_by([4, 5, 6, 7]))
             ),
             True,
         )
@@ -2591,12 +2563,10 @@ class HStoreRoundTripTest(fixtures.TablesTest):
     def _test_fixed_round_trip(self, engine):
         with engine.begin() as conn:
             s = select(
-                [
-                    hstore(
-                        array(["key1", "key2", "key3"]),
-                        array(["value1", "value2", "value3"]),
-                    )
-                ]
+                hstore(
+                    array(["key1", "key2", "key3"]),
+                    array(["value1", "value2", "value3"]),
+                )
             )
             eq_(
                 conn.scalar(s),
@@ -2615,24 +2585,14 @@ class HStoreRoundTripTest(fixtures.TablesTest):
     def _test_unicode_round_trip(self, engine):
         with engine.begin() as conn:
             s = select(
-                [
-                    hstore(
-                        array(
-                            [
-                                util.u("réveillé"),
-                                util.u("drôle"),
-                                util.u("S’il"),
-                            ]
-                        ),
-                        array(
-                            [
-                                util.u("réveillé"),
-                                util.u("drôle"),
-                                util.u("S’il"),
-                            ]
-                        ),
-                    )
-                ]
+                hstore(
+                    array(
+                        [util.u("réveillé"), util.u("drôle"), util.u("S’il")]
+                    ),
+                    array(
+                        [util.u("réveillé"), util.u("drôle"), util.u("S’il")]
+                    ),
+                )
             )
             eq_(
                 conn.scalar(s),
@@ -3303,7 +3263,7 @@ class JSONRoundTripTest(fixtures.TablesTest):
         self._fixture_data(engine)
         data_table = self.tables.data_table
         result = connection.execute(
-            select([data_table.c.data["k1"].astext])
+            select(data_table.c.data["k1"].astext)
         ).first()
         if engine.dialect.returns_unicode_strings:
             assert isinstance(result[0], util.text_type)
@@ -3315,7 +3275,7 @@ class JSONRoundTripTest(fixtures.TablesTest):
         self._fixture_data(engine)
         data_table = self.tables.data_table
         result = connection.execute(
-            select([data_table.c.data["k3"].astext.cast(Integer)]).where(
+            select(data_table.c.data["k3"].astext.cast(Integer)).where(
                 data_table.c.name == "r5"
             )
         ).first()