python-sql 1.4.3__py3-none-any.whl → 1.5.1__py3-none-any.whl

{python_sql-1.4.3.dist-info → python_sql-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sql
-Version: 1.4.3
+Version: 1.5.1
 Summary: Library to write SQL queries
 Home-page: https://pypi.org/project/python-sql/
 Download-URL: https://downloads.tryton.org/python-sql/

{python_sql-1.4.3.dist-info → python_sql-1.5.1.dist-info}/RECORD

@@ -1,13 +1,8 @@
-sql/__init__.py,sha256=Nfvxf94uY_FkBq0WQAY4ytJSd0Jph72l6kxOAR-u8p8,47512
+sql/__init__.py,sha256=gmmbZtl-Xz2V_wc5HDJMcTdjoXdfgYueu42AaAoha_Y,60610
 sql/aggregate.py,sha256=Dmog1JIuFZ8fFT8RjeGbWGU7kCdJcMrNlwTSO1HIwc8,5241
 sql/conditionals.py,sha256=xJY6ffEBeES6CiGKErXSa2dK2FXaEaR_QQl_CKILP30,2541
-sql/functions.py,sha256=MEd0EHMAwYlOWbLXSLhN-FHDryzKgWE9kjdF-z6LBUM,12307
-sql/operators.py,sha256=xKQF-uzV8lNnQQwabJqXPht3ZTkThOPfZDpq4HGUuAw,10782
-sql/__pycache__/__init__.cpython-39.pyc,sha256=BlJWuvgStja33Lcn3WPzflsHCJJ-5Ddja7R5j1fYenY,54412
-sql/__pycache__/aggregate.cpython-39.pyc,sha256=6yGP5PBW49MbIQHiKl7qfWdKyG01CL-iJaMHhFddWoY,6155
-sql/__pycache__/conditionals.cpython-39.pyc,sha256=wSI0Vk5XDr6gVs2DSoUZX8WT21bNr3DfRy1QV-BtEo0,2961
-sql/__pycache__/functions.cpython-39.pyc,sha256=SOd0flReMnTi_2hTrm3nrLXTYD9dBUX4FHkdVqIkgf4,17408
-sql/__pycache__/operators.cpython-39.pyc,sha256=LuFoz-JMNGcm0sEh2-zqEuJSatOpbcUKO5ANvWE7ujs,14996
+sql/functions.py,sha256=qdmLZ5eoqIsc7erlPsdByecUey7rexhVdUTSB_RnOZ4,12373
+sql/operators.py,sha256=cuh2pvRDNbWbWwE4su9dwsuDxPlJ_S9gn3U-iVvrbKE,10788
 sql/tests/__init__.py,sha256=oHBEqcjoFLDwTiSIDwYNLS8Vj1lkq8-O5DsTKCh1BJw,675
 sql/tests/test_aggregate.py,sha256=7KDN81zxzkVjjoHHLpQMvB-yVqwkKdPoKuppqmWfDYI,2592
 sql/tests/test_alias.py,sha256=AcMrKVvFPsR84BRGc_dN6t3O5vAqNjBeWicb6I6EuBI,1884
@@ -20,19 +15,20 @@ sql/tests/test_conditionals.py,sha256=kNkgsjOatXpJnF9AED03ANNd0zWIwWTrnWdi4PWfl3
 sql/tests/test_delete.py,sha256=0xEllZmXVc9YH6lGJI0_DVXCpB1CTc-e62GK0_fnoM4,1591
 sql/tests/test_for.py,sha256=6e4n7NbKTdlEp_z6MrNT_eM8rwXR94gANtBmWzhxcjk,550
 sql/tests/test_functions.py,sha256=CM-a0c1ey9uEhw3wFL8PWETB3Kpl5wtkGNLt44r_0EE,5377
-sql/tests/test_insert.py,sha256=PbhBySrLog4H0GNG9X5WOPRzeKkbyjXNTE467HhKjqU,3972
+sql/tests/test_insert.py,sha256=1jt2nNrNRdxH7VykkQCwjiVK-LJmmjaGiDaqUJWeh9U,7378
 sql/tests/test_join.py,sha256=OWFqe2Zbb-uDTzg9b0GcH2p2xzhinuvy6E_ANMCOD-Y,1891
 sql/tests/test_lateral.py,sha256=f6hlapGKJ-ZWobMPktN4mSNXgfyNr7O5ZwZASb_oo30,1046
 sql/tests/test_literal.py,sha256=ht-VLhGdpUm_rbtOzpQgbX3YQup_xp7F9va0RSWY0Ts,1010
-sql/tests/test_operators.py,sha256=9r9fCmlWjx9kj1KqMwX3JO0kyHRUnv3qTP_haWTXiNQ,15639
+sql/tests/test_merge.py,sha256=CWF7grhpfqlgNUlafDr9Xbx-EY9uGMFbJRPGoLf5pd8,4074
+sql/tests/test_operators.py,sha256=6j6AEK5_xKJq-WC7Q9fXDE5YxDrwW7Z3LhJwkLo1tI8,15542
 sql/tests/test_order.py,sha256=VXfs5ZMQQiLqrSVFn-EykjJ3cHgJAiStiUELjlbZefY,1996
-sql/tests/test_select.py,sha256=5eUqSjP58tr5I2ylMbrYHQgUr1Zw1nvfhDbgdf3xXn4,18053
+sql/tests/test_select.py,sha256=MSwnN-JF5sxia_rxfWvVgtxApXSNJi7gEQaQ6eg7QTc,19903
 sql/tests/test_table.py,sha256=ZF6VzLcx54ulj69Qnt0hdQ7_XamAqpofyTKs0WiGB4E,758
 sql/tests/test_update.py,sha256=ki2O9PkLbAd5kX4TJkmttB7OicSWhlYbQQXKWHOR2gg,3490
 sql/tests/test_values.py,sha256=qKvaFSDEQmVWajWhMZgqD2-rQcWJeW_nsevVMsV3jD8,1053
-sql/tests/test_window.py,sha256=jexNAwjbB88hvPOuSN5suVthLwC88LgTO0diICPU8bE,2383
+sql/tests/test_window.py,sha256=4WJCrdk0YeCujhZqu87UnXNhdJelOuXVJ-ttwSOR_S0,2392
 sql/tests/test_with.py,sha256=A8jwi8FctjFIKI3ppGv3sO9EV2rmJ9pcP3HFmhx7YiY,2256
-python_sql-1.4.3.dist-info/METADATA,sha256=-D9a5dUgkH1nwzrnLiptfE3ZXK_2eOU3Ga1u__fGQzc,8514
-python_sql-1.4.3.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-python_sql-1.4.3.dist-info/top_level.txt,sha256=hwJHmWfbRP5a_XNfqgHwi2zrjAAzAJk24QZoTocslow,4
-python_sql-1.4.3.dist-info/RECORD,,
+python_sql-1.5.1.dist-info/METADATA,sha256=XNgCKTalL5eVIhPQZzBfiCQsCyeL1uAsb0w67hWo9So,8514
+python_sql-1.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+python_sql-1.5.1.dist-info/top_level.txt,sha256=hwJHmWfbRP5a_XNfqgHwi2zrjAAzAJk24QZoTocslow,4
+python_sql-1.5.1.dist-info/RECORD,,

{python_sql-1.4.3.dist-info → python_sql-1.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sql/__init__.py

@@ -7,9 +7,13 @@ from collections import defaultdict
 from itertools import chain
 from threading import current_thread, local
 
-__version__ = '1.4.3'
-__all__ = ['Flavor', 'Table', 'Values', 'Literal', 'Column', 'Join',
-    'Asc', 'Desc', 'NullsFirst', 'NullsLast', 'format2numeric']
+__version__ = '1.5.1'
+__all__ = [
+    'Flavor', 'Table', 'Values', 'Literal', 'Column', 'Grouping', 'Conflict',
+    'Matched', 'MatchedUpdate', 'MatchedDelete',
+    'NotMatched', 'NotMatchedInsert',
+    'Rollup', 'Cube', 'Excluded', 'Join', 'Asc', 'Desc', 'NullsFirst',
+    'NullsLast', 'format2numeric']
 
 
 def _escape_identifier(name):
@@ -376,13 +380,14 @@ class SelectQuery(WithQuery):
 
     @property
     def _limit_offset_str(self):
+        param = Flavor.get().param
         if Flavor.get().limitstyle == 'limit':
             offset = ''
             if self.offset:
-                offset = ' OFFSET %s' % self.offset
+                offset = ' OFFSET %s' % param
             limit = ''
             if self.limit is not None:
-                limit = ' LIMIT %s' % self.limit
+                limit = ' LIMIT %s' % param
             elif self.offset:
                 max_limit = Flavor.get().max_limit
                 if max_limit:
@@ -391,12 +396,27 @@ class SelectQuery(WithQuery):
         else:
             offset = ''
             if self.offset:
-                offset = ' OFFSET (%s) ROWS' % self.offset
+                offset = ' OFFSET (%s) ROWS' % param
             fetch = ''
             if self.limit is not None:
-                fetch = ' FETCH FIRST (%s) ROWS ONLY' % self.limit
+                fetch = ' FETCH FIRST (%s) ROWS ONLY' % param
             return offset + fetch
 
+    @property
+    def _limit_offset_params(self):
+        p = []
+        if Flavor.get().limitstyle == 'limit':
+            if self.limit is not None:
+                p.append(self.limit)
+            if self.offset:
+                p.append(self.offset)
+        else:
+            if self.offset:
+                p.append(self.offset)
+            if self.limit is not None:
+                p.append(self.limit)
+        return tuple(p)
+
     def as_(self, output_name):
         return As(self, output_name)
 
@@ -659,21 +679,25 @@ class Select(FromItem, SelectQuery):
                 p.extend(self.having.params)
             for window in self.windows:
                 p.extend(window.params)
+            p.extend(self._limit_offset_params)
         return tuple(p)
 
 
 class Insert(WithQuery):
-    __slots__ = ('_table', '_columns', '_values', '_returning')
+    __slots__ = ('_table', '_columns', '_values', '_on_conflict', '_returning')
 
-    def __init__(self, table, columns=None, values=None, returning=None,
-            **kwargs):
+    def __init__(
+            self, table, columns=None, values=None, returning=None,
+            on_conflict=None, **kwargs):
         self._table = None
         self._columns = None
         self._values = None
+        self._on_conflict = None
         self._returning = None
         self.table = table
         self.columns = columns
         self.values = values
+        self.on_conflict = on_conflict
         self.returning = returning
         super(Insert, self).__init__(**kwargs)
 
@@ -709,6 +733,17 @@ class Insert(WithQuery):
             value = Values(value)
         self._values = value
 
+    @property
+    def on_conflict(self):
+        return self._on_conflict
+
+    @on_conflict.setter
+    def on_conflict(self, value):
+        if value is not None:
+            assert isinstance(value, Conflict)
+            assert value.table == self.table
+        self._on_conflict = value
+
     @property
     def returning(self):
         return self._returning
@@ -743,13 +778,20 @@ class Insert(WithQuery):
                 # TODO manage DEFAULT
             elif self.values is None:
                 values = ' DEFAULT VALUES'
+            on_conflict = ''
+            if self.on_conflict:
+                on_conflict = ' %s' % self.on_conflict
             returning = ''
             if self.returning:
                 returning = ' RETURNING ' + ', '.join(
                     map(self._format, self.returning))
+            if on_conflict or returning:
+                table = '%s AS "%s"' % (self.table, self.table.alias)
+            else:
+                table = str(self.table)
             return (self._with_str()
-                + 'INSERT INTO %s AS "%s"' % (self.table, self.table.alias)
-                + columns + values + returning)
+                + 'INSERT INTO %s' % table
+                + columns + values + on_conflict + returning)
 
     @property
     def params(self):
@@ -757,12 +799,149 @@ class Insert(WithQuery):
         p.extend(self._with_params())
         if isinstance(self.values, Query):
             p.extend(self.values.params)
+        if self.on_conflict:
+            p.extend(self.on_conflict.params)
         if self.returning:
             for exp in self.returning:
                 p.extend(exp.params)
         return tuple(p)
 
 
+class Conflict(object):
+    __slots__ = (
+        '_table', '_indexed_columns', '_index_where', '_columns', '_values',
+        '_where')
+
+    def __init__(
+            self, table, indexed_columns=None, index_where=None,
+            columns=None, values=None, where=None):
+        self._table = None
+        self._indexed_columns = None
+        self._index_where = None
+        self._columns = None
+        self._values = None
+        self._where = None
+        self.table = table
+        self.indexed_columns = indexed_columns
+        self.index_where = index_where
+        self.columns = columns
+        self.values = values
+        self.where = where
+
+    @property
+    def table(self):
+        return self._table
+
+    @table.setter
+    def table(self, value):
+        assert isinstance(value, Table)
+        self._table = value
+
+    @property
+    def indexed_columns(self):
+        return self._indexed_columns
+
+    @indexed_columns.setter
+    def indexed_columns(self, value):
+        if value is not None:
+            assert all(isinstance(col, Column) for col in value)
+            assert all(col.table == self.table for col in value)
+        self._indexed_columns = value
+
+    @property
+    def index_where(self):
+        return self._index_where
+
+    @index_where.setter
+    def index_where(self, value):
+        from sql.operators import And, Or
+        if value is not None:
+            assert isinstance(value, (Expression, And, Or))
+        self._index_where = value
+
+    @property
+    def columns(self):
+        return self._columns
+
+    @columns.setter
+    def columns(self, value):
+        if value is not None:
+            assert all(isinstance(col, Column) for col in value)
+            assert all(col.table == self.table for col in value)
+        self._columns = value
+
+    @property
+    def values(self):
+        return self._values
+
+    @values.setter
+    def values(self, value):
+        if value is not None:
+            assert isinstance(value, (list, Select))
+        if isinstance(value, list):
+            value = Values([value])
+        self._values = value
+
+    @property
+    def where(self):
+        return self._where
+
+    @where.setter
+    def where(self, value):
+        from sql.operators import And, Or
+        if value is not None:
+            assert isinstance(value, (Expression, And, Or))
+        self._where = value
+
+    def __str__(self):
+        indexed_columns = ''
+        if self.indexed_columns:
+            assert all(c.table == self.table for c in self.indexed_columns)
+            # Get columns without alias
+            indexed_columns = ', '.join(
+                c.column_name for c in self.indexed_columns)
+            indexed_columns = ' (' + indexed_columns + ')'
+            if self.index_where:
+                indexed_columns += ' WHERE ' + str(self.index_where)
+        else:
+            assert not self.index_where
+        do = ''
+        if not self.columns:
+            assert not self.values
+            assert not self.where
+            do = 'NOTHING'
+        else:
+            assert all(c.table == self.table for c in self.columns)
+            # Get columns without alias
+            do = ', '.join(c.column_name for c in self.columns)
+            # TODO manage DEFAULT
+            values = str(self.values)
+            if values.startswith('VALUES'):
+                values = values[len('VALUES'):]
+            else:
+                values = ' (' + values + ')'
+            if len(self.columns) == 1:
+                # PostgreSQL would require ROW expression
+                # with single column with parenthesis
+                do = 'UPDATE SET ' + do + ' =' + values
+            else:
+                do = 'UPDATE SET (' + do + ') =' + values
+            if self.where:
+                do += ' WHERE %s' % self.where
+        return 'ON CONFLICT' + indexed_columns + ' DO ' + do
+
+    @property
+    def params(self):
+        p = []
+        if self.index_where:
+            p.extend(self.index_where.params)
+        if self.values:
+            p.extend(self.values.params)
+        if self.where:
+            p.extend(self.where.params)
+        return p
+
+
 class Update(Insert):
     __slots__ = ('_where', '_values', 'from_')
 
@@ -919,6 +1098,207 @@ class Delete(WithQuery):
         return tuple(p)
 
 
+class Merge(WithQuery):
+    __slots__ = ('_target', '_source', '_condition', '_whens')
+
+    def __init__(self, target, source, condition, *whens, **kwargs):
+        self._target = None
+        self._source = None
+        self._condition = None
+        self._whens = None
+        self.target = target
+        self.source = source
+        self.condition = condition
+        self.whens = whens
+        super().__init__(**kwargs)
+
+    @property
+    def target(self):
+        return self._target
+
+    @target.setter
+    def target(self, value):
+        assert isinstance(value, Table)
+        self._target = value
+
+    @property
+    def source(self):
+        return self._source
+
+    @source.setter
+    def source(self, value):
+        assert isinstance(value, (Table, SelectQuery, Values))
+        self._source = value
+
+    @property
+    def condition(self):
+        return self._condition
+
+    @condition.setter
+    def condition(self, value):
+        assert isinstance(value, Expression)
+        self._condition = value
+
+    @property
+    def whens(self):
+        return self._whens
+
+    @whens.setter
+    def whens(self, value):
+        assert all(isinstance(w, Matched) for w in value)
+        self._whens = tuple(value)
+
+    def __str__(self):
+        with AliasManager():
+            if isinstance(self.source, (Select, Values)):
+                source = '(%s)' % self.source
+            else:
+                source = self.source
+            if self.condition:
+                condition = 'ON %s' % self.condition
+            else:
+                condition = ''
+            return (self._with_str()
+                + 'MERGE INTO %s AS "%s" ' % (self.target, self.target.alias)
+                + 'USING %s AS "%s" ' % (source, self.source.alias)
+                + condition + ' ' + ' '.join(map(str, self.whens)))
+
+    @property
+    def params(self):
+        p = []
+        p.extend(self._with_params())
+        if isinstance(self.source, (SelectQuery, Values)):
+            p.extend(self.source.params)
+        if self.condition:
+            p.extend(self.condition.params)
+        for match in self.whens:
+            p.extend(match.params)
+        return tuple(p)
+
+
+class Matched(object):
+    __slots__ = ('_condition',)
+    _when = 'MATCHED'
+
+    def __init__(self, condition=None):
+        self._condition = None
+        self.condition = condition
+
+    @property
+    def condition(self):
+        return self._condition
+
+    @condition.setter
+    def condition(self, value):
+        if value is not None:
+            assert isinstance(value, Expression)
+        self._condition = value
+
+    def _then_str(self):
+        return 'DO NOTHING'
+
+    def __str__(self):
+        if self.condition is not None:
+            condition = ' AND ' + str(self.condition)
+        else:
+            condition = ''
+        return 'WHEN ' + self._when + condition + ' THEN ' + self._then_str()
+
+    @property
+    def params(self):
+        p = []
+        if self.condition:
+            p.extend(self.condition.params)
+        return tuple(p)
+
+
+class _MatchedValues(Matched):
+    __slots__ = ('_columns', '_values')
+
+    def __init__(self, columns, values, **kwargs):
+        self._columns = columns
+        self._values = values
+        self.columns = columns
+        self.values = values
+        super().__init__(**kwargs)
+
+    @property
+    def columns(self):
+        return self._columns
+
+    @columns.setter
+    def columns(self, value):
+        assert all(isinstance(col, Column) for col in value)
+        self._columns = value
+
+
+class MatchedUpdate(_MatchedValues, Matched):
+    __slots__ = ()
+
+    @property
+    def values(self):
+        return self._values
+
+    @values.setter
+    def values(self, value):
+        self._values = value
+
+    def _then_str(self):
+        columns = [c.column_name for c in self.columns]
+        return 'UPDATE SET ' + ', '.join(
+            '%s = %s' % (c, Update._format(v))
+            for c, v in zip(columns, self.values))
+
+    @property
+    def params(self):
+        p = list(super().params)
+        for value in self.values:
+            if isinstance(value, (Expression, Select)):
+                p.extend(value.params)
+            else:
+                p.append(value)
+        return tuple(p)
+
+
+class MatchedDelete(Matched):
+    __slots__ = ()
+
+    def _then_str(self):
+        return 'DELETE'
+
+
+class NotMatched(Matched):
+    __slots__ = ()
+    _when = 'NOT MATCHED'
+
+
+class NotMatchedInsert(_MatchedValues, NotMatched):
+    __slots__ = ()
+
+    @property
+    def values(self):
+        return self._values
+
+    @values.setter
+    def values(self, value):
+        self._values = Values([value])
+
+    def _then_str(self):
+        columns = ', '.join(c.column_name for c in self.columns)
+        columns = '(' + columns + ')'
+        if self.values is None:
+            values = ' DEFAULT VALUES '
+        else:
+            values = ' ' + str(self.values)
+        return 'INSERT ' + columns + values
+
+    @property
+    def params(self):
+        p = list(super().params)
+        p.extend(self.values.params)
+        return tuple(p)
+
+
 class CombiningQuery(FromItem, SelectQuery):
     __slots__ = ('queries', 'all_')
     _operator = ''
@@ -989,9 +1369,11 @@ class Table(FromItem):
     def params(self):
         return ()
 
-    def insert(self, columns=None, values=None, returning=None, with_=None):
+    def insert(
+            self, columns=None, values=None, returning=None, with_=None,
+            on_conflict=None):
         return Insert(self, columns=columns, values=values,
-            returning=returning, with_=with_)
+            on_conflict=on_conflict, returning=returning, with_=with_)
 
     def update(self, columns, values, from_=None, where=None, returning=None,
             with_=None):
