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

sql/__init__.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from itertools import chain
 from threading import current_thread, local
 
-__version__ = '1.5.1'
+__version__ = '1.6.0'
 __all__ = [
     'Flavor', 'Table', 'Values', 'Literal', 'Column', 'Grouping', 'Conflict',
     'Matched', 'MatchedUpdate', 'MatchedDelete',
@@ -62,17 +62,23 @@ class Flavor(object):
     def __init__(self, limitstyle='limit', max_limit=None, paramstyle='format',
             ilike=False, no_as=False, no_boolean=False, null_ordering=True,
             function_mapping=None, filter_=False, escape_empty=False):
-        assert limitstyle in ['fetch', 'limit', 'rownum']
+        if limitstyle not in {'fetch', 'limit', 'rownum'}:
+            raise ValueError("unsupported limitstyle: %r" % limitstyle)
         self.limitstyle = limitstyle
+        if (max_limit is not None
+                and not isinstance(max_limit, numbers.Integral)):
+            raise ValueError("unsupported max_limit: %r" % max_limit)
         self.max_limit = max_limit
+        if paramstyle not in {'format', 'qmark'}:
+            raise ValueError("unsupported paramstyle: %r" % paramstyle)
         self.paramstyle = paramstyle
-        self.ilike = ilike
-        self.no_as = no_as
-        self.no_boolean = no_boolean
-        self.null_ordering = null_ordering
-        self.function_mapping = function_mapping or {}
-        self.filter_ = filter_
-        self.escape_empty = escape_empty
+        self.ilike = bool(ilike)
+        self.no_as = bool(no_as)
+        self.no_boolean = bool(no_boolean)
+        self.null_ordering = bool(null_ordering)
+        self.function_mapping = dict(function_mapping or {})
+        self.filter_ = bool(filter_)
+        self.escape_empty = bool(escape_empty)
 
     @property
     def param(self):
@@ -176,7 +182,7 @@ def format2numeric(query, params):
 
 
 class Query(object):
-    __slots__ = ()
+    __slots__ = ('__weakref__',)
 
     @property
     def params(self):
@@ -213,7 +219,8 @@ class WithQuery(Query):
         if value is not None:
             if isinstance(value, With):
                 value = [value]
-            assert all(isinstance(w, With) for w in value)
+            if any(not isinstance(w, With) for w in value):
+                raise ValueError("invalid with: %r" % value)
         self._with = value
 
     def _with_str(self):
@@ -236,7 +243,7 @@ class WithQuery(Query):
 
 
 class FromItem(object):
-    __slots__ = ()
+    __slots__ = ('__weakref__',)
 
     @property
     def alias(self):
@@ -252,7 +259,8 @@ class FromItem(object):
         return Column(self, name)
 
     def __add__(self, other):
-        assert isinstance(other, FromItem)
+        if not isinstance(other, FromItem):
+            return NotImplemented
         return From((self, other))
 
     def select(self, *args, **kwargs):
@@ -348,7 +356,8 @@ class SelectQuery(WithQuery):
         if value is not None:
             if isinstance(value, Expression):
                 value = [value]
-            assert all(isinstance(col, Expression) for col in value)
+            if any(not isinstance(col, Expression) for col in value):
+                raise ValueError("invalid order by: %r" % value)
         self._order_by = value
 
     @property
@@ -365,7 +374,8 @@ class SelectQuery(WithQuery):
     @limit.setter
     def limit(self, value):
         if value is not None:
-            assert isinstance(value, numbers.Integral)
+            if not isinstance(value, numbers.Integral):
+                raise ValueError("invalid limit: %r" % value)
         self._limit = value
 
     @property
@@ -375,7 +385,8 @@ class SelectQuery(WithQuery):
     @offset.setter
     def offset(self, value):
         if value is not None:
-            assert isinstance(value, numbers.Integral)
+            if not isinstance(value, numbers.Integral):
+                raise ValueError("invalid offset: %r" % value)
         self._offset = value
 
     @property
@@ -464,7 +475,8 @@ class Select(FromItem, SelectQuery):
         if value is not None:
             if isinstance(value, Expression):
                 value = [value]
-            assert all(isinstance(col, Expression) for col in value)
+            if any(not isinstance(col, Expression) for col in value):
+                raise ValueError("invalid distinct on: %r" % value)
         self._distinct_on = value
 
     @property
@@ -473,7 +485,10 @@ class Select(FromItem, SelectQuery):
 
     @columns.setter
     def columns(self, value):
-        assert all(isinstance(col, (Expression, SelectQuery)) for col in value)
+        if any(
+                not isinstance(col, (Expression, SelectQuery))
+                for col in value):
+            raise ValueError("invalid columns: %r" % value)
         self._columns = tuple(value)
 
     @property
@@ -484,7 +499,8 @@ class Select(FromItem, SelectQuery):
     def where(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid where: %r" % value)
         self._where = value
 
     @property
@@ -496,7 +512,8 @@ class Select(FromItem, SelectQuery):
         if value is not None:
             if isinstance(value, Expression):
                 value = [value]
-            assert all(isinstance(col, Expression) for col in value)
+            if any(not isinstance(col, Expression) for col in value):
+                raise ValueError("invalid group by: %r" % value)
         self._group_by = value
 
     @property
@@ -507,7 +524,8 @@ class Select(FromItem, SelectQuery):
     def having(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid having: %r" % value)
         self._having = value
 
     @property
@@ -519,7 +537,8 @@ class Select(FromItem, SelectQuery):
         if value is not None:
             if isinstance(value, For):
                 value = [value]
-            assert all(isinstance(f, For) for f in value)
+            if any(not isinstance(f, For) for f in value):
+                raise ValueError("invalid for: %r" % value)
         self._for_ = value
 
     @property
@@ -547,7 +566,8 @@ class Select(FromItem, SelectQuery):
     @windows.setter
     def windows(self, value):
         if value is not None:
-            assert all(isinstance(w, Window) for w in value)
+            if any(not isinstance(w, Window) for w in value):
+                raise ValueError("invalid windows: %r" % value)
         self._windows = value
 
     @staticmethod
@@ -672,13 +692,13 @@ class Select(FromItem, SelectQuery):
             if self.group_by:
                 for expression in self.group_by:
                     p.extend(expression.params)
-            if self.order_by:
-                for expression in self.order_by:
-                    p.extend(expression.params)
             if self.having:
                 p.extend(self.having.params)
             for window in self.windows:
                 p.extend(window.params)
+            if self.order_by:
+                for expression in self.order_by:
+                    p.extend(expression.params)
             p.extend(self._limit_offset_params)
         return tuple(p)
 
@@ -707,7 +727,8 @@ class Insert(WithQuery):
 
     @table.setter
     def table(self, value):
-        assert isinstance(value, Table)
+        if not isinstance(value, Table):
+            raise ValueError("invalid table: %r" % value)
         self._table = value
 
     @property
@@ -717,8 +738,10 @@ class Insert(WithQuery):
     @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)
+            if any(
+                    not isinstance(col, Column) or col.table != self.table
+                    for col in value):
+                raise ValueError("invalid columns: %r" % value)
         self._columns = value
 
     @property
@@ -728,7 +751,8 @@ class Insert(WithQuery):
     @values.setter
     def values(self, value):
         if value is not None:
-            assert isinstance(value, (list, Select))
+            if not isinstance(value, (list, Select)):
+                raise ValueError("invalid values: %r" % value)
         if isinstance(value, list):
             value = Values(value)
         self._values = value
@@ -740,8 +764,8 @@ class Insert(WithQuery):
     @on_conflict.setter
     def on_conflict(self, value):
         if value is not None:
-            assert isinstance(value, Conflict)
-            assert value.table == self.table
+            if not isinstance(value, Conflict) or value.table != self.table:
+                raise ValueError("invalid on conflict: %r" % value)
         self._on_conflict = value
 
     @property
@@ -751,7 +775,8 @@ class Insert(WithQuery):
     @returning.setter
     def returning(self, value):
         if value is not None:
-            assert isinstance(value, list)
+            if not isinstance(value, list):
+                raise ValueError("invalid returning: %r" % value)
         self._returning = value
 
     @staticmethod
@@ -834,7 +859,8 @@ class Conflict(object):
 
     @table.setter
     def table(self, value):
-        assert isinstance(value, Table)
+        if not isinstance(value, Table):
+            raise ValueError("invalid table: %r" % value)
         self._table = value
 
     @property
@@ -844,8 +870,10 @@ class Conflict(object):
     @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)
+            if any(
+                    not isinstance(col, Column) or col.table != self.table
+                    for col in value):
+                raise ValueError("invalid indexed columns: %r" % value)
         self._indexed_columns = value
 
     @property
@@ -856,7 +884,8 @@ class Conflict(object):
     def index_where(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid index where: %r" % value)
         self._index_where = value
 
     @property
@@ -866,8 +895,10 @@ class Conflict(object):
     @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)
+            if any(
+                    not isinstance(col, Column) or col.table != self.table
+                    for col in value):
+                raise ValueError("invalid columns: %r" % value)
         self._columns = value
 
     @property
@@ -877,7 +908,8 @@ class Conflict(object):
     @values.setter
     def values(self, value):
         if value is not None:
-            assert isinstance(value, (list, Select))
+            if not isinstance(value, (list, Select)):
+                raise ValueError("invalid values: %r" % value)
         if isinstance(value, list):
             value = Values([value])
         self._values = value
@@ -890,7 +922,8 @@ class Conflict(object):
     def where(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid where: %r" % value)
         self._where = value
 
     def __str__(self):
@@ -961,7 +994,8 @@ class Update(Insert):
     def values(self, value):
         if isinstance(value, Select):
             value = [value]
-        assert isinstance(value, list)
+        if not isinstance(value, list):
+            raise ValueError("invalid values: %r" % value)
         self._values = value
 
     @property
@@ -972,9 +1006,14 @@ class Update(Insert):
     def where(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid where: %r" % value)
         self._where = value
 
+    @staticmethod
+    def _format_column(value):
+        return Select._format_column(value)
+
     def __str__(self):
         assert all(col.table == self.table for col in self.columns)
         # Get columns without alias
@@ -992,7 +1031,7 @@ class Update(Insert):
             returning = ''
             if self.returning:
                 returning = ' RETURNING ' + ', '.join(
-                    map(self._format, self.returning))
+                    map(self._format_column, self.returning))
             return (self._with_str()
                 + 'UPDATE %s AS "%s" SET ' % (self.table, self.table.alias)
                 + values + from_ + where + returning)
@@ -1037,7 +1076,8 @@ class Delete(WithQuery):
 
     @table.setter
     def table(self, value):
-        assert isinstance(value, Table)
+        if not isinstance(value, Table):
+            raise ValueError("invalid table: %r" % value)
         self._table = value
 
     @property
@@ -1048,7 +1088,8 @@ class Delete(WithQuery):
     def where(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid where: %r" % value)
         self._where = value
 
     @property
@@ -1058,19 +1099,15 @@ class Delete(WithQuery):
     @returning.setter
     def returning(self, value):
         if value is not None:
-            assert isinstance(value, list)
+            if any(
+                    not isinstance(col, (Expression, SelectQuery))
+                    for col in value):
+                raise ValueError("invalid returning: %r" % value)
         self._returning = value
 
     @staticmethod
-    def _format(value, param=None):
-        if param is None:
-            param = Flavor.get().param
-        if isinstance(value, Expression):
-            return str(value)
-        elif isinstance(value, Select):
-            return '(%s)' % value
-        else:
-            return param
+    def _format(value):
+        return Select._format_column(value)
 
     def __str__(self):
         with AliasManager(exclude=[self.table]):
@@ -1118,7 +1155,8 @@ class Merge(WithQuery):
 
     @target.setter
     def target(self, value):
-        assert isinstance(value, Table)
+        if not isinstance(value, Table):
+            raise ValueError("invalid target: %r" % value)
         self._target = value
 
     @property
@@ -1127,7 +1165,8 @@ class Merge(WithQuery):
 
     @source.setter
     def source(self, value):
-        assert isinstance(value, (Table, SelectQuery, Values))
+        if not isinstance(value, (Table, SelectQuery, Values)):
+            raise ValueError("invalid source: %r" % value)
         self._source = value
 
     @property
@@ -1136,7 +1175,8 @@ class Merge(WithQuery):
 
     @condition.setter
     def condition(self, value):
-        assert isinstance(value, Expression)
+        if not isinstance(value, Expression):
+            raise ValueError("invalid condition: %r" % value)
         self._condition = value
 
     @property
@@ -1145,7 +1185,8 @@ class Merge(WithQuery):
 
     @whens.setter
     def whens(self, value):
-        assert all(isinstance(w, Matched) for w in value)
+        if any(not isinstance(w, Matched) for w in value):
+            raise ValueError("invalid whens: %r" % value)
         self._whens = tuple(value)
 
     def __str__(self):
@@ -1154,10 +1195,7 @@ class Merge(WithQuery):
                 source = '(%s)' % self.source
             else:
                 source = self.source
-            if self.condition:
-                condition = 'ON %s' % self.condition
-            else:
-                condition = ''
+            condition = 'ON %s' % self.condition
             return (self._with_str()
                 + 'MERGE INTO %s AS "%s" ' % (self.target, self.target.alias)
                 + 'USING %s AS "%s" ' % (source, self.source.alias)
@@ -1191,7 +1229,8 @@ class Matched(object):
     @condition.setter
     def condition(self, value):
         if value is not None:
-            assert isinstance(value, Expression)
+            if not isinstance(value, Expression):
+                raise ValueError("invalid condition: %r" % value)
         self._condition = value
 
     def _then_str(self):
@@ -1228,7 +1267,8 @@ class _MatchedValues(Matched):
 
     @columns.setter
     def columns(self, value):
-        assert all(isinstance(col, Column) for col in value)
+        if any(not isinstance(col, Column) for col in value):
+            raise ValueError("invalid columns: %r" % value)
         self._columns = value
 
 
@@ -1281,13 +1321,15 @@ class NotMatchedInsert(_MatchedValues, NotMatched):
 
     @values.setter
     def values(self, value):
-        self._values = Values([value])
+        if value is not None:
+            value = Values([value])
+        self._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 '
+            values = ' DEFAULT VALUES'
         else:
             values = ' ' + str(self.values)
         return 'INSERT ' + columns + values
@@ -1295,7 +1337,8 @@ class NotMatchedInsert(_MatchedValues, NotMatched):
     @property
     def params(self):
         p = list(super().params)
-        p.extend(self.values.params)
+        if self.values:
+            p.extend(self.values.params)
         return tuple(p)
 
 
@@ -1304,7 +1347,8 @@ class CombiningQuery(FromItem, SelectQuery):
     _operator = ''
 
     def __init__(self, *queries, **kwargs):
-        assert all(isinstance(q, Query) for q in queries)
+        if any(not isinstance(q, Query) for q in queries):
+            raise ValueError("invalid queries: %r" % (queries,))
         self.queries = queries
         self.all_ = kwargs.pop('all_', False)
         super(CombiningQuery, self).__init__(**kwargs)
@@ -1424,7 +1468,8 @@ class Join(FromItem):
 
     @left.setter
     def left(self, value):
-        assert isinstance(value, FromItem)
+        if not isinstance(value, FromItem):
+            raise ValueError("invalid left: %r" % value)
         self._left = value
 
     @property
@@ -1433,7 +1478,8 @@ class Join(FromItem):
 
     @right.setter
     def right(self, value):
-        assert isinstance(value, FromItem)
+        if not isinstance(value, FromItem):
+            raise ValueError("invalid right: %r" % value)
         self._right = value
 
     @property
@@ -1444,7 +1490,8 @@ class Join(FromItem):
     def condition(self, value):
         from sql.operators import And, Or
         if value is not None:
-            assert isinstance(value, (Expression, And, Or))
+            if not isinstance(value, (Expression, And, Or)):
+                raise ValueError("invalid condition: %r" % value)
         self._condition = value
 
     @property
@@ -1454,8 +1501,10 @@ class Join(FromItem):
     @type_.setter
     def type_(self, value):
         value = value.upper()
-        assert value in ('INNER', 'LEFT', 'LEFT OUTER',
-            'RIGHT', 'RIGHT OUTER', 'FULL', 'FULL OUTER', 'CROSS')
+        if value not in {
+                'INNER', 'LEFT', 'LEFT OUTER', 'RIGHT', 'RIGHT OUTER', 'FULL',
+                'FULL OUTER', 'CROSS'}:
+            raise ValueError("invalid type: %r" % value)
         self._type_ = value
 
     def __str__(self):
@@ -1471,14 +1520,9 @@ class Join(FromItem):
     def params(self):
         p = []
         for item in (self.left, self.right):
-            try:
-                p.extend(item.params)
-            except AttributeError:
-                pass
-        try:
+            p.extend(item.params)
+        if self.condition:
             p.extend(self.condition.params)
-        except AttributeError:
-            pass
         return tuple(p)
 
     @property
@@ -1534,8 +1578,10 @@ class From(list):
         return tuple(p)
 
     def __add__(self, other):
-        assert isinstance(other, FromItem)
-        assert not isinstance(other, CombiningQuery)
+        if not isinstance(other, FromItem):
+            return NotImplemented
+        elif isinstance(other, CombiningQuery):
+            return NotImplemented
         return From(super(From, self).__add__([other]))
 
 
@@ -1558,7 +1604,7 @@ class Values(list, Query, FromItem):
 
     @property
     def params(self):
-        p = []
+        p = list(super().params)
         for values in self:
             for value in values:
                 if isinstance(value, Expression):
@@ -1569,7 +1615,7 @@ class Values(list, Query, FromItem):
 
 
 class Expression(object):
-    __slots__ = ()
+    __slots__ = ('__weakref__',)
 
     def __str__(self):
         raise NotImplementedError
@@ -1823,21 +1869,35 @@ class Cast(Expression):
 
 
 class Collate(Expression):
-    __slots__ = ('expression', 'collation')
+    __slots__ = ('_expression', '_collation')
 
     def __init__(self, expression, collation):
         super(Collate, self).__init__()
         self.expression = expression
         self.collation = collation
 
+    @property
+    def expression(self):
+        return self._expression
+
+    @expression.setter
+    def expression(self, value):
+        self._expression = value
+
+    @property
+    def collation(self):
+        return self._collation
+
+    @collation.setter
+    def collation(self, value):
+        self._collation = value
+
     def __str__(self):
         if isinstance(self.expression, Expression):
             value = self.expression
         else:
             value = Flavor.get().param
-        if '"' in self.collation:
-            raise ValueError("Wrong collation %s" % self.collation)
-        return '%s COLLATE "%s"' % (value, self.collation)
+        return '%s COLLATE %s' % (value, _escape_identifier(self.collation))
 
     @property
     def params(self):
@@ -1860,8 +1920,11 @@ class Grouping(Expression):
 
     @sets.setter
     def sets(self, value):
-        assert all(
-            isinstance(col, Expression) for cols in value for col in cols)
+        if any(
+                not isinstance(col, Expression)
+                for cols in value
+                for col in cols):
+            raise ValueError("invalid sets: %r" % value)
         self._sets = tuple(tuple(cols) for cols in value)
 
     def __str__(self):
@@ -1888,10 +1951,11 @@ class Rollup(Expression):
 
     @expressions.setter
     def expressions(self, value):
-        assert all(
-            isinstance(col, Expression)
-            or all(isinstance(c, Expression) for c in col)
-            for col in value)
+        if not all(
+                isinstance(col, Expression)
+                or all(isinstance(c, Expression) for c in col)
+                for col in value):
+            raise ValueError("invalid expressions: %r" % value)
         self._expressions = tuple(value)
 
     def __str__(self):
@@ -1922,7 +1986,8 @@ class Cube(Rollup):
 
 class Window(object):
     __slots__ = (
-        '_partition', '_order_by', '_frame', '_start', '_end', '_exclude')
+        '_partition', '_order_by', '_frame', '_start', '_end', '_exclude',
+        '__weakref__')
 
     def __init__(self, partition, order_by=None,
             frame=None, start=None, end=0, exclude=None):
@@ -1945,7 +2010,8 @@ class Window(object):
 
     @partition.setter
     def partition(self, value):
-        assert all(isinstance(e, Expression) for e in value)
+        if any(not isinstance(e, Expression) for e in value):
+            raise ValueError("invalid partition: %r" % value)
         self._partition = value
 
     @property
@@ -1957,7 +2023,8 @@ class Window(object):
         if value is not None:
             if isinstance(value, Expression):
                 value = [value]
-            assert all(isinstance(col, Expression) for col in value)
+            if any(not isinstance(col, Expression) for col in value):
+                raise ValueError("invalid order by: %r" % value)
         self._order_by = value
 
     @property
@@ -1967,7 +2034,8 @@ class Window(object):
     @frame.setter
     def frame(self, value):
         if value:
-            assert value in ['RANGE', 'ROWS', 'GROUPS']
+            if value not in {'RANGE', 'ROWS', 'GROUPS'}:
+                raise ValueError("invalid frame: %r" % value)
         self._frame = value
 
     @property
@@ -1977,7 +2045,8 @@ class Window(object):
     @start.setter
     def start(self, value):
         if value:
-            assert isinstance(value, numbers.Integral)
+            if not isinstance(value, numbers.Integral):
+                raise ValueError("invalid start: %r" % value)
         self._start = value
 
     @property
@@ -1987,7 +2056,8 @@ class Window(object):
     @end.setter
     def end(self, value):
         if value:
-            assert isinstance(value, numbers.Integral)
+            if not isinstance(value, numbers.Integral):
+                raise ValueError("invalid end: %r" % value)
         self._end = value
 
     @property
@@ -1997,7 +2067,8 @@ class Window(object):
     @exclude.setter
     def exclude(self, value):
         if value:
-            assert value in ['CURRENT ROW', 'GROUP', 'TIES']
+            if value not in {'CURRENT ROW', 'GROUP', 'TIES'}:
+                raise ValueError("invalid exclude: %r" % value)
         self._exclude = value
 
     @property
@@ -2070,7 +2141,8 @@ class Order(Expression):
 
     @expression.setter
     def expression(self, value):
-        assert isinstance(value, (Expression, SelectQuery))
+        if not isinstance(value, (Expression, SelectQuery)):
+            raise ValueError("invalid expression: %r" % value)
         self._expression = value
 
     def __str__(self):
@@ -2173,7 +2245,8 @@ class For(object):
     @type_.setter
     def type_(self, value):
         value = value.upper()
-        assert value in ('UPDATE', 'SHARE')
+        if value not in {'UPDATE', 'SHARE'}:
+            raise ValueError("invalid type: %r" % value)
         self._type_ = value
 
     def __str__(self):