python-sql 1.7.0__py3-none-any.whl → 1.8.1__py3-none-any.whl

{python_sql-1.7.0.dist-info → python_sql-1.8.1.dist-info}/METADATA

@@ -1,45 +1,24 @@
 Metadata-Version: 2.4
 Name: python-sql
-Version: 1.7.0
+Version: 1.8.1
 Summary: Library to write SQL queries
-Home-page: https://pypi.org/project/python-sql/
-Download-URL: https://downloads.tryton.org/python-sql/
-Author: Tryton
-Author-email: foundation@tryton.org
-License: BSD
-Project-URL: Bug Tracker, https://bugs.tryton.org/python-sql
-Project-URL: Forum, https://discuss.tryton.org/tags/python-sql
-Project-URL: Source Code, https://code.tryton.org/python-sql
-Keywords: SQL database query
+Project-URL: homepage, https://www.tryton.org/
+Project-URL: changelog, https://code.tryton.org/python-sql/-/blob/branch/default/CHANGELOG
+Project-URL: forum, https://discuss.tryton.org/tags/python-sql
+Project-URL: issues, https://bugs.tryton.org/python-sql
+Project-URL: repository, https://code.tryton.org/python-sql
+Author: B2CK SRL
+Author-email: Cédric Krier <cedric.krier@b2ck.com>, Nicolas Évrard <nicolas.evrard@b2ck.com>
+Maintainer-email: Tryton <foundation@tryton.org>
+License-Expression: BSD-3-Clause
+License-File: COPYRIGHT
+Keywords: SQL,database,query
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.5
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: download-url
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: project-url
-Dynamic: requires-python
-Dynamic: summary
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
 
 python-sql
 ==========
@@ -82,14 +61,14 @@ Select with where condition::
 
     >>> select.where = user.name == 'foo'
     >>> tuple(select)
-    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE ("a"."name" = %s)', ('foo',))
+    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE "a"."name" = %s', ('foo',))
 
     >>> select.where = (user.name == 'foo') & (user.active == True)
     >>> tuple(select)
-    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE (("a"."name" = %s) AND ("a"."active" = %s))', ('foo', True))
+    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE ("a"."name" = %s) AND ("a"."active" = %s)', ('foo', True))
     >>> select.where = user.name == user.login
     >>> tuple(select)
-    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE ("a"."name" = "a"."login")', ())
+    ('SELECT "a"."id", "a"."name" FROM "user" AS "a" WHERE "a"."name" = "a"."login"', ())
 
 Select with join::
 
@@ -97,7 +76,7 @@ Select with join::
     >>> join.condition = join.right.user == user.id
     >>> select = join.select(user.name, join.right.group)
     >>> tuple(select)
-    ('SELECT "a"."name", "b"."group" FROM "user" AS "a" INNER JOIN "user_group" AS "b" ON ("b"."user" = "a"."id")', ())
+    ('SELECT "a"."name", "b"."group" FROM "user" AS "a" INNER JOIN "user_group" AS "b" ON "b"."user" = "a"."id"', ())
 
 Select with multiple joins::
 
@@ -136,9 +115,9 @@ Select with sub-select::
     ...     where=user_group.active == True)
     >>> user = Table('user')
     >>> tuple(user.select(user.id, where=user.id.in_(subselect)))
-    ('SELECT "a"."id" FROM "user" AS "a" WHERE ("a"."id" IN (SELECT "b"."user" FROM "user_group" AS "b" WHERE ("b"."active" = %s)))', (True,))
+    ('SELECT "a"."id" FROM "user" AS "a" WHERE "a"."id" IN (SELECT "b"."user" FROM "user_group" AS "b" WHERE "b"."active" = %s)', (True,))
     >>> tuple(subselect.select(subselect.user))
-    ('SELECT "a"."user" FROM (SELECT "b"."user" FROM "user_group" AS "b" WHERE ("b"."active" = %s)) AS "a"', (True,))
+    ('SELECT "a"."user" FROM (SELECT "b"."user" FROM "user_group" AS "b" WHERE "b"."active" = %s) AS "a"', (True,))
 
 Select on other schema::
 