@@ -1003,6 +1385,25 @@ class Table(FromItem):
         return Delete(self, only=only, using=using, where=where,
             returning=returning, with_=with_)
 
+    def merge(self, source, condition, *whens, with_=None):
+        return Merge(self, source, condition, *whens, with_=with_)
+
+
+class _Excluded(Table):
+    def __init__(self):
+        super().__init__('EXCLUDED')
+
+    @property
+    def alias(self):
+        return 'EXCLUDED'
+
+    @property
+    def has_alias(self):
+        return False
+
+
+Excluded = _Excluded()
+
 
 class Join(FromItem):
     __slots__ = ('_left', '_right', '_condition', '_type_')
@@ -1070,10 +1471,14 @@ class Join(FromItem):
     def params(self):
         p = []
         for item in (self.left, self.right):
-            if hasattr(item, 'params'):
+            try:
                 p.extend(item.params)
-        if hasattr(self.condition, 'params'):
+            except AttributeError:
+                pass
+        try:
             p.extend(self.condition.params)
+        except AttributeError:
+            pass
         return tuple(p)
 
     @property
@@ -1442,6 +1847,79 @@ class Collate(Expression):
             return (self.expression,)
 
 
+class Grouping(Expression):
+    __slots__ = ('_sets',)
+
+    def __init__(self, *sets):
+        super().__init__()
+        self.sets = sets
+
+    @property
+    def sets(self):
+        return self._sets
+
+    @sets.setter
+    def sets(self, value):
+        assert all(
+            isinstance(col, Expression) for cols in value for col in cols)
+        self._sets = tuple(tuple(cols) for cols in value)
+
+    def __str__(self):
+        return 'GROUPING SETS (%s)' % (
+            ', '.join(
+                '(%s)' % ', '.join(str(col) for col in cols)
+                for cols in self.sets))
+
+    @property
+    def params(self):
+        return sum((col.params for cols in self.sets for col in cols), ())
+
+
+class Rollup(Expression):
+    __slots__ = ('_expressions',)
+
+    def __init__(self, *expressions):
+        super().__init__()
+        self.expressions = expressions
+
+    @property
+    def expressions(self):
+        return self._expressions
+
+    @expressions.setter
+    def expressions(self, value):
+        assert all(
+            isinstance(col, Expression)
+            or all(isinstance(c, Expression) for c in col)
+            for col in value)
+        self._expressions = tuple(value)
+
+    def __str__(self):
+        def format(col):
+            if isinstance(col, Expression):
+                return str(col)
+            else:
+                return '(%s)' % ', '.join(str(c) for c in col)
+        return '%s (%s)' % (
+            self.__class__.__name__.upper(),
+            ', '.join(format(col) for col in self.expressions))
+
+    @property
+    def params(self):
+        p = []
+        for col in self.expressions:
+            if isinstance(col, Expression):
+                p.extend(col.params)
+            else:
+                for c in col:
+                    p.extend(c.params)
+        return tuple(p)
+
+
+class Cube(Rollup):
+    pass
+
+
 class Window(object):
     __slots__ = (
         '_partition', '_order_by', '_frame', '_start', '_end', '_exclude')
