python-sql 1.4.3__tar.gz → 1.5.0__tar.gz

{python-sql-1.4.3 → python_sql-1.5.0}/.gitlab-ci.yml

@@ -54,7 +54,7 @@ test-tox-python:
   extends: .test-tox
   image: ${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/python:${PYTHON_VERSION}
   script:
-    - tox -e "py${PYTHON_VERSION/./}" -vv -- -v --output-file junit.xml
+    - tox -e "py${PYTHON_VERSION/./}" -- -v --output-file junit.xml
   parallel:
     matrix:
       - PYTHON_VERSION: ["3.5", "3.6", "3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
@@ -63,4 +63,4 @@ test-tox-pypy:
   extends: .test-tox
   image: ${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/pypy:3
   script:
-    - tox -e pypy3 -vv -- -v --output-file junit.xml
+    - tox -e pypy3 -- -v --output-file junit.xml

{python-sql-1.4.3 → python_sql-1.5.0}/.hgtags

@@ -16,3 +16,5 @@ edc03ee84f0ac96d403d8f984d59fffa3274cd2f 1.3.0
 a317c40a4d60089ba9e465fbd64b78df24f9e890 1.4.0
 e71bbae3398cb6a0e72f97a0cada9fcdee2bddea 1.4.1
 fcb64787b51db2068061eb4aa13825abc1134916 1.4.2
+111e3e86865360f83a65c04fa48c55f3d2957ee3 1.4.3
+6f9066b83fe3a8c4699a8555ad1bc406f18974ff 1.5.0

{python-sql-1.4.3 → python_sql-1.5.0}/CHANGELOG

@@ -1,3 +1,10 @@
+Version 1.5.0 - 2024-05-13
+* Skip alias on INSERT without ON CONFLICT or RETURNING
+* Add MERGE
+* Support UPSERT
+* Remove default escape char on LIKE and ILIKE
+* Add GROUPING SETS, CUBE, and ROLLUP
+
 Version 1.4.3 - 2023-12-30
 * Render common table expression in combining query
 * Add support for Python 3.12

{python-sql-1.4.3 → python_sql-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sql
-Version: 1.4.3
+Version: 1.5.0
 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 → python_sql-1.5.0}/python_sql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sql
-Version: 1.4.3
+Version: 1.5.0
 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 → python_sql-1.5.0}/python_sql.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ sql/tests/test_insert.py
 sql/tests/test_join.py
 sql/tests/test_lateral.py
 sql/tests/test_literal.py
+sql/tests/test_merge.py
 sql/tests/test_operators.py
 sql/tests/test_order.py
 sql/tests/test_select.py

{python-sql-1.4.3 → python_sql-1.5.0}/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.0'
+__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):
@@ -663,17 +667,20 @@ class Select(FromItem, SelectQuery):
 
 
 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 +716,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 +761,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 +782,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 +1081,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 +1352,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 +1368,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 +1454,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 +1830,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')

{python-sql-1.4.3 → python_sql-1.5.0}/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)
 
 

{python-sql-1.4.3 → python_sql-1.5.0}/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):