python-sql 1.5.0__py3-none-any.whl → 1.5.2__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.0'
+__version__ = '1.5.2'
 __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):
@@ -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):
@@ -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,18 +385,20 @@ 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
     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:
@@ -395,12 +407,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)
 
@@ -448,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
@@ -457,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
@@ -468,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
@@ -480,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
@@ -491,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
@@ -503,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
@@ -531,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
@@ -663,6 +699,7 @@ 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)
 
 
@@ -690,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
@@ -700,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
@@ -711,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
@@ -723,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
@@ -734,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
@@ -817,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
@@ -827,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
@@ -839,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
@@ -849,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
@@ -860,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
@@ -873,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):
@@ -944,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
@@ -955,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
@@ -975,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)
@@ -1020,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
@@ -1031,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
@@ -1041,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]):
@@ -1101,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
@@ -1110,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
@@ -1119,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
@@ -1128,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):
@@ -1137,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)
@@ -1174,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):
@@ -1211,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
 
 
@@ -1264,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
@@ -1278,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)
 
 
@@ -1287,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)
@@ -1407,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
@@ -1416,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
@@ -1427,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
@@ -1437,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):
@@ -1454,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
@@ -1517,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]))
 
 
@@ -1541,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):
@@ -1806,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):
@@ -1843,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):
@@ -1871,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):
@@ -1928,7 +2009,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
@@ -1940,7 +2022,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
@@ -1950,7 +2033,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
@@ -1960,7 +2044,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
@@ -1970,7 +2055,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
@@ -1980,7 +2066,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
@@ -1992,6 +2079,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))
@@ -2005,9 +2093,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:
@@ -2028,6 +2116,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)
 
 
@@ -2047,7 +2140,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):
@@ -2150,7 +2244,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):