details: https://code.tryton.org/python-sql/commit/05c585f43f17
branch: default
user: Cédric Krier <[email protected]>
date: Wed Dec 24 10:37:11 2025 +0100
description:
Remove the parentheses around the unary and binary operators
Closes #98
diffstat:
CHANGELOG | 1 +
README.rst | 28 ++++----
sql/operators.py | 32 ++++----
sql/tests/test_aggregate.py | 8 +-
sql/tests/test_combining_query.py | 2 +-
sql/tests/test_conditionals.py | 6 +-
sql/tests/test_delete.py | 8 +-
sql/tests/test_functions.py | 6 +-
sql/tests/test_insert.py | 8 +-
sql/tests/test_join.py | 4 +-
sql/tests/test_lateral.py | 2 +-
sql/tests/test_merge.py | 24 +++---
sql/tests/test_operators.py | 125 ++++++++++++++++++-------------------
sql/tests/test_order.py | 6 +-
sql/tests/test_select.py | 52 +++++++-------
sql/tests/test_update.py | 12 +-
sql/tests/test_with.py | 6 +-
17 files changed, 165 insertions(+), 165 deletions(-)
diffs (1218 lines):
diff -r b1dfdb4a20c5 -r 05c585f43f17 CHANGELOG
--- a/CHANGELOG Wed Dec 24 12:01:06 2025 +0100
+++ b/CHANGELOG Wed Dec 24 10:37:11 2025 +0100
@@ -1,3 +1,4 @@
+* Remove the parentheses around the unary and binary operators
* Use the ordinal number as aliases for GROUP BY
* Check the coherence of the aliases of GROUP BY and ORDER BY expressions
* Do not use parameter for EXTRACT field
diff -r b1dfdb4a20c5 -r 05c585f43f17 README.rst
--- a/README.rst Wed Dec 24 12:01:06 2025 +0100
+++ b/README.rst Wed Dec 24 10:37:11 2025 +0100
@@ -39,14 +39,14 @@
>>> 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 @@
>>> 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 @@
... 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 @@
>>> 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 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 @@
('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 @@
>>> 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 @@
>>> 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',))
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/operators.py
--- a/sql/operators.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/operators.py Wed Dec 24 10:37:11 2025 +0100
@@ -48,9 +48,10 @@
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)):
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 +89,7 @@
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 +106,7 @@
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 +122,7 @@
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 +184,9 @@
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 +196,9 @@
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 +220,7 @@
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 +259,12 @@
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 +395,11 @@
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):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_aggregate.py
--- a/sql/tests/test_aggregate.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_aggregate.py Wed Dec 24 10:37:11 2025 +0100
@@ -38,7 +38,7 @@
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 @@
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 @@
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):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_combining_query.py
--- a/sql/tests/test_combining_query.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_combining_query.py Wed Dec 24 10:37:11 2025 +0100
@@ -33,7 +33,7 @@
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,))
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_conditionals.py
--- a/sql/tests/test_conditionals.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_conditionals.py Wed Dec 24 10:37:11 2025 +0100
@@ -36,9 +36,9 @@
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 @@
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):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_delete.py
--- a/sql/tests/test_delete.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_delete.py Wed Dec 24 10:37:11 2025 +0100
@@ -15,7 +15,7 @@
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 @@
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 @@
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, ())
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_functions.py
--- a/sql/tests/test_functions.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_functions.py Wed Dec 24 10:37:11 2025 +0100
@@ -70,7 +70,7 @@
abs_ = Abs(self.table.select(self.table.c1,
where=self.table.c2 == 'foo'))
self.assertEqual(str(abs_),
- 'ABS((SELECT "a"."c1" FROM "t" AS "a" WHERE ("a"."c2" = %s)))')
+ 'ABS((SELECT "a"."c1" FROM "t" AS "a" WHERE "a"."c2" = %s))')
self.assertEqual(abs_.params, ('foo',))
def test_overlay(self):
@@ -110,7 +110,7 @@
self.table.select(self.table.tz, where=self.table.c1 == 'foo'))
self.assertEqual(str(time_zone),
'"c1" AT TIME ZONE '
- '(SELECT "a"."tz" FROM "t" AS "a" WHERE ("a"."c1" = %s))')
+ '(SELECT "a"."tz" FROM "t" AS "a" WHERE "a"."c1" = %s)')
self.assertEqual(time_zone.params, ('foo',))
def test_at_time_zone_mapping(self):
@@ -192,7 +192,7 @@
with AliasManager():
self.assertEqual(str(function),
- 'RANK("a"."c") FILTER (WHERE ("a"."c" > %s)) OVER ()')
+ 'RANK("a"."c") FILTER (WHERE "a"."c" > %s) OVER ()')
self.assertEqual(function.params, (0,))
def test_invalid_filter(self):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_insert.py
--- a/sql/tests/test_insert.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_insert.py Wed Dec 24 10:37:11 2025 +0100
@@ -73,7 +73,7 @@
self.assertEqual(str(query),
'INSERT INTO "t1" AS "b" ("c") VALUES (%s) '
'RETURNING (SELECT "a"."c" FROM "t2" AS "a" '
- 'WHERE (("a"."c1" = "b"."c") AND ("a"."c2" = %s)))')
+ 'WHERE ("a"."c1" = "b"."c") AND ("a"."c2" = %s))')
self.assertEqual(tuple(query.params), ('foo', 'bar'))
def test_insert_invalid_returning(self):
@@ -160,7 +160,7 @@
self.assertEqual(str(query),
'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
- 'ON CONFLICT ("c1") WHERE ("a"."c2" = %s) DO NOTHING')
+ 'ON CONFLICT ("c1") WHERE "a"."c2" = %s DO NOTHING')
self.assertEqual(tuple(query.params), ('foo', 'bar'))
def test_upsert_update(self):
@@ -188,7 +188,7 @@
self.assertEqual(str(query),
'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
'ON CONFLICT DO UPDATE SET "c1" = (%s) '
- 'WHERE ("a"."c2" = %s)')
+ 'WHERE "a"."c2" = %s')
self.assertEqual(tuple(query.params), ('baz', 'foo', 'bar'))
def test_upsert_update_subquery(self):
@@ -218,7 +218,7 @@
self.assertEqual(str(query),
'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
- 'ON CONFLICT DO UPDATE SET "c1" = (("EXCLUDED"."c1" + %s))')
+ 'ON CONFLICT DO UPDATE SET "c1" = ("EXCLUDED"."c1" + %s)')
self.assertEqual(tuple(query.params), (1, 2))
def test_conflict_invalid_table(self):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_join.py
--- a/sql/tests/test_join.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_join.py Wed Dec 24 10:37:11 2025 +0100
@@ -18,7 +18,7 @@
join.condition = t1.c == t2.c
with AliasManager():
self.assertEqual(str(join),
- '"t1" AS "a" INNER JOIN "t2" AS "b" ON ("a"."c" = "b"."c")')
+ '"t1" AS "a" INNER JOIN "t2" AS "b" ON "a"."c" = "b"."c"')
def test_join_invalid_left(self):
with self.assertRaises(ValueError):
@@ -45,7 +45,7 @@
with AliasManager():
self.assertEqual(str(join),
'"t1" AS "a" INNER JOIN (SELECT * FROM "t2" AS "c") AS "b" '
- 'ON ("a"."c" = "b"."c")')
+ 'ON "a"."c" = "b"."c"')
self.assertEqual(tuple(join.params), ())
def test_join_function(self):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_lateral.py
--- a/sql/tests/test_lateral.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_lateral.py Wed Dec 24 10:37:11 2025 +0100
@@ -16,7 +16,7 @@
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a", LATERAL '
- '(SELECT * FROM "t2" AS "c" WHERE ("c"."id" = "a"."t2")) AS "b"')
+ '(SELECT * FROM "t2" AS "c" WHERE "c"."id" = "a"."t2") AS "b"')
self.assertEqual(tuple(query.params), ())
def test_lateral_function(self):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_merge.py
--- a/sql/tests/test_merge.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_merge.py Wed Dec 24 10:37:11 2025 +0100
@@ -18,7 +18,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN MATCHED THEN DO NOTHING')
self.assertEqual(query.params, ())
@@ -46,7 +46,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON (("a"."c1" = "b"."c2") AND ("a"."c3" = %s)) '
+ 'ON ("a"."c1" = "b"."c2") AND ("a"."c3" = %s) '
'WHEN MATCHED THEN DO NOTHING')
self.assertEqual(query.params, (42,))
@@ -58,9 +58,9 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN MATCHED '
- 'AND (("b"."c3" = %s) AND ("a"."c4" = "b"."c5")) '
+ 'AND ("b"."c3" = %s) AND ("a"."c4" = "b"."c5") '
'THEN DO NOTHING')
self.assertEqual(query.params, (42,))
@@ -73,9 +73,9 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN MATCHED THEN '
- 'UPDATE SET "c1" = ("a"."c1" + "b"."c2"), "c2" = %s')
+ 'UPDATE SET "c1" = "a"."c1" + "b"."c2", "c2" = %s')
self.assertEqual(query.params, (42,))
def test_matched_delete(self):
@@ -84,7 +84,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN MATCHED THEN DELETE')
self.assertEqual(query.params, ())
@@ -94,7 +94,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN NOT MATCHED THEN DO NOTHING')
self.assertEqual(query.params, ())
@@ -107,7 +107,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN NOT MATCHED THEN '
'INSERT ("c1", "c2") VALUES ("b"."c3", "b"."c4")')
self.assertEqual(query.params, ())
@@ -119,7 +119,7 @@
self.assertEqual(
str(query),
'MERGE INTO "t" AS "a" USING "s" AS "b" '
- 'ON ("a"."c1" = "b"."c2") '
+ 'ON "a"."c1" = "b"."c2" '
'WHEN NOT MATCHED THEN '
'INSERT ("c1", "c2") DEFAULT VALUES')
self.assertEqual(query.params, ())
@@ -141,9 +141,9 @@
source, self.target.c1 == source.c2, Matched(), with_=[w])
self.assertEqual(
str(query),
- 'WITH "a" AS (SELECT * FROM "t1" AS "d" WHERE ("d"."c2" = %s)) '
+ 'WITH "a" AS (SELECT * FROM "t1" AS "d" WHERE "d"."c2" = %s) '
'MERGE INTO "t" AS "b" '
'USING (SELECT * FROM "a" AS "a") AS "c" '
- 'ON ("b"."c1" = "c"."c2") '
+ 'ON "b"."c1" = "c"."c2" '
'WHEN MATCHED THEN DO NOTHING')
self.assertEqual(query.params, (42,))
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_operators.py
--- a/sql/tests/test_operators.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_operators.py Wed Dec 24 10:37:11 2025 +0100
@@ -25,34 +25,34 @@
def test_and(self):
for and_ in [And((self.table.c1, self.table.c2)),
self.table.c1 & self.table.c2]:
- self.assertEqual(str(and_), '("c1" AND "c2")')
+ self.assertEqual(str(and_), '"c1" AND "c2"')
self.assertEqual(and_.params, ())
and_ = And((Literal(True), self.table.c2))
- self.assertEqual(str(and_), '(%s AND "c2")')
+ self.assertEqual(str(and_), '%s AND "c2"')
self.assertEqual(and_.params, (True,))
and_ = And((Literal(True), 'foo'))
- self.assertEqual(str(and_), '(%s AND %s)')
+ self.assertEqual(str(and_), '%s AND %s')
self.assertEqual(and_.params, (True, 'foo'))
def test_operator_operators(self):
and_ = And((Literal(True), self.table.c1))
and2 = and_ & And((Literal(True), self.table.c2))
- self.assertEqual(str(and2), '((%s AND "c1") AND %s AND "c2")')
+ self.assertEqual(str(and2), '(%s AND "c1") AND %s AND "c2"')
self.assertEqual(and2.params, (True, True))
and3 = and_ & Literal(True)
- self.assertEqual(str(and3), '((%s AND "c1") AND %s)')
+ self.assertEqual(str(and3), '(%s AND "c1") AND %s')
self.assertEqual(and3.params, (True, True))
or_ = Or((Literal(True), self.table.c1))
or2 = or_ | Or((Literal(True), self.table.c2))
- self.assertEqual(str(or2), '((%s OR "c1") OR %s OR "c2")')
+ self.assertEqual(str(or2), '(%s OR "c1") OR %s OR "c2"')
self.assertEqual(or2.params, (True, True))
or3 = or_ | Literal(True)
- self.assertEqual(str(or3), '((%s OR "c1") OR %s)')
+ self.assertEqual(str(or3), '(%s OR "c1") OR %s')
self.assertEqual(or3.params, (True, True))
def test_operator_compat_column(self):
@@ -63,152 +63,152 @@
def test_or(self):
for or_ in [Or((self.table.c1, self.table.c2)),
self.table.c1 | self.table.c2]:
- self.assertEqual(str(or_), '("c1" OR "c2")')
+ self.assertEqual(str(or_), '"c1" OR "c2"')
self.assertEqual(or_.params, ())
def test_not(self):
for not_ in [Not(self.table.c), ~self.table.c]:
- self.assertEqual(str(not_), '(NOT "c")')
+ self.assertEqual(str(not_), 'NOT "c"')
self.assertEqual(not_.params, ())
not_ = Not(Literal(False))
- self.assertEqual(str(not_), '(NOT %s)')
+ self.assertEqual(str(not_), 'NOT %s')
self.assertEqual(not_.params, (False,))
def test_neg(self):
for neg in [Neg(self.table.c1), -self.table.c1]:
- self.assertEqual(str(neg), '(- "c1")')
+ self.assertEqual(str(neg), '- "c1"')
self.assertEqual(neg.params, ())
def test_pos(self):
for pos in [Pos(self.table.c1), +self.table.c1]:
- self.assertEqual(str(pos), '(+ "c1")')
+ self.assertEqual(str(pos), '+ "c1"')
self.assertEqual(pos.params, ())
def test_less(self):
for less in [Less(self.table.c1, self.table.c2),
self.table.c1 < self.table.c2,
~GreaterEqual(self.table.c1, self.table.c2)]:
- self.assertEqual(str(less), '("c1" < "c2")')
+ self.assertEqual(str(less), '"c1" < "c2"')
self.assertEqual(less.params, ())
less = Less(Literal(0), self.table.c2)
- self.assertEqual(str(less), '(%s < "c2")')
+ self.assertEqual(str(less), '%s < "c2"')
self.assertEqual(less.params, (0,))
def test_greater(self):
for greater in [Greater(self.table.c1, self.table.c2),
self.table.c1 > self.table.c2,
~LessEqual(self.table.c1, self.table.c2)]:
- self.assertEqual(str(greater), '("c1" > "c2")')
+ self.assertEqual(str(greater), '"c1" > "c2"')
self.assertEqual(greater.params, ())
def test_less_equal(self):
for less in [LessEqual(self.table.c1, self.table.c2),
self.table.c1 <= self.table.c2,
~Greater(self.table.c1, self.table.c2)]:
- self.assertEqual(str(less), '("c1" <= "c2")')
+ self.assertEqual(str(less), '"c1" <= "c2"')
self.assertEqual(less.params, ())
def test_greater_equal(self):
for greater in [GreaterEqual(self.table.c1, self.table.c2),
self.table.c1 >= self.table.c2,
~Less(self.table.c1, self.table.c2)]:
- self.assertEqual(str(greater), '("c1" >= "c2")')
+ self.assertEqual(str(greater), '"c1" >= "c2"')
self.assertEqual(greater.params, ())
def test_equal(self):
for equal in [Equal(self.table.c1, self.table.c2),
self.table.c1 == self.table.c2,
~NotEqual(self.table.c1, self.table.c2)]:
- self.assertEqual(str(equal), '("c1" = "c2")')
+ self.assertEqual(str(equal), '"c1" = "c2"')
self.assertEqual(equal.params, ())
equal = Equal(Literal('foo'), Literal('bar'))
- self.assertEqual(str(equal), '(%s = %s)')
+ self.assertEqual(str(equal), '%s = %s')
self.assertEqual(equal.params, ('foo', 'bar'))
equal = Equal(self.table.c1, Null)
- self.assertEqual(str(equal), '("c1" IS NULL)')
+ self.assertEqual(str(equal), '"c1" IS NULL')
self.assertEqual(equal.params, ())
equal = Equal(Literal('test'), Null)
- self.assertEqual(str(equal), '(%s IS NULL)')
+ self.assertEqual(str(equal), '%s IS NULL')
self.assertEqual(equal.params, ('test',))
equal = Equal(Null, self.table.c1)
- self.assertEqual(str(equal), '("c1" IS NULL)')
+ self.assertEqual(str(equal), '"c1" IS NULL')
self.assertEqual(equal.params, ())
equal = Equal(Null, Literal('test'))
- self.assertEqual(str(equal), '(%s IS NULL)')
+ self.assertEqual(str(equal), '%s IS NULL')
self.assertEqual(equal.params, ('test',))
def test_not_equal(self):
for equal in [NotEqual(self.table.c1, self.table.c2),
self.table.c1 != self.table.c2,
~Equal(self.table.c1, self.table.c2)]:
- self.assertEqual(str(equal), '("c1" != "c2")')
+ self.assertEqual(str(equal), '"c1" != "c2"')
self.assertEqual(equal.params, ())
equal = NotEqual(self.table.c1, Null)
- self.assertEqual(str(equal), '("c1" IS NOT NULL)')
+ self.assertEqual(str(equal), '"c1" IS NOT NULL')
self.assertEqual(equal.params, ())
equal = NotEqual(Null, self.table.c1)
- self.assertEqual(str(equal), '("c1" IS NOT NULL)')
+ self.assertEqual(str(equal), '"c1" IS NOT NULL')
self.assertEqual(equal.params, ())
def test_between(self):
for between in [Between(self.table.c1, 1, 2),
~NotBetween(self.table.c1, 1, 2)]:
- self.assertEqual(str(between), '("c1" BETWEEN %s AND %s)')
+ self.assertEqual(str(between), '"c1" BETWEEN %s AND %s')
self.assertEqual(between.params, (1, 2))
between = Between(
self.table.c1, self.table.c2, self.table.c3, symmetric=True)
self.assertEqual(
- str(between), '("c1" BETWEEN SYMMETRIC "c2" AND "c3")')
+ str(between), '"c1" BETWEEN SYMMETRIC "c2" AND "c3"')
self.assertEqual(between.params, ())
def test_not_between(self):
for between in [NotBetween(self.table.c1, 1, 2),
~Between(self.table.c1, 1, 2)]:
- self.assertEqual(str(between), '("c1" NOT BETWEEN %s AND %s)')
+ self.assertEqual(str(between), '"c1" NOT BETWEEN %s AND %s')
self.assertEqual(between.params, (1, 2))
between = NotBetween(
self.table.c1, self.table.c2, self.table.c3, symmetric=True)
self.assertEqual(
- str(between), '("c1" NOT BETWEEN SYMMETRIC "c2" AND "c3")')
+ str(between), '"c1" NOT BETWEEN SYMMETRIC "c2" AND "c3"')
self.assertEqual(between.params, ())
def test_is_distinct(self):
for distinct in [IsDistinct(self.table.c1, self.table.c2),
~IsNotDistinct(self.table.c1, self.table.c2)]:
- self.assertEqual(str(distinct), '("c1" IS DISTINCT FROM "c2")')
+ self.assertEqual(str(distinct), '"c1" IS DISTINCT FROM "c2"')
self.assertEqual(distinct.params, ())
def test_is_not_distinct(self):
for distinct in [IsNotDistinct(self.table.c1, self.table.c2),
~IsDistinct(self.table.c1, self.table.c2)]:
- self.assertEqual(str(distinct), '("c1" IS NOT DISTINCT FROM "c2")')
+ self.assertEqual(str(distinct), '"c1" IS NOT DISTINCT FROM "c2"')
self.assertEqual(distinct.params, ())
def test_is(self):
for is_ in [Is(self.table.c1, None),
~IsNot(self.table.c1, None)]:
- self.assertEqual(str(is_), '("c1" IS UNKNOWN)')
+ self.assertEqual(str(is_), '"c1" IS UNKNOWN')
self.assertEqual(is_.params, ())
for is_ in [Is(self.table.c1, True),
~IsNot(self.table.c1, True)]:
- self.assertEqual(str(is_), '("c1" IS TRUE)')
+ self.assertEqual(str(is_), '"c1" IS TRUE')
self.assertEqual(is_.params, ())
for is_ in [Is(self.table.c1, False),
~IsNot(self.table.c1, False)]:
- self.assertEqual(str(is_), '("c1" IS FALSE)')
+ self.assertEqual(str(is_), '"c1" IS FALSE')
self.assertEqual(is_.params, ())
def test_is_invalid_right(self):
@@ -218,41 +218,41 @@
def test_is_not(self):
for is_ in [IsNot(self.table.c1, None),
~Is(self.table.c1, None)]:
- self.assertEqual(str(is_), '("c1" IS NOT UNKNOWN)')
+ self.assertEqual(str(is_), '"c1" IS NOT UNKNOWN')
self.assertEqual(is_.params, ())
for is_ in [IsNot(self.table.c1, True),
~Is(self.table.c1, True)]:
- self.assertEqual(str(is_), '("c1" IS NOT TRUE)')
+ self.assertEqual(str(is_), '"c1" IS NOT TRUE')
self.assertEqual(is_.params, ())
for is_ in [IsNot(self.table.c1, False),
~Is(self.table.c1, False)]:
- self.assertEqual(str(is_), '("c1" IS NOT FALSE)')
+ self.assertEqual(str(is_), '"c1" IS NOT FALSE')
self.assertEqual(is_.params, ())
def test_sub(self):
for sub in [Sub(self.table.c1, self.table.c2),
self.table.c1 - self.table.c2]:
- self.assertEqual(str(sub), '("c1" - "c2")')
+ self.assertEqual(str(sub), '"c1" - "c2"')
self.assertEqual(sub.params, ())
def test_mul(self):
for mul in [Mul(self.table.c1, self.table.c2),
self.table.c1 * self.table.c2]:
- self.assertEqual(str(mul), '("c1" * "c2")')
+ self.assertEqual(str(mul), '"c1" * "c2"')
self.assertEqual(mul.params, ())
def test_div(self):
for div in [Div(self.table.c1, self.table.c2),
self.table.c1 / self.table.c2]:
- self.assertEqual(str(div), '("c1" / "c2")')
+ self.assertEqual(str(div), '"c1" / "c2"')
self.assertEqual(div.params, ())
def test_mod(self):
for mod in [Mod(self.table.c1, self.table.c2),
self.table.c1 % self.table.c2]:
- self.assertEqual(str(mod), '("c1" %% "c2")')
+ self.assertEqual(str(mod), '"c1" %% "c2"')
self.assertEqual(mod.params, ())
def test_mod_paramstyle(self):
@@ -260,7 +260,7 @@
Flavor.set(flavor)
try:
mod = Mod(self.table.c1, self.table.c2)
- self.assertEqual(str(mod), '("c1" %% "c2")')
+ self.assertEqual(str(mod), '"c1" %% "c2"')
self.assertEqual(mod.params, ())
finally:
Flavor.set(Flavor())
@@ -269,7 +269,7 @@
Flavor.set(flavor)
try:
mod = Mod(self.table.c1, self.table.c2)
- self.assertEqual(str(mod), '("c1" % "c2")')
+ self.assertEqual(str(mod), '"c1" % "c2"')
self.assertEqual(mod.params, ())
finally:
Flavor.set(Flavor())
@@ -277,24 +277,24 @@
def test_pow(self):
for pow_ in [Pow(self.table.c1, self.table.c2),
self.table.c1 ** self.table.c2]:
- self.assertEqual(str(pow_), '("c1" ^ "c2")')
+ self.assertEqual(str(pow_), '"c1" ^ "c2"')
self.assertEqual(pow_.params, ())
def test_abs(self):
for abs_ in [Abs(self.table.c1), abs(self.table.c1)]:
- self.assertEqual(str(abs_), '(@ "c1")')
+ self.assertEqual(str(abs_), '@ "c1"')
self.assertEqual(abs_.params, ())
def test_lshift(self):
for lshift in [LShift(self.table.c1, 2),
self.table.c1 << 2]:
- self.assertEqual(str(lshift), '("c1" << %s)')
+ self.assertEqual(str(lshift), '"c1" << %s')
self.assertEqual(lshift.params, (2,))
def test_rshift(self):
for rshift in [RShift(self.table.c1, 2),
self.table.c1 >> 2]:
- self.assertEqual(str(rshift), '("c1" >> %s)')
+ self.assertEqual(str(rshift), '"c1" >> %s')
self.assertEqual(rshift.params, (2,))
def test_like(self):
@@ -302,12 +302,12 @@
self.table.c1.like('foo'),
~NotLike(self.table.c1, 'foo'),
~~Like(self.table.c1, 'foo')]:
- self.assertEqual(str(like), '("c1" LIKE %s)')
+ self.assertEqual(str(like), '"c1" LIKE %s')
self.assertEqual(like.params, ('foo',))
def test_like_escape(self):
like = Like(self.table.c1, 'foo', escape='$')
- self.assertEqual(str(like), '("c1" LIKE %s ESCAPE %s)')
+ self.assertEqual(str(like), '"c1" LIKE %s ESCAPE %s')
self.assertEqual(like.params, ('foo', '$'))
def test_like_escape_empty_false(self):
@@ -315,7 +315,7 @@
Flavor.set(flavor)
try:
like = Like(self.table.c1, 'foo')
- self.assertEqual(str(like), '("c1" LIKE %s)')
+ self.assertEqual(str(like), '"c1" LIKE %s')
self.assertEqual(like.params, ('foo',))
finally:
Flavor.set(Flavor())
@@ -325,7 +325,7 @@
Flavor.set(flavor)
try:
like = Like(self.table.c1, 'foo')
- self.assertEqual(str(like), '("c1" LIKE %s ESCAPE %s)')
+ self.assertEqual(str(like), '"c1" LIKE %s ESCAPE %s')
self.assertEqual(like.params, ('foo', ''))
finally:
Flavor.set(Flavor())
@@ -341,7 +341,7 @@
for like in [ILike(self.table.c1, 'foo'),
self.table.c1.ilike('foo'),
~NotILike(self.table.c1, 'foo')]:
- self.assertEqual(str(like), '("c1" ILIKE %s)')
+ self.assertEqual(str(like), '"c1" ILIKE %s')
self.assertEqual(like.params, ('foo',))
finally:
Flavor.set(Flavor())
@@ -351,7 +351,7 @@
try:
like = ILike(self.table.c1, 'foo')
self.assertEqual(
- str(like), '(UPPER("c1") LIKE UPPER(%s))')
+ str(like), 'UPPER("c1") LIKE UPPER(%s)')
self.assertEqual(like.params, ('foo',))
finally:
Flavor.set(Flavor())
@@ -362,7 +362,7 @@
try:
for like in [NotILike(self.table.c1, 'foo'),
~self.table.c1.ilike('foo')]:
- self.assertEqual(str(like), '("c1" NOT ILIKE %s)')
+ self.assertEqual(str(like), '"c1" NOT ILIKE %s')
self.assertEqual(like.params, ('foo',))
finally:
Flavor.set(Flavor())
@@ -372,7 +372,7 @@
try:
like = NotILike(self.table.c1, 'foo')
self.assertEqual(
- str(like), '(UPPER("c1") NOT LIKE UPPER(%s))')
+ str(like), 'UPPER("c1") NOT LIKE UPPER(%s)')
self.assertEqual(like.params, ('foo',))
finally:
Flavor.set(Flavor())
@@ -381,32 +381,31 @@
for in_ in [In(self.table.c1, [self.table.c2, 1, Null]),
~NotIn(self.table.c1, [self.table.c2, 1, Null]),
~~In(self.table.c1, [self.table.c2, 1, Null])]:
- self.assertEqual(str(in_), '("c1" IN ("c2", %s, %s))')
+ self.assertEqual(str(in_), '"c1" IN ("c2", %s, %s)')
self.assertEqual(in_.params, (1, None))
t2 = Table('t2')
in_ = In(self.table.c1, t2.select(t2.c2))
self.assertEqual(str(in_),
- '("c1" IN (SELECT "a"."c2" FROM "t2" AS "a"))')
+ '"c1" IN (SELECT "a"."c2" FROM "t2" AS "a")')
self.assertEqual(in_.params, ())
in_ = In(self.table.c1, t2.select(t2.c2) | t2.select(t2.c3))
self.assertEqual(str(in_),
- '("c1" IN (SELECT "a"."c2" FROM "t2" AS "a" '
- 'UNION SELECT "a"."c3" FROM "t2" AS "a"))')
+ '"c1" IN (SELECT "a"."c2" FROM "t2" AS "a" '
+ 'UNION SELECT "a"."c3" FROM "t2" AS "a")')
self.assertEqual(in_.params, ())
in_ = In(self.table.c1, array('l', list(range(10))))
self.assertEqual(str(in_),
- '("c1" IN (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s))')
+ '"c1" IN (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)')
self.assertEqual(in_.params, tuple(range(10)))
def test_exists(self):
exists = Exists(self.table.select(self.table.c1,
where=self.table.c1 == 1))
self.assertEqual(str(exists),
- '(EXISTS (SELECT "a"."c1" FROM "t" AS "a" '
- 'WHERE ("a"."c1" = %s)))')
+ 'EXISTS (SELECT "a"."c1" FROM "t" AS "a" WHERE "a"."c1" = %s)')
self.assertEqual(exists.params, (1,))
def test_floordiv(self):
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_order.py
--- a/sql/tests/test_order.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_order.py Wed Dec 24 10:37:11 2025 +0100
@@ -36,17 +36,17 @@
exp = NullsFirst(self.column)
self.assertEqual(str(exp),
- 'CASE WHEN ("c" IS NULL) THEN %s ELSE %s END ASC, "c"')
+ 'CASE WHEN "c" IS NULL THEN %s ELSE %s END ASC, "c"')
self.assertEqual(exp.params, (0, 1))
exp = NullsFirst(Desc(self.column))
self.assertEqual(str(exp),
- 'CASE WHEN ("c" IS NULL) THEN %s ELSE %s END ASC, "c" DESC')
+ 'CASE WHEN "c" IS NULL THEN %s ELSE %s END ASC, "c" DESC')
self.assertEqual(exp.params, (0, 1))
exp = NullsLast(Literal(2))
self.assertEqual(str(exp),
- 'CASE WHEN (%s IS NULL) THEN %s ELSE %s END ASC, %s')
+ 'CASE WHEN %s IS NULL THEN %s ELSE %s END ASC, %s')
self.assertEqual(exp.params, (2, 1, 0, 2))
finally:
Flavor.set(Flavor())
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_select.py
--- a/sql/tests/test_select.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_select.py Wed Dec 24 10:37:11 2025 +0100
@@ -31,7 +31,7 @@
def test_select3(self):
query = self.table.select(where=(self.table.c == 'foo'))
self.assertEqual(str(query),
- 'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s)')
+ 'SELECT * FROM "t" AS "a" WHERE "a"."c" = %s')
self.assertEqual(tuple(query.params), ('foo',))
def test_select_iter(self):
@@ -110,7 +110,7 @@
'SELECT * FROM "t2" AS "c") AS "a"')
query1.where = self.table.c == 'foo'
self.assertEqual(str(union),
- 'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s) UNION ALL '
+ 'SELECT * FROM "t" AS "a" WHERE "a"."c" = %s UNION ALL '
'SELECT * FROM "t2" AS "b"')
self.assertEqual(tuple(union.params), ('foo',))
@@ -279,7 +279,7 @@
having=(Min(col2) > 3))
self.assertEqual(str(query),
'SELECT "a"."col1", MIN("a"."col2") FROM "t" AS "a" '
- 'HAVING (MIN("a"."col2") > %s)')
+ 'HAVING MIN("a"."col2") > %s')
self.assertEqual(tuple(query.params), (3,))
def test_select_invalid_having(self):
@@ -383,8 +383,8 @@
'SELECT "a".* FROM ('
'SELECT "b".*, ROWNUM AS "rnum" FROM ('
'SELECT * FROM "t" AS "c") AS "b" '
- 'WHERE (ROWNUM <= %s)) AS "a" '
- 'WHERE ("rnum" > %s)')
+ 'WHERE ROWNUM <= %s) AS "a" '
+ 'WHERE "rnum" > %s')
self.assertEqual(tuple(query.params), (60, 10))
query = self.table.select(
@@ -395,8 +395,8 @@
'SELECT "b"."col1", "b"."col2", ROWNUM AS "rnum" FROM ('
'SELECT "c"."c1" AS "col1", "c"."c2" AS "col2" '
'FROM "t" AS "c") AS "b" '
- 'WHERE (ROWNUM <= %s)) AS "a" '
- 'WHERE ("rnum" > %s)')
+ 'WHERE ROWNUM <= %s) AS "a" '
+ 'WHERE "rnum" > %s')
self.assertEqual(tuple(query.params), (60, 10))
subquery = query.select(query.col1, query.col2)
@@ -407,8 +407,8 @@
'FROM ('
'SELECT "c"."c1" AS "col1", "c"."c2" AS "col2" '
'FROM "t" AS "c") AS "a" '
- 'WHERE (ROWNUM <= %s)) AS "b" '
- 'WHERE ("rnum" > %s)) AS "a"')
+ 'WHERE ROWNUM <= %s) AS "b" '
+ 'WHERE "rnum" > %s) AS "a"')
# XXX alias of query is reused but not a problem
# as it is hidden in subquery
self.assertEqual(tuple(query.params), (60, 10))
@@ -419,15 +419,15 @@
'SELECT "a".* FROM ('
'SELECT "b".*, ROWNUM AS "rnum" FROM ('
'SELECT * FROM "t" AS "c" ORDER BY "c"."c") AS "b" '
- 'WHERE (ROWNUM <= %s)) AS "a" '
- 'WHERE ("rnum" > %s)')
+ 'WHERE ROWNUM <= %s) AS "a" '
+ 'WHERE "rnum" > %s')
self.assertEqual(tuple(query.params), (60, 10))
query = self.table.select(limit=50)
self.assertEqual(str(query),
'SELECT "a".* FROM ('
'SELECT * FROM "t" AS "b") AS "a" '
- 'WHERE (ROWNUM <= %s)')
+ 'WHERE ROWNUM <= %s')
self.assertEqual(tuple(query.params), (50,))
query = self.table.select(offset=10)
@@ -435,7 +435,7 @@
'SELECT "a".* FROM ('
'SELECT "b".*, ROWNUM AS "rnum" FROM ('
'SELECT * FROM "t" AS "c") AS "b") AS "a" '
- 'WHERE ("rnum" > %s)')
+ 'WHERE "rnum" > %s')
self.assertEqual(tuple(query.params), (10,))
query = self.table.select(self.table.c.as_('col'),
@@ -445,9 +445,9 @@
'SELECT "a"."col" FROM ('
'SELECT "b"."col", ROWNUM AS "rnum" FROM ('
'SELECT "c"."c" AS "col" FROM "t" AS "c" '
- 'WHERE ("c"."c" >= %s)) AS "b" '
- 'WHERE (ROWNUM <= %s)) AS "a" '
- 'WHERE ("rnum" > %s)')
+ 'WHERE "c"."c" >= %s) AS "b" '
+ 'WHERE ROWNUM <= %s) AS "a" '
+ 'WHERE "rnum" > %s')
self.assertEqual(tuple(query.params), (20, 60, 10))
finally:
Flavor.set(Flavor())
@@ -499,7 +499,7 @@
Rank(filter_=self.table.c1 > 0, window=window),
Min(self.table.c1, window=window))
self.assertEqual(str(query),
- 'SELECT RANK() FILTER (WHERE ("a"."c1" > %s)) OVER "b", '
+ 'SELECT RANK() FILTER (WHERE "a"."c1" > %s) OVER "b", '
'MIN("a"."c1") OVER "b" FROM "t" AS "a" '
'WINDOW "b" AS (PARTITION BY "a"."c1")')
self.assertEqual(tuple(query.params), (0,))
@@ -517,8 +517,8 @@
Max(self.table.c1, window=window)
/ Min(self.table.c1, window=window))
self.assertEqual(str(query),
- 'SELECT (MAX("a"."c1") OVER (PARTITION BY "a"."c2") '
- '/ MIN("a"."c1") OVER (PARTITION BY "a"."c2")) '
+ 'SELECT MAX("a"."c1") OVER (PARTITION BY "a"."c2") '
+ '/ MIN("a"."c1") OVER (PARTITION BY "a"."c2") '
'FROM "t" AS "a"')
self.assertEqual(tuple(query.params), ())
@@ -527,8 +527,8 @@
Max(self.table.c1, window=window)
/ Min(self.table.c1, window=window))
self.assertEqual(str(query),
- 'SELECT (MAX("a"."c1") OVER (PARTITION BY %s) '
- '/ MIN("a"."c1") OVER (PARTITION BY %s)) '
+ 'SELECT MAX("a"."c1") OVER (PARTITION BY %s) '
+ '/ MIN("a"."c1") OVER (PARTITION BY %s) '
'FROM "t" AS "a"')
self.assertEqual(tuple(query.params), (1, 1))
@@ -539,8 +539,8 @@
/ Min(self.table.c1, window=window2),
windows=[window1])
self.assertEqual(str(query),
- 'SELECT (MAX("a"."c1") OVER "b" '
- '/ MIN("a"."c1") OVER (PARTITION BY %s)) '
+ 'SELECT MAX("a"."c1") OVER "b" '
+ '/ MIN("a"."c1") OVER (PARTITION BY %s) '
'FROM "t" AS "a" '
'WINDOW "b" AS (PARTITION BY "a"."c2")')
self.assertEqual(tuple(query.params), (1,))
@@ -572,10 +572,10 @@
order_by=[Literal(8)])
self.assertEqual(
str(query),
- 'WITH "c" AS (SELECT "a"."c" FROM "t" AS "a" WHERE ("a"."c" > %s))'
+ 'WITH "c" AS (SELECT "a"."c" FROM "t" AS "a" WHERE "a"."c" > %s)'
' SELECT %s, MIN("a"."c") OVER "b" '
- 'FROM SELECT * FROM "t" AS "a" WHERE ("a"."c" > %s) '
- 'WHERE ("a"."c" > %s) '
+ 'FROM SELECT * FROM "t" AS "a" WHERE "a"."c" > %s '
+ 'WHERE "a"."c" > %s '
'GROUP BY %s '
'HAVING %s '
'WINDOW "b" AS (PARTITION BY %s) '
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_update.py
--- a/sql/tests/test_update.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_update.py Wed Dec 24 10:37:11 2025 +0100
@@ -15,7 +15,7 @@
query.where = (self.table.b == Literal(True))
self.assertEqual(str(query),
- 'UPDATE "t" AS "a" SET "c" = %s WHERE ("a"."b" = %s)')
+ 'UPDATE "t" AS "a" SET "c" = %s WHERE "a"."b" = %s')
self.assertEqual(query.params, ('foo', True))
def test_update2(self):
@@ -24,7 +24,7 @@
query = t1.update([t1.c], ['foo'], from_=[t2], where=(t1.c == t2.c))
self.assertEqual(str(query),
'UPDATE "t1" AS "b" SET "c" = %s FROM "t2" AS "a" '
- 'WHERE ("b"."c" = "a"."c")')
+ 'WHERE "b"."c" = "a"."c"')
self.assertEqual(query.params, ('foo',))
def test_update_invalid_values(self):
@@ -43,7 +43,7 @@
for query in [query_list, query_nolist]:
self.assertEqual(str(query),
'UPDATE "t1" AS "b" SET "c" = ('
- 'SELECT "a"."c" FROM "t2" AS "a" WHERE ("a"."i" = "b"."i"))')
+ 'SELECT "a"."c" FROM "t2" AS "a" WHERE "a"."i" = "b"."i")')
self.assertEqual(query.params, ())
def test_update_returning(self):
@@ -62,7 +62,7 @@
self.assertEqual(str(query),
'UPDATE "t1" AS "b" SET "c" = %s '
'RETURNING (SELECT "a"."c" FROM "t2" AS "a" '
- 'WHERE (("a"."c1" = "b"."c") AND ("a"."c2" = %s)))')
+ 'WHERE ("a"."c1" = "b"."c") AND ("a"."c2" = %s))')
self.assertEqual(query.params, ('foo', 'bar'))
def test_with(self):
@@ -76,7 +76,7 @@
self.assertEqual(str(query),
'WITH "a" AS (SELECT "b"."c1" FROM "t1" AS "b") '
'UPDATE "t" AS "c" SET "c2" = (SELECT "a"."c3" FROM "a" AS "a" '
- 'WHERE ("a"."c4" = %s))')
+ 'WHERE "a"."c4" = %s)')
self.assertEqual(query.params, (2,))
def test_schema(self):
@@ -95,5 +95,5 @@
self.assertEqual(str(query),
'UPDATE "default"."t1" AS "b" SET "c1" = ('
'SELECT "a"."c" FROM "default"."t2" AS "a" '
- 'WHERE ("a"."i" = "b"."i"))')
+ 'WHERE "a"."i" = "b"."i")')
self.assertEqual(query.params, ())
diff -r b1dfdb4a20c5 -r 05c585f43f17 sql/tests/test_with.py
--- a/sql/tests/test_with.py Wed Dec 24 12:01:06 2025 +0100
+++ b/sql/tests/test_with.py Wed Dec 24 10:37:11 2025 +0100
@@ -15,7 +15,7 @@
self.assertEqual(simple.statement(),
'"a" AS ('
- 'SELECT "b"."id" FROM "t" AS "b" WHERE ("b"."id" = %s)'
+ 'SELECT "b"."id" FROM "t" AS "b" WHERE "b"."id" = %s'
')')
self.assertEqual(simple.statement_params(), (1,))
@@ -40,7 +40,7 @@
wq = WithQuery(with_=[simple, second])
self.assertEqual(wq._with_str(),
'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'
'), "c" AS ('
'SELECT * FROM "a" AS "a"'
') ')
@@ -59,7 +59,7 @@
'WITH RECURSIVE "a" ("n") AS ('
'VALUES (%s) '
'UNION ALL '
- 'SELECT ("a"."n" + %s) FROM "a" AS "a" WHERE ("a"."n" < %s)'
+ 'SELECT "a"."n" + %s FROM "a" AS "a" WHERE "a"."n" < %s'
') SELECT * FROM "a" AS "a"')
self.assertEqual(tuple(q.params), (1, 1, 100))