@@ -172,20 +151,20 @@ Update query with values::
     >>> tuple(user.update(columns=[user.active], values=[True]))
     ('UPDATE "user" AS "a" SET "active" = %s', (True,))
     >>> tuple(invoice.update(columns=[invoice.total], values=[invoice.amount + invoice.tax]))
-    ('UPDATE "invoice" AS "a" SET "total" = ("a"."amount" + "a"."tax")', ())
+    ('UPDATE "invoice" AS "a" SET "total" = "a"."amount" + "a"."tax"', ())
 
 Update query with where condition::
 
     >>> tuple(user.update(columns=[user.active], values=[True],
     ...          where=user.active == False))
-    ('UPDATE "user" AS "a" SET "active" = %s WHERE ("a"."active" = %s)', (True, False))
+    ('UPDATE "user" AS "a" SET "active" = %s WHERE "a"."active" = %s', (True, False))
 
 Update query with from list::
 
     >>> group = Table('user_group')
     >>> tuple(user.update(columns=[user.active], values=[group.active],
     ...         from_=[group], where=user.id == group.user))
-    ('UPDATE "user" AS "b" SET "active" = "a"."active" FROM "user_group" AS "a" WHERE ("b"."id" = "a"."user")', ())
+    ('UPDATE "user" AS "b" SET "active" = "a"."active" FROM "user_group" AS "a" WHERE "b"."id" = "a"."user"', ())
 
 Delete query::
 
@@ -195,13 +174,13 @@ Delete query::
 Delete query with where condition::
 
     >>> tuple(user.delete(where=user.name == 'foo'))
-    ('DELETE FROM "user" WHERE ("name" = %s)', ('foo',))
+    ('DELETE FROM "user" WHERE "name" = %s', ('foo',))
 
 Delete query with sub-query::
 
     >>> tuple(user.delete(
     ...             where=user.id.in_(user_group.select(user_group.user))))
-    ('DELETE FROM "user" WHERE ("id" IN (SELECT "a"."user" FROM "user_group" AS "a"))', ())
+    ('DELETE FROM "user" WHERE "id" IN (SELECT "a"."user" FROM "user_group" AS "a")', ())
 
 Flavors::
 
@@ -228,7 +207,7 @@ Limit style::
     ('SELECT * FROM "user" AS "a" OFFSET (%s) ROWS FETCH FIRST (%s) ROWS ONLY', (20, 10))
     >>> Flavor.set(Flavor(limitstyle='rownum'))
     >>> tuple(select)
-    ('SELECT "a".* FROM (SELECT "b".*, ROWNUM AS "rnum" FROM (SELECT * FROM "user" AS "c") AS "b" WHERE (ROWNUM <= %s)) AS "a" WHERE ("rnum" > %s)', (30, 20))
+    ('SELECT "a".* FROM (SELECT "b".*, ROWNUM AS "rnum" FROM (SELECT * FROM "user" AS "c") AS "b" WHERE ROWNUM <= %s) AS "a" WHERE "rnum" > %s', (30, 20))
 
 qmark style::
 
@@ -236,7 +215,7 @@ qmark style::
     >>> select = user.select()
     >>> select.where = user.name == 'foo'
     >>> tuple(select)
-    ('SELECT * FROM "user" AS "a" WHERE ("a"."name" = ?)', ('foo',))
+    ('SELECT * FROM "user" AS "a" WHERE "a"."name" = ?', ('foo',))
 
 numeric style::
 
@@ -244,4 +223,4 @@ numeric style::
     >>> select = user.select()
     >>> select.where = user.name == 'foo'
     >>> format2numeric(*select)
-    ('SELECT * FROM "user" AS "a" WHERE ("a"."name" = :0)', ('foo',))
+    ('SELECT * FROM "user" AS "a" WHERE "a"."name" = :0', ('foo',))