@@ -1531,6 +2009,7 @@ class Window(object):
         return AliasManager.contains(self)
 
     def __str__(self):
+        param = Flavor.get().param
         partition = ''
         if self.partition:
             partition = 'PARTITION BY ' + ', '.join(map(str, self.partition))
@@ -1544,9 +2023,9 @@ class Window(object):
             elif not frame:
                 return 'CURRENT ROW'
             elif frame < 0:
-                return '%s PRECEDING' % -frame
+                return '%s PRECEDING' % param
             elif frame > 0:
-                return '%s FOLLOWING' % frame
+                return '%s FOLLOWING' % param
 
         frame = ''
         if self.frame:
@@ -1567,6 +2046,11 @@ class Window(object):
         if self.order_by:
             for expression in self.order_by:
                 p.extend(expression.params)
+        if self.frame:
+            if self.start:
+                p.append(abs(self.start))
+            if self.end:
+                p.append(abs(self.end))
         return tuple(p)
 
 

sql/functions.py

@@ -315,8 +315,11 @@ class Trim(Function):
         for arg in (self.characters, self.string):
             if isinstance(arg, str):
                 p.append(arg)
-            elif hasattr(arg, 'params'):
-                p.extend(arg.params)
+            else:
+                try:
+                    p.extend(arg.params)
+                except AttributeError:
+                    pass
         return tuple(p)
 
 

