python-sql 1.7.0__tar.gz → 1.8.0__tar.gz

python_sql-1.8.0/.gitignore

@@ -0,0 +1 @@
+Sync/dotfiles/git/dot-gitignore

python_sql-1.8.0/.hgignore

@@ -0,0 +1,7 @@
+syntax: glob
+*.py[cdo]
+*.egg-info
+dist/
+build/
+.tox/
+.coverage

{python_sql-1.7.0 → python_sql-1.8.0}/COPYRIGHT

@@ -1,6 +1,6 @@
-Copyright (c) 2011-2025, Cédric Krier
-Copyright (c) 2013-2025, Nicolas Évrard
-Copyright (c) 2011-2025, B2CK
+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

{python_sql-1.7.0 → python_sql-1.8.0}/PKG-INFO

@@ -1,45 +1,24 @@
 Metadata-Version: 2.4
 Name: python-sql
-Version: 1.7.0
+Version: 1.8.0
 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.7.0 → python_sql-1.8.0}/README.rst

@@ -39,14 +39,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::
 
@@ -54,7 +54,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::
 
@@ -93,9 +93,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::
 
@@ -129,20 +129,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::
 
@@ -152,13 +152,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::
 
@@ -185,7 +185,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::
 
@@ -193,7 +193,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::
 
@@ -201,4 +201,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.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ['hatchling >= 1', 'hatch-tryton']
+build-backend = 'hatchling.build'
+
+[project]
+name = 'python-sql'
+dynamic = ['version', 'authors']
+requires-python = '>=3.9'
+maintainers = [
+    {name = "Tryton", email = "foundation@tryton.org"},
+    ]
+description = "Library to write SQL queries"
+readme = 'README.rst'
+license = 'BSD-3-Clause'
+license-files = ['COPYRIGHT']
+keywords = ["SQL", "database", "query"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    ]
+
+[project.urls]
+homepage = "https://www.tryton.org/"
+changelog = "https://code.tryton.org/python-sql/-/blob/branch/default/CHANGELOG"
+forum = "https://discuss.tryton.org/tags/python-sql"
+issues = "https://bugs.tryton.org/python-sql"
+repository = "https://code.tryton.org/python-sql"
+
+[tool.hatch.version]
+path = 'sql/__init__.py'
+
+[tool.hatch.build]
+packages = ['sql']
+
+[tool.hatch.metadata.hooks.tryton]
+copyright = 'COPYRIGHT'

{python_sql-1.7.0 → python_sql-1.8.0}/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.0'
 __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)

{python_sql-1.7.0 → python_sql-1.8.0}/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):

{python_sql-1.7.0 → python_sql-1.8.0}/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'
 

{python_sql-1.7.0 → python_sql-1.8.0}/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):

{python_sql-1.7.0 → python_sql-1.8.0}/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,))