python_sql-1.8.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+sql/__init__.py,sha256=PUwBTtKhP7r6YWZEtv-7IwYF3OgICgCgHDVPFNqiVOk,65346
+sql/aggregate.py,sha256=Spg5T4y8SSUN5Tyc7GUVB6I_69AhrVHVCkOgzFX482A,6008
+sql/conditionals.py,sha256=xJY6ffEBeES6CiGKErXSa2dK2FXaEaR_QQl_CKILP30,2541
+sql/functions.py,sha256=htradjtMpm9HfDlgSnjKi-rFWRvX5ch8odE-ngAah1I,14125
+sql/operators.py,sha256=wy_11xRXjk6ZclkA7nhJ4QTW0g7bEC45-LH6nmTXuYE,11480
+sql/tests/__init__.py,sha256=QA18gftL_tykRkbGriAobA3THDVu34v8Pdn-a2qJywY,679
+sql/tests/test_aggregate.py,sha256=dFoqNd1fqsyYN8rNX_EGSF1rKKFtiprVMfDmdH9TyYQ,3359
+sql/tests/test_alias.py,sha256=wtBwMkA8HADz3Tq6kz-MJXBG75hL0AbO2Z3LE7L2YTY,2408
+sql/tests/test_as.py,sha256=OfXDu0CnJ2paRKR29dMdx7q_Q9TFY60MWlvib6MR5LY,926
+sql/tests/test_cast.py,sha256=ejrqHQZwA3967UhszYR3caZYvH3waPcF6li4rnmxGi4,653
+sql/tests/test_collate.py,sha256=_RJM_t-YzCoO34b6k35jBoTyQedTK7EXywYosrK1bUQ,688
+sql/tests/test_column.py,sha256=_GkBkBzLW_fDoJy5yUWDtHTSyka1s5Drd4gDuvtIM_8,866
+sql/tests/test_combining_query.py,sha256=TyxcakaXq3gAKqdK5lRQqWhLzpmx1n03L_MTa55ZIXI,2413
+sql/tests/test_conditionals.py,sha256=Qlv10nzrHcqto-fZmEHW7mKFifQa_lmYSnrn7jBIRM0,2699
+sql/tests/test_delete.py,sha256=mLnfhKJwfKhsabYuenOXrDr5CTS2Lx_wIs3VQO-u9pM,2237
+sql/tests/test_excluded.py,sha256=aOdzg9oOTeaCPzQ2MOBC2F-KJl1hWI39MnM2cfaVSHs,388
+sql/tests/test_expression.py,sha256=39Z4hZXxUW6vJDmWMKJGpdf1tMP5i-1bfNaYvrHv2JY,457
+sql/tests/test_flavor.py,sha256=ho8wjHDbZDVB0NYN_lCPL3MdyzBhYYfCxolR1wQv3qU,1240
+sql/tests/test_for.py,sha256=_qk3ovyPtcq4XBK21OzmovLPiqgSvhGc4nhpX8IYC4s,651
+sql/tests/test_from.py,sha256=USwyW8WnbRO_oQBc-Fmgv9rwhARY2bOF-k5ZBxozyIw,713
+sql/tests/test_from_item.py,sha256=SJosqjO8UKPNppgtYRN_HKFlu17j5Aw6OVAQ4BGSNXo,1177
+sql/tests/test_functions.py,sha256=SmH9GNJNSUdEzwlWNeRgGH3kD3KPMPq3FdKwPULMU6Q,7074
+sql/tests/test_grouping.py,sha256=hdUOeEhYIuKxvLrSmkFZlIW93uMq8exbtp9XqEodgEE,338
+sql/tests/test_insert.py,sha256=yxQwN0GM6dHbXEoTRhle-W7ad_mAy_gHFWd6uhU-u1c,9359
+sql/tests/test_join.py,sha256=xJtwC5OjCDXqG8FR-Ga6zds4TORReY70p-RHZuuv0no,2639
+sql/tests/test_lateral.py,sha256=uNPIo-AvMmD7mSwAtPSB0FlHXRRUF4B43G-iKBJFizA,1045
+sql/tests/test_literal.py,sha256=ht-VLhGdpUm_rbtOzpQgbX3YQup_xp7F9va0RSWY0Ts,1010
+sql/tests/test_merge.py,sha256=JEwJ7hJ6Wpg_MqNcdA8uEog6_NQVtxuR-_IEQWpvAWQ,5436
+sql/tests/test_operators.py,sha256=K-B5Rh8-sy88aTjuCsQqxXaK6xKBqMzar8TKSsPLiJk,16752
+sql/tests/test_order.py,sha256=dcBGxPxaGW5S-zMWOZcWFZdgfVjEg0NSg60MCydVpMw,2266
+sql/tests/test_rollup.py,sha256=Ae7PVTnyELICcjC00dkcAiHzr61NG8cnIcAoHagHr98,339
+sql/tests/test_select.py,sha256=czr2Ss6kSPZL5LLpCbVQguBJ_QsSl7PeWdyjTx7Yz_8,23346
+sql/tests/test_table.py,sha256=ZF6VzLcx54ulj69Qnt0hdQ7_XamAqpofyTKs0WiGB4E,758
+sql/tests/test_update.py,sha256=09r_9047luX4WN0paJJBjchZGhFileZcavq1R1TqGV8,3772
+sql/tests/test_values.py,sha256=qKvaFSDEQmVWajWhMZgqD2-rQcWJeW_nsevVMsV3jD8,1053
+sql/tests/test_window.py,sha256=EpqjZX2cyQ-m7UWMubrB5MOtL_5uF8jSnNhODfE74xc,3183
+sql/tests/test_with.py,sha256=Ff9LYEnXsu6062bF6C86uZFwdYlpwswuvc1cdBZs8HY,2363
+python_sql-1.8.1.dist-info/METADATA,sha256=ywZsOeYln70IyzXLIkiB2VdN-VUr37qY6kiHoaSZtxc,8146
+python_sql-1.8.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_sql-1.8.1.dist-info/licenses/COPYRIGHT,sha256=qxgK78Jt_bk7V59177UafkZEm4lS6KVUuUp0DM24lIA,1627
+python_sql-1.8.1.dist-info/RECORD,,