sql/operators.py

@@ -377,7 +377,7 @@ class Like(BinaryOperator):
     __slots__ = 'escape'
     _operator = 'LIKE'
 
-    def __init__(self, left, right, escape='\\'):
+    def __init__(self, left, right, escape=None):
         super().__init__(left, right)
         assert not escape or len(escape) == 1
         self.escape = escape
@@ -386,7 +386,7 @@ class Like(BinaryOperator):
     def params(self):
         params = super().params
         if self.escape or Flavor().get().escape_empty:
-            params += (self.escape,)
+            params += (self.escape or '',)
         return params
 
     def __str__(self):

sql/tests/test_insert.py

@@ -2,7 +2,7 @@
 # this repository contains the full copyright notices and license terms.
 import unittest
 
-from sql import Table, With
+from sql import Conflict, Excluded, Table, With
 from sql.functions import Abs
 
 
@@ -11,21 +11,21 @@ class TestInsert(unittest.TestCase):
 
     def test_insert_default(self):
         query = self.table.insert()
-        self.assertEqual(str(query), 'INSERT INTO "t" AS "a" DEFAULT VALUES')
+        self.assertEqual(str(query), 'INSERT INTO "t" 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" AS "a" ("c1", "c2") VALUES (%s, %s)')
+            'INSERT INTO "t" ("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" AS "a" ("c1", "c2") VALUES (%s, %s), (%s, %s)')
+            'INSERT INTO "t" ("c1", "c2") VALUES (%s, %s), (%s, %s)')
         self.assertEqual(tuple(query.params), ('foo', 'bar', 'spam', 'eggs'))
 
     def test_insert_subselect(self):
