Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-python-sql for
openSUSE:Factory checked in at 2021-09-10 23:41:26
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-python-sql (Old)
and /work/SRC/openSUSE:Factory/.python-python-sql.new.1899 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-python-sql"
Fri Sep 10 23:41:26 2021 rev:6 rq:917909 version:1.2.2
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-python-sql/python-python-sql.changes
2020-10-07 14:18:23.049480805 +0200
+++
/work/SRC/openSUSE:Factory/.python-python-sql.new.1899/python-python-sql.changes
2021-09-10 23:41:49.794592496 +0200
@@ -1,0 +2,11 @@
+Fri Sep 10 07:14:18 UTC 2021 - [email protected]
+
+- version update to 1.2.2
+ Version 1.2.2 - 2021-05-16
+ * Escape table and column names containing double quote
+ * Use alias on the main table used in UPDATE and INSERT
+ * Add support for Python 3.9
+ Version 1.2.1 - 2020-10-08
+ * Fix AttributeError in Select.params with windows
+
+-------------------------------------------------------------------
Old:
----
python-sql-1.2.0.tar.gz
New:
----
python-sql-1.2.2.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-python-sql.spec ++++++
--- /var/tmp/diff_new_pack.CsdQBq/_old 2021-09-10 23:41:50.266592998 +0200
+++ /var/tmp/diff_new_pack.CsdQBq/_new 2021-09-10 23:41:50.270593002 +0200
@@ -1,7 +1,7 @@
#
-# spec file for package python-python-sql
+# spec file
#
-# Copyright (c) 2020 SUSE LLC
+# Copyright (c) 2021 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -19,7 +19,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
%define base_name python-sql
Name: python-%{base_name}
-Version: 1.2.0
+Version: 1.2.2
Release: 0
Summary: Library to write SQL queries
License: BSD-3-Clause
@@ -44,7 +44,9 @@
%python_install
%check
-%python_exec setup.py test
+mv sql sql_hide
+%pyunittest discover -v
+mv sql_hide sql
%files %{python_files}
%doc README
++++++ python-sql-1.2.0.tar.gz -> python-sql-1.2.2.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/.drone.yml
new/python-sql-1.2.2/.drone.yml
--- old/python-sql-1.2.0/.drone.yml 2020-10-02 21:26:48.000000000 +0200
+++ new/python-sql-1.2.2/.drone.yml 2021-05-09 09:36:27.000000000 +0200
@@ -27,6 +27,8 @@
TOXENV: py37
- IMAGE: python:3.8
TOXENV: py38
+ - IMAGE: python:3.9
+ TOXENV: py39
- IMAGE: pypy:2
TOXENV: pypy
- IMAGE: pypy:3
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/.hgtags new/python-sql-1.2.2/.hgtags
--- old/python-sql-1.2.0/.hgtags 2020-10-05 18:37:13.000000000 +0200
+++ new/python-sql-1.2.2/.hgtags 2021-05-16 12:18:56.000000000 +0200
@@ -10,3 +10,5 @@
7459778aa23150aa6ac39356621c29d368ae1f36 1.0.0
194182e5b0e2dc6486a32778860f29c80c0672f9 1.1.0
de68c850bc6a809b0c88ddbe2fa99b02df07bee3 1.2.0
+b2bcc0f71f6881316c11330c07de34113f088888 1.2.1
+1c38ffeacbb82a9ff6ae3568cdc017dbbeddff5d 1.2.2
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/CHANGELOG
new/python-sql-1.2.2/CHANGELOG
--- old/python-sql-1.2.0/CHANGELOG 2020-10-05 18:33:14.000000000 +0200
+++ new/python-sql-1.2.2/CHANGELOG 2021-05-16 12:17:30.000000000 +0200
@@ -1,3 +1,11 @@
+Version 1.2.2 - 2021-05-16
+* Escape table and column names containing double quote
+* Use alias on the main table used in UPDATE and INSERT
+* Add support for Python 3.9
+
+Version 1.2.1 - 2020-10-08
+* Fix AttributeError in Select.params with windows
+
Version 1.2.0 - 2020-10-05
* Add explicit Windows to Select
* Fix missing Windows definitions in nested expressions
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/PKG-INFO
new/python-sql-1.2.2/PKG-INFO
--- old/python-sql-1.2.0/PKG-INFO 2020-10-05 18:37:51.000000000 +0200
+++ new/python-sql-1.2.2/PKG-INFO 2021-05-16 12:19:37.180865500 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 1.2
Name: python-sql
-Version: 1.2.0
+Version: 1.2.2
Summary: Library to write SQL queries
Home-page: https://pypi.org/project/python-sql/
Author: Tryton
@@ -118,36 +118,36 @@
Insert query with default values::
>>> tuple(user.insert())
- ('INSERT INTO "user" DEFAULT VALUES', ())
+ ('INSERT INTO "user" AS "a" DEFAULT VALUES', ())
Insert query with values::
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s)', ('Foo',
'foo'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s)',
('Foo', 'foo'))
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo'], ['Bar', 'bar']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s), (%s, %s)',
('Foo', 'foo', 'Bar', 'bar'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s),
(%s, %s)', ('Foo', 'foo', 'Bar', 'bar'))
Insert query with query::
>>> passwd = Table('passwd')
>>> select = passwd.select(passwd.login, passwd.passwd)
>>> tuple(user.insert(values=select))
- ('INSERT INTO "user" SELECT "a"."login", "a"."passwd" FROM
"passwd" AS "a"', ())
+ ('INSERT INTO "user" AS "b" SELECT "a"."login", "a"."passwd" FROM
"passwd" AS "a"', ())
Update query with values::
>>> tuple(user.update(columns=[user.active], values=[True]))
- ('UPDATE "user" SET "active" = %s', (True,))
+ ('UPDATE "user" AS "a" SET "active" = %s', (True,))
>>> tuple(invoice.update(columns=[invoice.total],
values=[invoice.amount + invoice.tax]))
- ('UPDATE "invoice" SET "total" = ("invoice"."amount" +
"invoice"."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" SET "active" = %s WHERE ("user"."active" = %s)',
(True, False))
+ ('UPDATE "user" AS "a" SET "active" = %s WHERE ("a"."active" =
%s)', (True, False))
Update query with from list::
@@ -230,5 +230,6 @@
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: Topic :: Database
Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/README new/python-sql-1.2.2/README
--- old/python-sql-1.2.0/README 2019-11-11 18:46:20.000000000 +0100
+++ new/python-sql-1.2.2/README 2021-05-09 09:36:27.000000000 +0200
@@ -106,36 +106,36 @@
Insert query with default values::
>>> tuple(user.insert())
- ('INSERT INTO "user" DEFAULT VALUES', ())
+ ('INSERT INTO "user" AS "a" DEFAULT VALUES', ())
Insert query with values::
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s)', ('Foo', 'foo'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s)', ('Foo',
'foo'))
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo'], ['Bar', 'bar']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s), (%s, %s)', ('Foo',
'foo', 'Bar', 'bar'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s), (%s, %s)',
('Foo', 'foo', 'Bar', 'bar'))
Insert query with query::
>>> passwd = Table('passwd')
>>> select = passwd.select(passwd.login, passwd.passwd)
>>> tuple(user.insert(values=select))
- ('INSERT INTO "user" SELECT "a"."login", "a"."passwd" FROM "passwd" AS
"a"', ())
+ ('INSERT INTO "user" AS "b" SELECT "a"."login", "a"."passwd" FROM "passwd"
AS "a"', ())
Update query with values::
>>> tuple(user.update(columns=[user.active], values=[True]))
- ('UPDATE "user" SET "active" = %s', (True,))
+ ('UPDATE "user" AS "a" SET "active" = %s', (True,))
>>> tuple(invoice.update(columns=[invoice.total], values=[invoice.amount +
invoice.tax]))
- ('UPDATE "invoice" SET "total" = ("invoice"."amount" + "invoice"."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" SET "active" = %s WHERE ("user"."active" = %s)', (True,
False))
+ ('UPDATE "user" AS "a" SET "active" = %s WHERE ("a"."active" = %s)',
(True, False))
Update query with from list::
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/python_sql.egg-info/PKG-INFO
new/python-sql-1.2.2/python_sql.egg-info/PKG-INFO
--- old/python-sql-1.2.0/python_sql.egg-info/PKG-INFO 2020-10-05
18:37:50.000000000 +0200
+++ new/python-sql-1.2.2/python_sql.egg-info/PKG-INFO 2021-05-16
12:19:36.000000000 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 1.2
Name: python-sql
-Version: 1.2.0
+Version: 1.2.2
Summary: Library to write SQL queries
Home-page: https://pypi.org/project/python-sql/
Author: Tryton
@@ -118,36 +118,36 @@
Insert query with default values::
>>> tuple(user.insert())
- ('INSERT INTO "user" DEFAULT VALUES', ())
+ ('INSERT INTO "user" AS "a" DEFAULT VALUES', ())
Insert query with values::
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s)', ('Foo',
'foo'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s)',
('Foo', 'foo'))
>>> tuple(user.insert(columns=[user.name, user.login],
... values=[['Foo', 'foo'], ['Bar', 'bar']]))
- ('INSERT INTO "user" ("name", "login") VALUES (%s, %s), (%s, %s)',
('Foo', 'foo', 'Bar', 'bar'))
+ ('INSERT INTO "user" AS "a" ("name", "login") VALUES (%s, %s),
(%s, %s)', ('Foo', 'foo', 'Bar', 'bar'))
Insert query with query::
>>> passwd = Table('passwd')
>>> select = passwd.select(passwd.login, passwd.passwd)
>>> tuple(user.insert(values=select))
- ('INSERT INTO "user" SELECT "a"."login", "a"."passwd" FROM
"passwd" AS "a"', ())
+ ('INSERT INTO "user" AS "b" SELECT "a"."login", "a"."passwd" FROM
"passwd" AS "a"', ())
Update query with values::
>>> tuple(user.update(columns=[user.active], values=[True]))
- ('UPDATE "user" SET "active" = %s', (True,))
+ ('UPDATE "user" AS "a" SET "active" = %s', (True,))
>>> tuple(invoice.update(columns=[invoice.total],
values=[invoice.amount + invoice.tax]))
- ('UPDATE "invoice" SET "total" = ("invoice"."amount" +
"invoice"."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" SET "active" = %s WHERE ("user"."active" = %s)',
(True, False))
+ ('UPDATE "user" AS "a" SET "active" = %s WHERE ("a"."active" =
%s)', (True, False))
Update query with from list::
@@ -230,5 +230,6 @@
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: Topic :: Database
Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/setup.py
new/python-sql-1.2.2/setup.py
--- old/python-sql-1.2.0/setup.py 2020-05-11 00:47:40.000000000 +0200
+++ new/python-sql-1.2.2/setup.py 2021-05-09 09:36:27.000000000 +0200
@@ -72,6 +72,7 @@
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
+ 'Programming Language :: Python :: 3.9',
'Topic :: Database',
'Topic :: Software Development :: Libraries :: Python Modules',
],
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/__init__.py
new/python-sql-1.2.2/sql/__init__.py
--- old/python-sql-1.2.0/sql/__init__.py 2020-10-05 18:33:38.000000000
+0200
+++ new/python-sql-1.2.2/sql/__init__.py 2021-05-16 12:15:18.000000000
+0200
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2011-2018, C??dric Krier
-# Copyright (c) 2013-2014, Nicolas ??vrard
-# Copyright (c) 2011-2018, B2CK
+# Copyright (c) 2011-2020, C??dric Krier
+# Copyright (c) 2013-2021, Nicolas ??vrard
+# Copyright (c) 2011-2021, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -36,11 +36,15 @@
from collections import defaultdict
from itertools import chain
-__version__ = '1.2.0'
+__version__ = '1.2.2'
__all__ = ['Flavor', 'Table', 'Values', 'Literal', 'Column', 'Join',
'Asc', 'Desc', 'NullsFirst', 'NullsLast', 'format2numeric']
+def _escape_identifier(name):
+ return '"%s"' % name.replace('"', '""')
+
+
def alias(i, letters=string.ascii_lowercase):
'''
Generate a unique alias based on integer
@@ -637,8 +641,8 @@
p = []
with AliasManager():
# Set alias to window function to skip their params
- for window_function in self.windows:
- window_function.alias
+ for window in self.windows:
+ window.alias
p.extend(self._with_params())
for column in chain(self.distinct_on or (), self.columns):
@@ -657,8 +661,8 @@
p.extend(expression.params)
if self.having:
p.extend(self.having.params)
- for window_function in self.windows:
- p.extend(window_function.window.params)
+ for window in self.windows:
+ p.extend(window.params)
return tuple(p)
@@ -735,21 +739,19 @@
if self.columns:
assert all(col.table == self.table for col in self.columns)
columns = ' (' + ', '.join(map(str, self.columns)) + ')'
- if isinstance(self.values, Query):
- values = ' %s' % str(self.values)
- # TODO manage DEFAULT
- elif self.values is None:
- values = ' DEFAULT VALUES'
with AliasManager():
- table = self.table
- AliasManager.set(table, str(table)[1:-1])
+ if isinstance(self.values, Query):
+ values = ' %s' % str(self.values)
+ # TODO manage DEFAULT
+ elif self.values is None:
+ values = ' DEFAULT VALUES'
returning = ''
if self.returning:
returning = ' RETURNING ' + ', '.join(
map(self._format, self.returning))
return (self._with_str()
- + 'INSERT INTO %s' % self.table + columns
- + values + returning)
+ + 'INSERT INTO %s AS "%s"' % (self.table, self.table.alias)
+ + columns + values + returning)
@property
def params(self):
@@ -804,11 +806,7 @@
with AliasManager():
from_ = ''
if self.from_:
- table = From([self.table])
from_ = ' FROM %s' % str(self.from_)
- else:
- table = self.table
- AliasManager.set(table, str(table)[1:-1])
values = ', '.join('%s = %s' % (c, self._format(v))
for c, v in zip(columns, self.values))
where = ''
@@ -819,8 +817,8 @@
returning = ' RETURNING ' + ', '.join(
map(self._format, self.returning))
return (self._with_str()
- + 'UPDATE %s SET ' % table + values + from_
- + where + returning)
+ + 'UPDATE %s AS "%s" SET ' % (self.table, self.table.alias)
+ + values + from_ + where + returning)
@property
def params(self):
@@ -970,13 +968,8 @@
self._database = database
def __str__(self):
- if self._database:
- return '"%s"."%s"."%s"' % (
- self._database, self._schema, self._name)
- elif self._schema:
- return '"%s"."%s"' % (self._schema, self._name)
- else:
- return '"%s"' % self._name
+ return '.'.join(map(_escape_identifier, filter(None,
+ (self._database, self._schema, self._name))))
@property
def params(self):
@@ -1354,16 +1347,13 @@
return self._name
def __str__(self):
- if self._name == '*':
- t = '%s'
- else:
- t = '"%s"'
+ name = (self._name if self._name == '*'
+ else _escape_identifier(self._name))
alias = self._from.alias
if alias:
- t = '"%s".' + t
- return t % (alias, self._name)
+ return '%s.%s' % (_escape_identifier(alias), name)
else:
- return t % self._name
+ return name
@property
def params(self):
@@ -1379,7 +1369,7 @@
self.output_name = output_name
def __str__(self):
- return '"%s"' % self.output_name
+ return '%s' % _escape_identifier(self.output_name)
@property
def params(self):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_as.py
new/python-sql-1.2.2/sql/tests/test_as.py
--- old/python-sql-1.2.0/sql/tests/test_as.py 2018-08-18 13:25:33.000000000
+0200
+++ new/python-sql-1.2.2/sql/tests/test_as.py 2020-10-08 11:21:24.000000000
+0200
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2011-2013, C??dric Krier
-# Copyright (c) 2011-2013, B2CK
+# Copyright (c) 2011-2020, C??dric Krier
+# Copyright (c) 2011-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -41,13 +41,13 @@
def test_as_select(self):
query = self.table.select(self.column.as_('foo'))
self.assertEqual(str(query), 'SELECT "a"."c" AS "foo" FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_no_as(self):
query = self.table.select(self.column.as_('foo'))
try:
Flavor.set(Flavor(no_as=True))
self.assertEqual(str(query), 'SELECT "a"."c" "foo" FROM "t" "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
finally:
Flavor.set(Flavor())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_column.py
new/python-sql-1.2.2/sql/tests/test_column.py
--- old/python-sql-1.2.0/sql/tests/test_column.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_column.py 2021-05-16
12:16:46.000000000 +0200
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
#
# Copyright (c) 2011-2013, C??dric Krier
-# Copyright (c) 2011-2013, B2CK
+# Copyright (c) 2021, Nicolas ??vrard
+# Copyright (c) 2011-2021, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -39,3 +40,11 @@
with AliasManager():
self.assertEqual(str(column), '"a"."c"')
+
+ def test_quote_in_column(self):
+ column = Column(Table('t'), 'b "c"')
+ self.assertEqual(str(column), '"b ""c"""')
+ self.assertEqual(column.name, 'b "c"')
+
+ with AliasManager():
+ self.assertEqual(str(column), '"a"."b ""c"""')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_combining_query.py
new/python-sql-1.2.2/sql/tests/test_combining_query.py
--- old/python-sql-1.2.0/sql/tests/test_combining_query.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_combining_query.py 2020-10-08
11:21:39.000000000 +0200
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2014, C??dric Krier
-# Copyright (c) 2014, B2CK
+# Copyright (c) 2014-2020, C??dric Krier
+# Copyright (c) 2014-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -40,34 +40,34 @@
query = Union(self.q1, self.q2)
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = self.q1 | self.q2
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_union3(self):
query = Union(self.q1, self.q2, self.q3)
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b" '
'UNION SELECT * FROM "t3" AS "c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = Union(Union(self.q1, self.q2), self.q3)
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b" '
'UNION SELECT * FROM "t3" AS "c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = Union(self.q1, Union(self.q2, self.q3))
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b" '
'UNION SELECT * FROM "t3" AS "c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = self.q1 | self.q2 | self.q3
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a" UNION SELECT * FROM "t2" AS "b" '
'UNION SELECT * FROM "t3" AS "c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_insert.py
new/python-sql-1.2.2/sql/tests/test_insert.py
--- old/python-sql-1.2.0/sql/tests/test_insert.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_insert.py 2021-05-16
12:15:33.000000000 +0200
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2011-2013, C??dric Krier
-# Copyright (c) 2013, Nicolas ??vrard
-# Copyright (c) 2011-2013, B2CK
+# Copyright (c) 2011-2020, C??dric Krier
+# Copyright (c) 2013-2021, Nicolas ??vrard
+# Copyright (c) 2011-2021, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -38,22 +38,22 @@
def test_insert_default(self):
query = self.table.insert()
- self.assertEqual(str(query), 'INSERT INTO "t" DEFAULT VALUES')
- self.assertEqual(query.params, ())
+ self.assertEqual(str(query), 'INSERT INTO "t" AS "a" DEFAULT VALUES')
+ self.assertEqual(tuple(query.params), ())
def test_insert_values(self):
query = self.table.insert([self.table.c1, self.table.c2],
[['foo', 'bar']])
self.assertEqual(str(query),
- 'INSERT INTO "t" ("c1", "c2") VALUES (%s, %s)')
- self.assertEqual(query.params, ('foo', 'bar'))
+ 'INSERT INTO "t" AS "a" ("c1", "c2") VALUES (%s, %s)')
+ self.assertEqual(tuple(query.params), ('foo', 'bar'))
def test_insert_many_values(self):
query = self.table.insert([self.table.c1, self.table.c2],
[['foo', 'bar'], ['spam', 'eggs']])
self.assertEqual(str(query),
- 'INSERT INTO "t" ("c1", "c2") VALUES (%s, %s), (%s, %s)')
- self.assertEqual(query.params, ('foo', 'bar', 'spam', 'eggs'))
+ 'INSERT INTO "t" AS "a" ("c1", "c2") VALUES (%s, %s), (%s, %s)')
+ self.assertEqual(tuple(query.params), ('foo', 'bar', 'spam', 'eggs'))
def test_insert_subselect(self):
t1 = Table('t1')
@@ -61,23 +61,23 @@
subquery = t2.select(t2.c1, t2.c2)
query = t1.insert([t1.c1, t1.c2], subquery)
self.assertEqual(str(query),
- 'INSERT INTO "t1" ("c1", "c2") '
+ 'INSERT INTO "t1" AS "b" ("c1", "c2") '
'SELECT "a"."c1", "a"."c2" FROM "t2" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_insert_function(self):
query = self.table.insert([self.table.c], [[Abs(-1)]])
self.assertEqual(str(query),
- 'INSERT INTO "t" ("c") VALUES (ABS(%s))')
- self.assertEqual(query.params, (-1,))
+ 'INSERT INTO "t" AS "a" ("c") VALUES (ABS(%s))')
+ self.assertEqual(tuple(query.params), (-1,))
def test_insert_returning(self):
query = self.table.insert([self.table.c1, self.table.c2],
[['foo', 'bar']], returning=[self.table.c1, self.table.c2])
self.assertEqual(str(query),
- 'INSERT INTO "t" ("c1", "c2") VALUES (%s, %s) '
- 'RETURNING "t"."c1", "t"."c2"')
- self.assertEqual(query.params, ('foo', 'bar'))
+ 'INSERT INTO "t" AS "a" ("c1", "c2") VALUES (%s, %s) '
+ 'RETURNING "a"."c1", "a"."c2"')
+ self.assertEqual(tuple(query.params), ('foo', 'bar'))
def test_insert_returning_select(self):
t1 = Table('t1')
@@ -86,10 +86,10 @@
returning=[
t2.select(t2.c, where=(t2.c1 == t1.c) & (t2.c2 == 'bar'))])
self.assertEqual(str(query),
- 'INSERT INTO "t1" ("c") VALUES (%s) '
- 'RETURNING (SELECT "b"."c" FROM "t2" AS "b" '
- 'WHERE (("b"."c1" = "t1"."c") AND ("b"."c2" = %s)))')
- self.assertEqual(query.params, ('foo', 'bar'))
+ '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)))')
+ self.assertEqual(tuple(query.params), ('foo', 'bar'))
def test_with(self):
t1 = Table('t1')
@@ -100,14 +100,14 @@
with_=[w],
values=w.select())
self.assertEqual(str(query),
- 'WITH "b" AS (SELECT * FROM "t1" AS "c") '
- 'INSERT INTO "t" ("c1") SELECT * FROM "a" AS "a"')
- self.assertEqual(query.params, ())
+ 'WITH "a" AS (SELECT * FROM "t1" AS "b") '
+ 'INSERT INTO "t" AS "c" ("c1") SELECT * FROM "a" AS "a"')
+ self.assertEqual(tuple(query.params), ())
def test_schema(self):
t1 = Table('t1', 'default')
query = t1.insert([t1.c1], [['foo']])
self.assertEqual(str(query),
- 'INSERT INTO "default"."t1" ("c1") VALUES (%s)')
- self.assertEqual(query.params, ('foo',))
+ 'INSERT INTO "default"."t1" AS "a" ("c1") VALUES (%s)')
+ self.assertEqual(tuple(query.params), ('foo',))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_join.py
new/python-sql-1.2.2/sql/tests/test_join.py
--- old/python-sql-1.2.0/sql/tests/test_join.py 2018-08-18 13:25:33.000000000
+0200
+++ new/python-sql-1.2.2/sql/tests/test_join.py 2020-10-08 11:22:04.000000000
+0200
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2011-2013, C??dric Krier
-# Copyright (c) 2011-2013, B2CK
+# Copyright (c) 2011-2020, C??dric Krier
+# Copyright (c) 2011-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -39,7 +39,7 @@
join = Join(t1, t2)
with AliasManager():
self.assertEqual(str(join), '"t1" AS "a" INNER JOIN "t2" AS "b"')
- self.assertEqual(join.params, ())
+ self.assertEqual(tuple(join.params), ())
join.condition = t1.c == t2.c
with AliasManager():
@@ -56,11 +56,11 @@
self.assertEqual(str(join),
'"t1" AS "a" INNER JOIN (SELECT * FROM "t2" AS "c") AS "b" '
'ON ("a"."c" = "b"."c")')
- self.assertEqual(join.params, ())
+ self.assertEqual(tuple(join.params), ())
def test_join_function(self):
t1 = Table('t1')
join = Join(t1, Now())
with AliasManager():
self.assertEqual(str(join), '"t1" AS "a" INNER JOIN NOW() AS "b"')
- self.assertEqual(join.params, ())
+ self.assertEqual(tuple(join.params), ())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_lateral.py
new/python-sql-1.2.2/sql/tests/test_lateral.py
--- old/python-sql-1.2.0/sql/tests/test_lateral.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_lateral.py 2020-10-08
11:22:16.000000000 +0200
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2015, C??dric Krier
-# Copyright (c) 2015, B2CK
+# Copyright (c) 2015-2020, C??dric Krier
+# Copyright (c) 2015-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -43,7 +43,7 @@
self.assertEqual(str(query),
'SELECT * FROM "t1" AS "a", LATERAL '
'(SELECT * FROM "t2" AS "c" WHERE ("c"."id" = "a"."t2")) AS "b"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_lateral_function(self):
@@ -56,4 +56,4 @@
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a", LATERAL FUNC("a"."a") AS "b"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_select.py
new/python-sql-1.2.2/sql/tests/test_select.py
--- old/python-sql-1.2.0/sql/tests/test_select.py 2020-09-29
12:59:59.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_select.py 2020-10-08
11:22:26.000000000 +0200
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2011-2016, C??dric Krier
+# Copyright (c) 2011-2020, C??dric Krier
# Copyright (c) 2013-2014, Nicolas ??vrard
-# Copyright (c) 2011-2016, B2CK
+# Copyright (c) 2011-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -42,12 +42,12 @@
def test_select1(self):
query = self.table.select()
self.assertEqual(str(query), 'SELECT * FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_select2(self):
query = self.table.select(self.table.c)
self.assertEqual(str(query), 'SELECT "a"."c" FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.columns += (self.table.c2,)
self.assertEqual(str(query),
@@ -57,41 +57,41 @@
query = self.table.select(where=(self.table.c == 'foo'))
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s)')
- self.assertEqual(query.params, ('foo',))
+ self.assertEqual(tuple(query.params), ('foo',))
def test_select_without_from(self):
query = Select([Literal(1)])
self.assertEqual(str(query), 'SELECT %s')
- self.assertEqual(query.params, (1,))
+ self.assertEqual(tuple(query.params), (1,))
def test_select_select(self):
query = Select([Select([Literal(1)])])
self.assertEqual(str(query), 'SELECT (SELECT %s)')
- self.assertEqual(query.params, (1,))
+ self.assertEqual(tuple(query.params), (1,))
def test_select_select_as(self):
query = Select([Select([Literal(1)]).as_('foo')])
self.assertEqual(str(query), 'SELECT (SELECT %s) AS "foo"')
- self.assertEqual(query.params, (1,))
+ self.assertEqual(tuple(query.params), (1,))
def test_select_distinct(self):
query = self.table.select(self.table.c, distinct=True)
self.assertEqual(
str(query), 'SELECT DISTINCT "a"."c" FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_select_distinct_on(self):
query = self.table.select(self.table.c, distinct_on=self.table.c)
self.assertEqual(
str(query), 'SELECT DISTINCT ON ("a"."c") "a"."c" FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = self.table.select(
self.table.c, distinct_on=[self.table.a, self.table.b])
self.assertEqual(
str(query),
'SELECT DISTINCT ON ("a"."a", "a"."b") "a"."c" FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_select_from_list(self):
t2 = Table('t2')
@@ -99,7 +99,7 @@
query = (self.table + t2 + t3).select(self.table.c, getattr(t2, '*'))
self.assertEqual(str(query),
'SELECT "a"."c", "b".* FROM "t" AS "a", "t2" AS "b", "t3" AS "c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_select_union(self):
query1 = self.table.select()
@@ -119,11 +119,11 @@
self.assertEqual(str(union),
'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s) UNION ALL '
'SELECT * FROM "t2" AS "b"')
- self.assertEqual(union.params, ('foo',))
+ self.assertEqual(tuple(union.params), ('foo',))
union = Union(query1)
self.assertEqual(str(union), str(query1))
- self.assertEqual(union.params, query1.params)
+ self.assertEqual(tuple(union.params), tuple(query1.params))
def test_select_union_order(self):
query1 = self.table.select()
@@ -134,7 +134,7 @@
'SELECT * FROM "t" AS "a" UNION '
'SELECT * FROM "t2" AS "b" '
'ORDER BY %s')
- self.assertEqual(union.params, (1,))
+ self.assertEqual(tuple(union.params), (1,))
def test_select_intersect(self):
query1 = self.table.select()
@@ -176,12 +176,12 @@
select = t1.select()
self.assertEqual(str(select.select()),
'SELECT * FROM (SELECT * FROM "t1" AS "b") AS "a"')
- self.assertEqual(select.params, ())
+ self.assertEqual(tuple(select.params), ())
def test_select_function(self):
query = Now().select()
self.assertEqual(str(query), 'SELECT * FROM NOW() AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_select_function_columns_definitions(self):
class Crosstab(Function):
@@ -192,25 +192,25 @@
('c1', 'INT'), ('c2', 'CHAR'), ('c3', 'BOOL')]).select()
self.assertEqual(str(query), 'SELECT * FROM CROSSTAB(%s, %s) '
'AS "a" ("c1" INT, "c2" CHAR, "c3" BOOL)')
- self.assertEqual(query.params, ('query1', 'query2'))
+ self.assertEqual(tuple(query.params), ('query1', 'query2'))
def test_select_group_by(self):
column = self.table.c
query = self.table.select(column, group_by=column)
self.assertEqual(str(query),
'SELECT "a"."c" FROM "t" AS "a" GROUP BY "a"."c"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
output = column.as_('c1')
query = self.table.select(output, group_by=output)
self.assertEqual(str(query),
'SELECT "a"."c" AS "c1" FROM "t" AS "a" GROUP BY "c1"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = self.table.select(Literal('foo'), group_by=Literal('foo'))
self.assertEqual(str(query),
'SELECT %s FROM "t" AS "a" GROUP BY %s')
- self.assertEqual(query.params, ('foo', 'foo'))
+ self.assertEqual(tuple(query.params), ('foo', 'foo'))
def test_select_having(self):
col1 = self.table.col1
@@ -220,14 +220,14 @@
self.assertEqual(str(query),
'SELECT "a"."col1", MIN("a"."col2") FROM "t" AS "a" '
'HAVING (MIN("a"."col2") > %s)')
- self.assertEqual(query.params, (3,))
+ self.assertEqual(tuple(query.params), (3,))
def test_select_order(self):
c = self.table.c
query = self.table.select(c, order_by=Literal(1))
self.assertEqual(str(query),
'SELECT "a"."c" FROM "t" AS "a" ORDER BY %s')
- self.assertEqual(query.params, (1,))
+ self.assertEqual(tuple(query.params), (1,))
def test_select_limit_offset(self):
try:
@@ -235,34 +235,34 @@
query = self.table.select(limit=50, offset=10)
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" LIMIT 50 OFFSET 10')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.limit = None
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" OFFSET 10')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.offset = 0
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
Flavor.set(Flavor(limitstyle='limit', max_limit=-1))
query.offset = None
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.offset = 0
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.offset = 10
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" LIMIT -1 OFFSET 10')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
finally:
Flavor.set(Flavor())
@@ -273,17 +273,17 @@
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" '
'OFFSET (10) ROWS FETCH FIRST (50) ROWS ONLY')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.limit = None
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a" OFFSET (10) ROWS')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query.offset = 0
self.assertEqual(str(query),
'SELECT * FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
finally:
Flavor.set(Flavor())
@@ -297,7 +297,7 @@
'SELECT * FROM "t" AS "c") AS "b" '
'WHERE (ROWNUM <= %s)) AS "a" '
'WHERE ("rnum" > %s)')
- self.assertEqual(query.params, (60, 10))
+ self.assertEqual(tuple(query.params), (60, 10))
query = self.table.select(
self.table.c1.as_('col1'), self.table.c2.as_('col2'),
@@ -309,7 +309,7 @@
'FROM "t" AS "c") AS "b" '
'WHERE (ROWNUM <= %s)) AS "a" '
'WHERE ("rnum" > %s)')
- self.assertEqual(query.params, (60, 10))
+ self.assertEqual(tuple(query.params), (60, 10))
subquery = query.select(query.col1, query.col2)
self.assertEqual(str(subquery),
@@ -323,7 +323,7 @@
'WHERE ("rnum" > %s)) AS "a"')
# XXX alias of query is reused but not a problem
# as it is hidden in subquery
- self.assertEqual(query.params, (60, 10))
+ self.assertEqual(tuple(query.params), (60, 10))
query = self.table.select(limit=50, offset=10,
order_by=[self.table.c])
@@ -333,14 +333,14 @@
'SELECT * FROM "t" AS "c" ORDER BY "c"."c") AS "b" '
'WHERE (ROWNUM <= %s)) AS "a" '
'WHERE ("rnum" > %s)')
- self.assertEqual(query.params, (60, 10))
+ 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)')
- self.assertEqual(query.params, (50,))
+ self.assertEqual(tuple(query.params), (50,))
query = self.table.select(offset=10)
self.assertEqual(str(query),
@@ -348,7 +348,7 @@
'SELECT "b".*, ROWNUM AS "rnum" FROM ('
'SELECT * FROM "t" AS "c") AS "b") AS "a" '
'WHERE ("rnum" > %s)')
- self.assertEqual(query.params, (10,))
+ self.assertEqual(tuple(query.params), (10,))
query = self.table.select(self.table.c.as_('col'),
where=self.table.c >= 20,
@@ -360,7 +360,7 @@
'WHERE ("c"."c" >= %s)) AS "b" '
'WHERE (ROWNUM <= %s)) AS "a" '
'WHERE ("rnum" > %s)')
- self.assertEqual(query.params, (20, 60, 10))
+ self.assertEqual(tuple(query.params), (20, 60, 10))
finally:
Flavor.set(Flavor())
@@ -369,14 +369,14 @@
query = self.table.select(c, for_=For('UPDATE'))
self.assertEqual(str(query),
'SELECT "a"."c" FROM "t" AS "a" FOR UPDATE')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_copy(self):
query = self.table.select()
copy_query = deepcopy(query)
self.assertNotEqual(query, copy_query)
self.assertEqual(str(copy_query), 'SELECT * FROM "t" AS "a"')
- self.assertEqual(copy_query.params, ())
+ self.assertEqual(tuple(copy_query.params), ())
def test_with(self):
w = With(query=self.table.select(self.table.c1))
@@ -385,7 +385,7 @@
self.assertEqual(str(query),
'WITH "a" AS (SELECT "b"."c1" FROM "t" AS "b") '
'SELECT * FROM "a" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
def test_window(self):
query = self.table.select(Min(self.table.c1,
@@ -394,13 +394,13 @@
self.assertEqual(str(query),
'SELECT MIN("a"."c1") OVER "b" FROM "t" AS "a" '
'WINDOW "b" AS (PARTITION BY "a"."c2")')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
query = self.table.select(Rank(window=Window([])))
self.assertEqual(str(query),
'SELECT RANK() OVER "b" FROM "t" AS "a" '
'WINDOW "b" AS ()')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
window = Window([self.table.c1])
query = self.table.select(
@@ -410,7 +410,7 @@
'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(query.params, (0,))
+ self.assertEqual(tuple(query.params), (0,))
window = Window([DatePart('year', self.table.date_col)])
query = self.table.select(
@@ -418,7 +418,7 @@
self.assertEqual(str(query),
'SELECT MIN("a"."c1") OVER "b" FROM "t" AS "a" '
'WINDOW "b" AS (PARTITION BY DATE_PART(%s, "a"."date_col"))')
- self.assertEqual(query.params, ('year',))
+ self.assertEqual(tuple(query.params), ('year',))
window = Window([self.table.c2])
query = self.table.select(
@@ -428,7 +428,7 @@
'SELECT (MAX("a"."c1") OVER (PARTITION BY "a"."c2") '
'/ MIN("a"."c1") OVER (PARTITION BY "a"."c2")) '
'FROM "t" AS "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
window = Window([Literal(1)])
query = self.table.select(
@@ -438,7 +438,7 @@
'SELECT (MAX("a"."c1") OVER (PARTITION BY %s) '
'/ MIN("a"."c1") OVER (PARTITION BY %s)) '
'FROM "t" AS "a"')
- self.assertEqual(query.params, (1, 1))
+ self.assertEqual(tuple(query.params), (1, 1))
window1 = Window([self.table.c2])
window2 = Window([Literal(1)])
@@ -451,7 +451,7 @@
'/ MIN("a"."c1") OVER (PARTITION BY %s)) '
'FROM "t" AS "a" '
'WINDOW "b" AS (PARTITION BY "a"."c2")')
- self.assertEqual(query.params, (1,))
+ self.assertEqual(tuple(query.params), (1,))
def test_order_params(self):
with_ = With(query=self.table.select(self.table.c,
@@ -464,13 +464,13 @@
group_by=[Literal(5)],
order_by=[Literal(6)],
having=Literal(7))
- self.assertEqual(query.params, (1, 2, 3, 4, 5, 6, 7, 8))
+ self.assertEqual(tuple(query.params), (1, 2, 3, 4, 5, 6, 7, 8))
def test_no_as(self):
query = self.table.select(self.table.c)
try:
Flavor.set(Flavor(no_as=True))
self.assertEqual(str(query), 'SELECT "a"."c" FROM "t" "a"')
- self.assertEqual(query.params, ())
+ self.assertEqual(tuple(query.params), ())
finally:
Flavor.set(Flavor())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_table.py
new/python-sql-1.2.2/sql/tests/test_table.py
--- old/python-sql-1.2.0/sql/tests/test_table.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_table.py 2021-05-16
12:17:10.000000000 +0200
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
#
# Copyright (c) 2015, C??dric Krier
-# Copyright (c) 2015, B2CK
+# Copyright (c) 2021, Nicolas ??vrard
+# Copyright (c) 2015-2021, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -38,6 +39,10 @@
t = Table('mytable')
self.assertEqual(str(t), '"mytable"')
+ def test_quoted_name(self):
+ t = Table('my "quoted" name')
+ self.assertEqual(str(t), '"my ""quoted"" name"')
+
def test_schema(self):
t = Table('mytable', schema='myschema')
self.assertEqual(str(t), '"myschema"."mytable"')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_update.py
new/python-sql-1.2.2/sql/tests/test_update.py
--- old/python-sql-1.2.0/sql/tests/test_update.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_update.py 2021-05-16
12:16:03.000000000 +0200
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
#
# Copyright (c) 2011-2013, C??dric Krier
-# Copyright (c) 2011-2013, B2CK
+# Copyright (c) 2021, Nicolas ??vrard
+# Copyright (c) 2011-2021, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -36,12 +37,12 @@
def test_update1(self):
query = self.table.update([self.table.c], ['foo'])
- self.assertEqual(str(query), 'UPDATE "t" SET "c" = %s')
+ self.assertEqual(str(query), 'UPDATE "t" AS "a" SET "c" = %s')
self.assertEqual(query.params, ('foo',))
query.where = (self.table.b == Literal(True))
self.assertEqual(str(query),
- 'UPDATE "t" SET "c" = %s WHERE ("t"."b" = %s)')
+ 'UPDATE "t" AS "a" SET "c" = %s WHERE ("a"."b" = %s)')
self.assertEqual(query.params, ('foo', True))
def test_update2(self):
@@ -60,15 +61,15 @@
query_nolist = t1.update([t1.c], t2.select(t2.c, where=t2.i == t1.i))
for query in [query_list, query_nolist]:
self.assertEqual(str(query),
- 'UPDATE "t1" SET "c" = ('
- 'SELECT "b"."c" FROM "t2" AS "b" WHERE ("b"."i" = "t1"."i"))')
+ 'UPDATE "t1" AS "b" SET "c" = ('
+ 'SELECT "a"."c" FROM "t2" AS "a" WHERE ("a"."i" = "b"."i"))')
self.assertEqual(query.params, ())
def test_update_returning(self):
query = self.table.update([self.table.c], ['foo'],
returning=[self.table.c])
self.assertEqual(str(query),
- 'UPDATE "t" SET "c" = %s RETURNING "t"."c"')
+ 'UPDATE "t" AS "a" SET "c" = %s RETURNING "a"."c"')
self.assertEqual(query.params, ('foo',))
def test_update_returning_select(self):
@@ -78,9 +79,9 @@
returning=[
t2.select(t2.c, where=(t2.c1 == t1.c) & (t2.c2 == 'bar'))])
self.assertEqual(str(query),
- 'UPDATE "t1" SET "c" = %s '
- 'RETURNING (SELECT "b"."c" FROM "t2" AS "b" '
- 'WHERE (("b"."c1" = "t1"."c") AND ("b"."c2" = %s)))')
+ 'UPDATE "t1" AS "b" SET "c" = %s '
+ 'RETURNING (SELECT "a"."c" FROM "t2" AS "a" '
+ 'WHERE (("a"."c1" = "b"."c") AND ("a"."c2" = %s)))')
self.assertEqual(query.params, ('foo', 'bar'))
def test_with(self):
@@ -92,16 +93,17 @@
with_=[w],
values=[w.select(w.c3, where=w.c4 == 2)])
self.assertEqual(str(query),
- 'WITH "b" AS (SELECT "c"."c1" FROM "t1" AS "c") '
- 'UPDATE "t" SET "c2" = (SELECT "b"."c3" FROM "b" AS "b" '
- 'WHERE ("b"."c4" = %s))')
+ '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))')
self.assertEqual(query.params, (2,))
def test_schema(self):
t1 = Table('t1', 'default')
query = t1.update([t1.c1], ['foo'])
- self.assertEqual(str(query), 'UPDATE "default"."t1" SET "c1" = %s')
+ self.assertEqual(
+ str(query), 'UPDATE "default"."t1" AS "a" SET "c1" = %s')
self.assertEqual(query.params, ('foo',))
def test_schema_subselect(self):
@@ -110,7 +112,7 @@
query = t1.update([t1.c1], t2.select(t2.c, where=t2.i == t1.i))
self.assertEqual(str(query),
- 'UPDATE "default"."t1" SET "c1" = ('
- 'SELECT "b"."c" FROM "default"."t2" AS "b" '
- 'WHERE ("b"."i" = "default"."t1"."i"))')
+ 'UPDATE "default"."t1" AS "b" SET "c1" = ('
+ 'SELECT "a"."c" FROM "default"."t2" AS "a" '
+ 'WHERE ("a"."i" = "b"."i"))')
self.assertEqual(query.params, ())
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_values.py
new/python-sql-1.2.2/sql/tests/test_values.py
--- old/python-sql-1.2.0/sql/tests/test_values.py 2018-08-18
13:25:33.000000000 +0200
+++ new/python-sql-1.2.2/sql/tests/test_values.py 2020-10-08
11:22:36.000000000 +0200
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
#
-# Copyright (c) 2014, C??dric Krier
-# Copyright (c) 2014, B2CK
+# Copyright (c) 2014-2020, C??dric Krier
+# Copyright (c) 2014-2020, B2CK
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -47,7 +47,7 @@
query = values.select()
self.assertEqual(str(query),
'SELECT * FROM (VALUES (%s), (%s), (%s)) AS "a"')
- self.assertEqual(query.params, (1, 2, 3))
+ self.assertEqual(tuple(query.params), (1, 2, 3))
def test_union(self):
values = Values([[1]])
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/sql/tests/test_with.py
new/python-sql-1.2.2/sql/tests/test_with.py
--- old/python-sql-1.2.0/sql/tests/test_with.py 2018-08-18 13:25:33.000000000
+0200
+++ new/python-sql-1.2.2/sql/tests/test_with.py 2020-10-08 11:23:02.000000000
+0200
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
#
# Copyright (c) 2014, Nicolas ??vrard
-# Copyright (c) 2014, B2CK
+# Copyright (c) 2014-2020, B2CK
+# Copyright (c) 2020, C??dric Krier
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
@@ -87,4 +88,4 @@
'UNION ALL '
'SELECT ("a"."n" + %s) FROM "a" AS "a" WHERE ("a"."n" < %s)'
') SELECT * FROM "a" AS "a"')
- self.assertEqual(q.params, (1, 1, 100))
+ self.assertEqual(tuple(q.params), (1, 1, 100))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/python-sql-1.2.0/tox.ini new/python-sql-1.2.2/tox.ini
--- old/python-sql-1.2.0/tox.ini 2019-12-26 10:47:34.000000000 +0100
+++ new/python-sql-1.2.2/tox.ini 2021-05-09 09:36:27.000000000 +0200
@@ -4,7 +4,7 @@
# and then run "tox" from this directory.
[tox]
-envlist = py26, py27, py33, py34, py35, py36, py37, py38, pypy, pypy3, jython
+envlist = py26, py27, py33, py34, py35, py36, py37, py38, py39, pypy, pypy3,
jython
[testenv]
commands = {envpython} setup.py test