{python_sql-1.7.0.dist-info → python_sql-1.8.1.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

python_sql-1.8.1.dist-info/licenses/COPYRIGHT

@@ -0,0 +1,26 @@
+Copyright (c) 2011-2026 Cédric Krier <cedric.krier@b2ck.com>
+Copyright (c) 2013-2025 Nicolas Évrard <nicolas.evrard@b2ck.com>
+Copyright (c) 2011-2026 B2CK SRL
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

sql/__init__.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from itertools import chain
 from threading import current_thread, local
 
-__version__ = '1.7.0'
+__version__ = '1.8.1'
 __all__ = [
     'Flavor', 'Table', 'Values', 'Literal', 'Column', 'Grouping', 'Conflict',
     'Matched', 'MatchedUpdate', 'MatchedDelete',
@@ -629,6 +629,27 @@ class Select(FromItem, SelectQuery):
                 and (self.limit is not None or self.offset is not None)):
             return self._rownum(str)
 
+        ordinals = {}
+        for expression in chain(
+                self.group_by or [],
+                self.order_by or []):
+            if not isinstance(expression, As):
+                continue
+            for i, column in enumerate(self.columns, start=1):
+                if not isinstance(column, As):
+                    continue
+                if column.output_name != expression.output_name:
+                    continue
+                if (str(column.expression) != str(expression.expression)
+                        or column.params != expression.params):
+                    raise ValueError("%r != %r" % (expression, column))
+                ordinals[column.output_name] = i
+
+        def str_or_ordinal(expression):
+            if isinstance(expression, As):
+                expression = ordinals.get(expression.output_name, expression)
+            return str(expression)
+
         with AliasManager():
             if self.from_ is not None:
                 from_ = ' FROM %s' % self.from_
@@ -657,7 +678,8 @@ class Select(FromItem, SelectQuery):
                 where = ' WHERE ' + str(self.where)
             group_by = ''
             if self.group_by:
-                group_by = ' GROUP BY ' + ', '.join(map(str, self.group_by))
+                group_by = ' GROUP BY ' + ', '.join(
+                    map(str_or_ordinal, self.group_by))
             having = ''
             if self.having:
                 having = ' HAVING ' + str(self.having)

sql/functions.py

@@ -1,5 +1,7 @@
 # This file is part of python-sql.  The COPYRIGHT file at the top level of
 # this repository contains the full copyright notices and license terms.
+
+from enum import Enum, auto
 from itertools import chain
 
 from sql import CombiningQuery, Expression, Flavor, FromItem, Select, Window
@@ -85,7 +87,7 @@ class FunctionKeyword(Function):
         return (self._function + '('
             + ' '.join(chain(*zip(
                         self._keywords,
-                        map(self._format, self.args))))[1:]
+                        map(self._format, self.args)))).strip()
             + ')')
 
 