@@ -34,14 +34,14 @@ class TestInsert(unittest.TestCase):
         subquery = t2.select(t2.c1, t2.c2)
         query = t1.insert([t1.c1, t1.c2], subquery)
         self.assertEqual(str(query),
-            'INSERT INTO "t1" AS "b" ("c1", "c2") '
+            'INSERT INTO "t1" ("c1", "c2") '
             'SELECT "a"."c1", "a"."c2" FROM "t2" AS "a"')
         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" AS "a" ("c") VALUES (ABS(%s))')
+            'INSERT INTO "t" ("c") VALUES (ABS(%s))')
         self.assertEqual(tuple(query.params), (-1,))
 
     def test_insert_returning(self):
@@ -74,7 +74,7 @@ class TestInsert(unittest.TestCase):
             values=w.select())
         self.assertEqual(str(query),
             'WITH "a" AS (SELECT * FROM "t1" AS "b") '
-            'INSERT INTO "t" AS "c" ("c1") SELECT * FROM "a" AS "a"')
+            'INSERT INTO "t" ("c1") SELECT * FROM "a" AS "a"')
         self.assertEqual(tuple(query.params), ())
 
     def test_insert_in_with(self):
@@ -101,5 +101,98 @@ class TestInsert(unittest.TestCase):
         query = t1.insert([t1.c1], [['foo']])
 
         self.assertEqual(str(query),
-            'INSERT INTO "default"."t1" AS "a" ("c1") VALUES (%s)')
+            'INSERT INTO "default"."t1" ("c1") VALUES (%s)')
         self.assertEqual(tuple(query.params), ('foo',))