@@ -383,9 +385,67 @@ class DateTrunc(Function):
 
 
 class Extract(FunctionKeyword):
-    __slots__ = ()
+    __slots__ = ('_field',)
     _function = 'EXTRACT'
-    _keywords = ('', 'FROM')
+
+    class Fields(str, Enum):
+        def _generate_next_value_(name, start, count, last_values):
+            return name.upper()
+
+        CENTURY = auto()
+        DAY = auto()
+        DECADE = auto()
+        DOW = auto()
+        DOY = auto()
+        EPOCH = auto()
+        HOUR = auto()
+        ISODOW = auto()
+        ISOYEAR = auto()
+        JULIAN = auto()
+        MICROSECONDS = auto()
+        MILLENNIUM = auto()
+        MILLISECONDS = auto()
+        MINUTE = auto()
+        MONTH = auto()
+        QUARTER = auto()
+        SECOND = auto()
+        TIMEZONE = auto()
+        TIMEZONE_HOUR = auto()
+        TIMEZONE_MINUTE = auto()
+        WEEK = auto()
+        YEAR = auto()
+
+    def __init__(self, field, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.field = field
+
+    @property
+    def field(self):
+        return self._field
+
+    @field.setter
+    def field(self, value):
+        value = value.upper()
+        if not hasattr(self.Fields, value):
+            raise ValueError("invalid field: %r" % value)
+        self._field = value
+
+    @property
+    def _keywords(self):
+        return ('%s FROM' % self.field,)
+
+    def __str__(self):
+        Mapping = Flavor.get().function_mapping.get(self.__class__)
+        if Mapping:
+            return str(Mapping(self.field, *self.args))
+        return super().__str__()
+
+    @property
+    def params(self):
+        Mapping = Flavor.get().function_mapping.get(self.__class__)
+        if Mapping:
+            return Mapping(self.field, *self.args).params
+        return super().params
 
 
 class Isfinite(Function):

sql/operators.py

@@ -48,9 +48,11 @@ class Operator(Expression):
     def _format(self, operand, param=None):
         if param is None:
             param = Flavor.get().param
-        if isinstance(operand, Expression):
+        if (isinstance(operand, Expression)
+                and (not isinstance(operand, Operator)
+                    or isinstance(operand, UnaryOperator))):
             return str(operand)
-        elif isinstance(operand, (Select, CombiningQuery)):
+        elif isinstance(operand, (Expression, Select, CombiningQuery)):
             return '(%s)' % operand
         elif isinstance(operand, (list, tuple)):
             return '(' + ', '.join(self._format(o, param)
@@ -88,7 +90,7 @@ class UnaryOperator(Operator):
         return (self.operand,)
 
     def __str__(self):
-        return '(%s %s)' % (self._operator, self._format(self.operand))
+        return '%s %s' % (self._operator, self._format(self.operand))
 
 
 class BinaryOperator(Operator):
@@ -105,7 +107,7 @@ class BinaryOperator(Operator):
 
     def __str__(self):
         left, right = self._operands
-        return '(%s %s %s)' % (self._format(left), self._operator,
+        return '%s %s %s' % (self._format(left), self._operator,
             self._format(right))
 
     def __invert__(self):
@@ -121,8 +123,7 @@ class NaryOperator(list, Operator):
         return self
 
     def __str__(self):
-        return '(' + (' %s ' % self._operator).join(
-            map(self._format, self)) + ')'
+        return (' %s ' % self._operator).join(map(self._format, self))
 
 
 class And(NaryOperator):
@@ -184,9 +185,9 @@ class Equal(BinaryOperator):
 
     def __str__(self):
         if self.left is Null:
-            return '(%s IS NULL)' % self.right
+            return '%s IS NULL' % self.right
         elif self.right is Null:
-            return '(%s IS NULL)' % self.left
+            return '%s IS NULL' % self.left
         return super(Equal, self).__str__()
 
 
@@ -196,9 +197,9 @@ class NotEqual(Equal):
 
     def __str__(self):
         if self.left is Null:
-            return '(%s IS NOT NULL)' % self.right
+            return '%s IS NOT NULL' % self.right
         elif self.right is Null:
-            return '(%s IS NOT NULL)' % self.left
+            return '%s IS NOT NULL' % self.left
         return super(Equal, self).__str__()
 
 
@@ -220,7 +221,7 @@ class Between(Operator):
         operator = self._operator
         if self.symmetric:
             operator += ' SYMMETRIC'
-        return '(%s %s %s AND %s)' % (
+        return '%s %s %s AND %s' % (
             self._format(self.operand), operator,
             self._format(self.left), self._format(self.right))
 
@@ -259,12 +260,12 @@ class Is(BinaryOperator):
 
     def __str__(self):
         if self.right is None:
-            return '(%s %s UNKNOWN)' % (
+            return '%s %s UNKNOWN' % (
                 self._format(self.left), self._operator)
         elif self.right is True:
-            return '(%s %s TRUE)' % (self._format(self.left), self._operator)
+            return '%s %s TRUE' % (self._format(self.left), self._operator)
         elif self.right is False:
-            return '(%s %s FALSE)' % (self._format(self.left), self._operator)
+            return '%s %s FALSE' % (self._format(self.left), self._operator)
 
 
 class IsNot(Is):
@@ -395,11 +396,11 @@ class Like(BinaryOperator):
     def __str__(self):
         left, right = self._operands
         if self.escape or Flavor().get().escape_empty:
-            return '(%s %s %s ESCAPE %s)' % (
+            return '%s %s %s ESCAPE %s' % (
                 self._format(left), self._operator, self._format(right),
                 self._format(self.escape or ''))
         else:
-            return '(%s %s %s)' % (
+            return '%s %s %s' % (
                 self._format(left), self._operator, self._format(right))
 
     def __invert__(self):
@@ -458,7 +459,24 @@ class Exists(UnaryOperator):
     _operator = 'EXISTS'
 
 
-class Any(UnaryOperator):
+class _ArrayOperator(UnaryOperator):
+    __slots__ = ()
+
+    @property
+    def params(self):
+        if isinstance(self.operand, (list, tuple, array)):
+            return (list(self.operand),)
+        return super().params
+
+    def _format(self, operand, param=None):
+        if param is None:
+            param = Flavor.get().param
+        if isinstance(operand, (list, tuple, array)):
+            return '(%s)' % param
+        return super()._format(operand, param=param)
+
+
+class Any(_ArrayOperator):
     __slots__ = ()
     _operator = 'ANY'
 
@@ -466,7 +484,7 @@ class Any(UnaryOperator):
 Some = Any
 
 
-class All(UnaryOperator):
+class All(_ArrayOperator):
     __slots__ = ()
     _operator = 'ALL'
 

sql/tests/test_aggregate.py

@@ -38,7 +38,7 @@ class TestAggregate(unittest.TestCase):
         self.assertEqual(str(avg), 'AVG("c")')
 
         avg = Avg(self.table.a + self.table.b)
-        self.assertEqual(str(avg), 'AVG(("a" + "b"))')
+        self.assertEqual(str(avg), 'AVG("a" + "b")')
 
     def test_count_without_expression(self):
         count = Count()
@@ -67,7 +67,7 @@ class TestAggregate(unittest.TestCase):
         try:
             avg = Avg(self.table.a + 1, filter_=self.table.a > 0)
             self.assertEqual(
-                str(avg), 'AVG(("a" + %s)) FILTER (WHERE ("a" > %s))')
+                str(avg), 'AVG("a" + %s) FILTER (WHERE "a" > %s)')
             self.assertEqual(avg.params, (1, 0))
         finally:
             Flavor.set(Flavor())
@@ -75,13 +75,13 @@ class TestAggregate(unittest.TestCase):
     def test_filter_case(self):
         avg = Avg(self.table.a + 1, filter_=self.table.a > 0)
         self.assertEqual(
-            str(avg), 'AVG(CASE WHEN ("a" > %s) THEN ("a" + %s) END)')
+            str(avg), 'AVG(CASE WHEN "a" > %s THEN "a" + %s END)')
         self.assertEqual(avg.params, (0, 1))
 
     def test_filter_case_count_star(self):
         count = Count(Literal('*'), filter_=self.table.a > 0)
         self.assertEqual(
-            str(count), 'COUNT(CASE WHEN ("a" > %s) THEN %s END)')
+            str(count), 'COUNT(CASE WHEN "a" > %s THEN %s END)')
         self.assertEqual(count.params, (0, 1))
 
     def test_window(self):

sql/tests/test_combining_query.py

@@ -33,7 +33,7 @@ class TestUnion(unittest.TestCase):
 
         self.assertEqual(str(query),
             'WITH "a" AS ('
-            'SELECT "b"."id" FROM "t" AS "b" WHERE ("b"."id" = %s)) '
+            'SELECT "b"."id" FROM "t" AS "b" WHERE "b"."id" = %s) '
             'SELECT * FROM "t1" AS "c" UNION SELECT * FROM "t2" AS "d"')
         self.assertEqual(tuple(query.params), (1,))
 

sql/tests/test_conditionals.py

@@ -36,9 +36,9 @@ class TestConditionals(unittest.TestCase):
                 where=self.table.c2 == 'foo'))
         self.assertEqual(str(case),
             'CASE WHEN '
-            '(SELECT "a"."bool" FROM "t" AS "a" WHERE ("a"."c2" = %s)) '
+            '(SELECT "a"."bool" FROM "t" AS "a" WHERE "a"."c2" = %s) '
             'THEN "c1" '
-            'ELSE (SELECT "a"."c1" FROM "t" AS "a" WHERE ("a"."c2" = %s)) END')
+            'ELSE (SELECT "a"."c1" FROM "t" AS "a" WHERE "a"."c2" = %s) END')
         self.assertEqual(case.params, ('bar', 'foo'))
 
     def test_coalesce(self):
@@ -52,7 +52,7 @@ class TestConditionals(unittest.TestCase):
             self.table.c2)
         self.assertEqual(str(coalesce),
             'COALESCE('
-            '(SELECT "a"."c1" FROM "t" AS "a" WHERE ("a"."c2" = %s)), "c2")')
+            '(SELECT "a"."c1" FROM "t" AS "a" WHERE "a"."c2" = %s), "c2")')
         self.assertEqual(coalesce.params, ('bar',))
 
     def test_nullif(self):