+
+    def test_upsert_nothing(self):
+        query = self.table.insert(
+            [self.table.c1], [['foo']],
+            on_conflict=Conflict(self.table))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT DO NOTHING')
+        self.assertEqual(tuple(query.params), ('foo',))
+
+    def test_upsert_indexed_column(self):
+        query = self.table.insert(
+            [self.table.c1], [['foo']],
+            on_conflict=Conflict(
+                self.table,
+                indexed_columns=[self.table.c1, self.table.c2]))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT ("c1", "c2") DO NOTHING')
+        self.assertEqual(tuple(query.params), ('foo',))
+
+    def test_upsert_indexed_column_index_where(self):
+        query = self.table.insert(
+            [self.table.c1], [['foo']],
+            on_conflict=Conflict(
+                self.table,
+                indexed_columns=[self.table.c1],
+                index_where=self.table.c2 == 'bar'))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT ("c1") WHERE ("a"."c2" = %s) DO NOTHING')
+        self.assertEqual(tuple(query.params), ('foo', 'bar'))
+
+    def test_upsert_update(self):
+        query = self.table.insert(
+            [self.table.c1], [['baz']],
+            on_conflict=Conflict(
+                self.table,
+                columns=[self.table.c1, self.table.c2],
+                values=['foo', 'bar']))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT DO UPDATE SET ("c1", "c2") = (%s, %s)')
+        self.assertEqual(tuple(query.params), ('baz', 'foo', 'bar'))
+
+    def test_upsert_update_where(self):
+        query = self.table.insert(
+            [self.table.c1], [['baz']],
+            on_conflict=Conflict(
+                self.table,
+                columns=[self.table.c1],
+                values=['foo'],
+                where=self.table.c2 == 'bar'))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT DO UPDATE SET "c1" = (%s) '
+            'WHERE ("a"."c2" = %s)')
+        self.assertEqual(tuple(query.params), ('baz', 'foo', 'bar'))
+
+    def test_upsert_update_subquery(self):
+        t1 = Table('t1')
+        t2 = Table('t2')
+        subquery = t2.select(t2.c1, t2.c2)
+        query = t1.insert(
+            [t1.c1], [['baz']],
+            on_conflict=Conflict(
+                t1,
+                columns=[t1.c1, t1.c2],
+                values=subquery))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t1" AS "b" ("c1") VALUES (%s) '
+            'ON CONFLICT DO UPDATE SET ("c1", "c2") = '
+            '(SELECT "a"."c1", "a"."c2" FROM "t2" AS "a")')
+        self.assertEqual(tuple(query.params), ('baz',))
+
+    def test_upsert_update_excluded(self):
+        query = self.table.insert(
+            [self.table.c1], [[1]],
+            on_conflict=Conflict(
+                self.table,
+                columns=[self.table.c1],
+                values=[Excluded.c1 + 2]))
+
+        self.assertEqual(str(query),
+            'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
+            'ON CONFLICT DO UPDATE SET "c1" = (("EXCLUDED"."c1" + %s))')
+        self.assertEqual(tuple(query.params), (1, 2))

sql/tests/test_merge.py