sql/tests/test_delete.py

@@ -15,7 +15,7 @@ class TestDelete(unittest.TestCase):
 
     def test_delete2(self):
         query = self.table.delete(where=(self.table.c == 'foo'))
-        self.assertEqual(str(query), 'DELETE FROM "t" WHERE ("c" = %s)')
+        self.assertEqual(str(query), 'DELETE FROM "t" WHERE "c" = %s')
         self.assertEqual(query.params, ('foo',))
 
     def test_delete3(self):
@@ -23,8 +23,8 @@ class TestDelete(unittest.TestCase):
         t2 = Table('t2')
         query = t1.delete(where=(t1.c.in_(t2.select(t2.c))))
         self.assertEqual(str(query),
-            'DELETE FROM "t1" WHERE ("c" IN ('
-            'SELECT "a"."c" FROM "t2" AS "a"))')
+            'DELETE FROM "t1" WHERE "c" IN ('
+            'SELECT "a"."c" FROM "t2" AS "a")')
         self.assertEqual(query.params, ())
 
     def test_delete_invalid_table(self):
@@ -61,5 +61,5 @@ class TestDelete(unittest.TestCase):
         self.assertEqual(str(query),
             'WITH "a" AS (SELECT "b"."c1" FROM "t1" AS "b") '
             'DELETE FROM "t" WHERE '
-            '("c2" IN (SELECT "a"."c3" FROM "a" AS "a"))')
+            '"c2" IN (SELECT "a"."c3" FROM "a" AS "a")')
         self.assertEqual(query.params, ())