@@ -0,0 +1,111 @@
+# 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.
+
+import unittest
+
+from sql import (
+    Matched, MatchedDelete, MatchedUpdate, NotMatched, NotMatchedInsert, Table,
+    With)
+
+
+class TestMerge(unittest.TestCase):
+    target = Table('t')
+    source = Table('s')
+
+    def test_merge(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2, Matched())
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN MATCHED THEN DO NOTHING')
+        self.assertEqual(query.params, ())
+
+    def test_condition(self):
+        query = self.target.merge(
+            self.source,
+            (self.target.c1 == self.source.c2) & (self.target.c3 == 42),
+            Matched())
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON (("a"."c1" = "b"."c2") AND ("a"."c3" = %s)) '
+            'WHEN MATCHED THEN DO NOTHING')
+        self.assertEqual(query.params, (42,))
+
+    def test_matched(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2,
+            Matched((self.source.c3 == 42)
+                & (self.target.c4 == self.source.c5)))
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN MATCHED '
+            'AND (("b"."c3" = %s) AND ("a"."c4" = "b"."c5")) '
+            'THEN DO NOTHING')
+        self.assertEqual(query.params, (42,))
+
+    def test_matched_update(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2,
+            MatchedUpdate([self.target.c1], [self.target.c1 + self.source.c2]))
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN MATCHED THEN '
+            'UPDATE SET "c1" = ("a"."c1" + "b"."c2")')
+        self.assertEqual(query.params, ())
+
+    def test_matched_delete(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2, MatchedDelete())
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN MATCHED THEN DELETE')
+        self.assertEqual(query.params, ())
+
+    def test_not_matched(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2, NotMatched())
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN NOT MATCHED THEN DO NOTHING')
+        self.assertEqual(query.params, ())
+
+    def test_not_matched_insert(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2,
+            NotMatchedInsert(
+                [self.target.c1, self.target.c2],
+                [self.source.c3, self.source.c4]))
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN NOT MATCHED THEN '
+            'INSERT ("c1", "c2") VALUES ("b"."c3", "b"."c4")')
+        self.assertEqual(query.params, ())
+
+    def test_with(self):
+        t1 = Table('t1')
+        w = With(query=t1.select(where=t1.c2 == 42))
+        source = w.select()
+
+        query = self.target.merge(
+            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)) '
+            'MERGE INTO "t" AS "b" '
+            'USING (SELECT * FROM "a" AS "a") AS "c" '
+            'ON ("b"."c1" = "c"."c2") '
+            'WHEN MATCHED THEN DO NOTHING')
+        self.assertEqual(query.params, (42,))

sql/tests/test_operators.py

@@ -287,8 +287,8 @@ class TestOperators(unittest.TestCase):
                 self.table.c1.like('foo'),
                 ~NotLike(self.table.c1, 'foo'),
                 ~~Like(self.table.c1, 'foo')]:
-            self.assertEqual(str(like), '("c1" LIKE %s ESCAPE %s)')
-            self.assertEqual(like.params, ('foo', '\\'))
+            self.assertEqual(str(like), '("c1" LIKE %s)')
+            self.assertEqual(like.params, ('foo',))
 
     def test_like_escape(self):
         like = Like(self.table.c1, 'foo', escape='$')
@@ -299,7 +299,7 @@ class TestOperators(unittest.TestCase):
         flavor = Flavor(escape_empty=False)
         Flavor.set(flavor)
         try:
-            like = Like(self.table.c1, 'foo', escape='')
+            like = Like(self.table.c1, 'foo')
             self.assertEqual(str(like), '("c1" LIKE %s)')
             self.assertEqual(like.params, ('foo',))
         finally:
@@ -309,7 +309,7 @@ class TestOperators(unittest.TestCase):
         flavor = Flavor(escape_empty=True)
         Flavor.set(flavor)
         try:
-            like = Like(self.table.c1, 'foo', escape='')
+            like = Like(self.table.c1, 'foo')
             self.assertEqual(str(like), '("c1" LIKE %s ESCAPE %s)')
             self.assertEqual(like.params, ('foo', ''))
         finally:
@@ -322,8 +322,8 @@ class TestOperators(unittest.TestCase):
             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 ESCAPE %s)')
-                self.assertEqual(like.params, ('foo', '\\'))
+                self.assertEqual(str(like), '("c1" ILIKE %s)')
+                self.assertEqual(like.params, ('foo',))
         finally:
             Flavor.set(Flavor())
 
@@ -332,8 +332,8 @@ class TestOperators(unittest.TestCase):
         try:
             like = ILike(self.table.c1, 'foo')
             self.assertEqual(
-                str(like), '(UPPER("c1") LIKE UPPER(%s) ESCAPE %s)')
-            self.assertEqual(like.params, ('foo', '\\'))
+                str(like), '(UPPER("c1") LIKE UPPER(%s))')
+            self.assertEqual(like.params, ('foo',))
         finally:
             Flavor.set(Flavor())
 
@@ -343,8 +343,8 @@ class TestOperators(unittest.TestCase):
         try:
             for like in [NotILike(self.table.c1, 'foo'),
                     ~self.table.c1.ilike('foo')]:
-                self.assertEqual(str(like), '("c1" NOT ILIKE %s ESCAPE %s)')
-                self.assertEqual(like.params, ('foo', '\\'))
+                self.assertEqual(str(like), '("c1" NOT ILIKE %s)')
+                self.assertEqual(like.params, ('foo',))
         finally:
             Flavor.set(Flavor())
 
@@ -353,8 +353,8 @@ class TestOperators(unittest.TestCase):
         try:
             like = NotILike(self.table.c1, 'foo')
             self.assertEqual(
-                str(like), '(UPPER("c1") NOT LIKE UPPER(%s) ESCAPE %s)')
-            self.assertEqual(like.params, ('foo', '\\'))
+                str(like), '(UPPER("c1") NOT LIKE UPPER(%s))')
+            self.assertEqual(like.params, ('foo',))
         finally:
             Flavor.set(Flavor())
 

sql/tests/test_select.py

@@ -4,7 +4,9 @@ import unittest
 import warnings
 from copy import deepcopy
 
-from sql import Flavor, For, Join, Literal, Select, Table, Union, Window, With
+from sql import (
+    Cube, Flavor, For, Grouping, Join, Literal, Rollup, Select, Table, Union,
+    Window, With)
 from sql.aggregate import Max, Min
 from sql.functions import DatePart, Function, Now, Rank
 
@@ -185,6 +187,50 @@ class TestSelect(unittest.TestCase):
             'SELECT %s FROM "t" AS "a" GROUP BY %s')
         self.assertEqual(tuple(query.params), ('foo', 'foo'))
 
+    def test_select_group_by_grouping_sets(self):
+        query = self.table.select(
+            Literal('*'),
+            group_by=Grouping((self.table.a, self.table.b), (Literal('foo'),)))
+        self.assertEqual(str(query),
+            'SELECT %s FROM "t" AS "a" '
+            'GROUP BY GROUPING SETS (("a"."a", "a"."b"), (%s))')
+        self.assertEqual(tuple(query.params), ('*', 'foo',))
+
+        query = self.table.select(
+            Literal('*'),
+            group_by=[
+                self.table.a, Grouping((self.table.b,), (self.table.c,))])
+        self.assertEqual(str(query),
+            'SELECT %s FROM "t" AS "a" '
+            'GROUP BY "a"."a", GROUPING SETS (("a"."b"), ("a"."c"))')
+        self.assertEqual(tuple(query.params), ('*',))
+
+    def test_select_group_by_rollup(self):
+        query = self.table.select(
+            Literal('*'),
+            group_by=Rollup(self.table.a, self.table.b, Literal('foo')))
+        self.assertEqual(str(query),
+            'SELECT %s FROM "t" AS "a" '
+            'GROUP BY ROLLUP ("a"."a", "a"."b", %s)')
+        self.assertEqual(tuple(query.params), ('*', 'foo'))
+
+        query = self.table.select(
+            Literal('*'),
+            group_by=Rollup((self.table.a, self.table.b), self.table.c))
+        self.assertEqual(str(query),
+            'SELECT %s FROM "t" AS "a" '
+            'GROUP BY ROLLUP (("a"."a", "a"."b"), "a"."c")')
+        self.assertEqual(tuple(query.params), ('*',))
+
+    def test_select_group_by_cube(self):
+        query = self.table.select(
+            Literal('*'),
+            group_by=Cube(self.table.a, self.table.b))
+        self.assertEqual(str(query),
+            'SELECT %s FROM "t" AS "a" '
+            'GROUP BY CUBE ("a"."a", "a"."b")')
+        self.assertEqual(tuple(query.params), ('*',))
+
     def test_select_having(self):
         col1 = self.table.col1
         col2 = self.table.col2
@@ -207,13 +253,13 @@ class TestSelect(unittest.TestCase):
             Flavor.set(Flavor(limitstyle='limit'))
             query = self.table.select(limit=50, offset=10)
             self.assertEqual(str(query),
-                'SELECT * FROM "t" AS "a" LIMIT 50 OFFSET 10')
-            self.assertEqual(tuple(query.params), ())
+                'SELECT * FROM "t" AS "a" LIMIT %s OFFSET %s')
+            self.assertEqual(tuple(query.params), (50, 10))
 
             query.limit = None
             self.assertEqual(str(query),
-                'SELECT * FROM "t" AS "a" OFFSET 10')
-            self.assertEqual(tuple(query.params), ())
+                'SELECT * FROM "t" AS "a" OFFSET %s')
+            self.assertEqual(tuple(query.params), (10,))
 
             query.offset = 0
             self.assertEqual(str(query),
@@ -234,8 +280,8 @@ class TestSelect(unittest.TestCase):
 
             query.offset = 10
             self.assertEqual(str(query),
-                'SELECT * FROM "t" AS "a" LIMIT -1 OFFSET 10')
-            self.assertEqual(tuple(query.params), ())
+                'SELECT * FROM "t" AS "a" LIMIT -1 OFFSET %s')
+            self.assertEqual(tuple(query.params), (10,))
         finally:
             Flavor.set(Flavor())
 
@@ -245,13 +291,13 @@ class TestSelect(unittest.TestCase):
             query = self.table.select(limit=50, offset=10)
             self.assertEqual(str(query),
                 'SELECT * FROM "t" AS "a" '
-                'OFFSET (10) ROWS FETCH FIRST (50) ROWS ONLY')
-            self.assertEqual(tuple(query.params), ())
+                'OFFSET (%s) ROWS FETCH FIRST (%s) ROWS ONLY')
+            self.assertEqual(tuple(query.params), (10, 50))
 
             query.limit = None
             self.assertEqual(str(query),
-                'SELECT * FROM "t" AS "a" OFFSET (10) ROWS')
-            self.assertEqual(tuple(query.params), ())
+                'SELECT * FROM "t" AS "a" OFFSET (%s) ROWS')
+            self.assertEqual(tuple(query.params), (10,))
 
             query.offset = 0
             self.assertEqual(str(query),

sql/tests/test_window.py

@@ -33,22 +33,22 @@ class TestWindow(unittest.TestCase):
         window.start = -1
         self.assertEqual(str(window),
             'PARTITION BY "c" RANGE '
-            'BETWEEN 1 PRECEDING AND CURRENT ROW')
-        self.assertEqual(window.params, ())
+            'BETWEEN %s PRECEDING AND CURRENT ROW')
+        self.assertEqual(window.params, (1,))
 
         window.start = 0
         window.end = 1
         self.assertEqual(str(window),
             'PARTITION BY "c" RANGE '
-            'BETWEEN CURRENT ROW AND 1 FOLLOWING')
-        self.assertEqual(window.params, ())
+            'BETWEEN CURRENT ROW AND %s FOLLOWING')
+        self.assertEqual(window.params, (1,))
 
         window.start = 1
         window.end = None
         self.assertEqual(str(window),
             'PARTITION BY "c" RANGE '
-            'BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING')
-        self.assertEqual(window.params, ())
+            'BETWEEN %s FOLLOWING AND UNBOUNDED FOLLOWING')
+        self.assertEqual(window.params, (1,))
 
     def test_window_exclude(self):
         t = Table('t')