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

sql/aggregate.py

@@ -8,7 +8,7 @@ _sentinel = object()
 
 
 class Aggregate(Expression):
-    __slots__ = ('expression', '_distinct', '_order_by', '_within',
+    __slots__ = ('_expression', '_distinct', '_order_by', '_within',
         '_filter', '_window')
     _sql = ''
 
@@ -22,13 +22,24 @@ class Aggregate(Expression):
         self.filter_ = filter_
         self.window = window
 
+    @property
+    def expression(self):
+        return self._expression
+
+    @expression.setter
+    def expression(self, value):
+        if not isinstance(value, Expression):
+            raise ValueError("invalid expression: %r" % value)
+        self._expression = value
+
     @property
     def distinct(self):
         return self._distinct
 
     @distinct.setter
     def distinct(self, value):
-        assert isinstance(value, bool)
+        if not isinstance(value, bool):
+            raise ValueError("invalid distinct: %r" % value)
         self._distinct = value
 
     @property
@@ -40,7 +51,8 @@ class Aggregate(Expression):
         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
@@ -52,7 +64,8 @@ class Aggregate(Expression):
         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 within: %r" % value)
         self._within = value
 
     @property
@@ -63,7 +76,8 @@ class Aggregate(Expression):
     def filter_(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 filter: %r" % value)
         self._filter = value
 
     @property
@@ -73,7 +87,8 @@ class Aggregate(Expression):
     @window.setter
     def window(self, value):
         if value:
-            assert isinstance(value, Window)
+            if not isinstance(value, Window):
+                raise ValueError("invalid window: %r" % value)
         self._window = value
 
     @property

sql/functions.py

@@ -39,7 +39,8 @@ class Function(Expression, FromItem):
 
     @columns_definitions.setter
     def columns_definitions(self, value):
-        assert isinstance(value, list)
+        if not isinstance(value, list):
+            raise ValueError("invalid columns definitions: %r" % value)
         self._columns_definitions = value
 
     @staticmethod
@@ -286,7 +287,8 @@ class Trim(Function):
     _function = 'TRIM'
 
     def __init__(self, string, position='BOTH', characters=' '):
-        assert position.upper() in ('LEADING', 'TRAILING', 'BOTH')
+        if position.upper() not in {'LEADING', 'TRAILING', 'BOTH'}:
+            raise ValueError("invalid position: %r" % position)
         self.position = position.upper()
         self.characters = characters
         self.string = string
@@ -316,10 +318,7 @@ class Trim(Function):
             if isinstance(arg, str):
                 p.append(arg)
             else:
-                try:
-                    p.extend(arg.params)
-                except AttributeError:
-                    pass
+                p.extend(arg.params)
         return tuple(p)
 
 
@@ -486,7 +485,8 @@ class WindowFunction(Function):
     def filter_(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 filter: %r" % value)
         self._filter = value
 
     @property
@@ -496,7 +496,8 @@ class WindowFunction(Function):
     @window.setter
     def window(self, value):
         if value:
-            assert isinstance(value, Window)
+            if not isinstance(value, Window):
+                raise ValueError("invalid window: %r" % value)
         self._window = value
 
     def __str__(self):

sql/operators.py

@@ -121,7 +121,8 @@ class NaryOperator(list, Operator):
         return self
 
     def __str__(self):
-        return '(' + (' %s ' % self._operator).join(map(str, self)) + ')'
+        return '(' + (' %s ' % self._operator).join(
+            map(self._format, self)) + ')'
 
 
 class And(NaryOperator):
@@ -248,7 +249,8 @@ class Is(BinaryOperator):
     _operator = 'IS'
 
     def __init__(self, left, right):
-        assert right in [None, True, False]
+        if right not in {None, True, False}:
+            raise ValueError("invalid right: %r" % right)
         super(Is, self).__init__(left, right)
 
     @property
@@ -379,7 +381,8 @@ class Like(BinaryOperator):
 
     def __init__(self, left, right, escape=None):
         super().__init__(left, right)
-        assert not escape or len(escape) == 1
+        if escape and len(escape) != 1:
+            raise ValueError("invalid escape: %r" % escape)
         self.escape = escape
 
     @property

sql/tests/test_aggregate.py

@@ -3,12 +3,36 @@
 import unittest
 
 from sql import AliasManager, Flavor, Literal, Table, Window
-from sql.aggregate import Avg, Count
+from sql.aggregate import Aggregate, Avg, Count
 
 
 class TestAggregate(unittest.TestCase):
     table = Table('t')
 
+    def test_invalid_expression(self):
+        with self.assertRaises(ValueError):
+            Aggregate('foo')
+
+    def test_invalid_distinct(self):
+        with self.assertRaises(ValueError):
+            Aggregate(self.table.c, distinct='foo')
+
+    def test_invalid_order(self):
+        with self.assertRaises(ValueError):
+            Aggregate(self.table.c, order_by=['foo'])
+
+    def test_invalid_within(self):
+        with self.assertRaises(ValueError):
+            Aggregate(self.table.c, within=['foo'])
+
+    def test_invalid_filter(self):
+        with self.assertRaises(ValueError):
+            Aggregate(self.table.c, filter_='foo')
+
+    def test_invalid_window(self):
+        with self.assertRaises(ValueError):
+            Aggregate(self.table.c, window='foo')
+
     def test_avg(self):
         avg = Avg(self.table.c)
         self.assertEqual(str(avg), 'AVG("c")')

sql/tests/test_alias.py

@@ -61,3 +61,18 @@ class TestAliasManager(unittest.TestCase):
         self.finish2.wait()
         if not self.succeed1.is_set() or not self.succeed2.is_set():
             self.fail()
+
+    def test_contains(self):
+        with AliasManager():
+            AliasManager.get(self.t1)
+            self.assertTrue(AliasManager.contains(self.t1))
+
+    def test_contains_exclude(self):
+        with AliasManager(exclude=[self.t1]):
+            self.assertEqual(AliasManager.get(self.t1), '')
+            self.assertFalse(AliasManager.contains(self.t1))
+
+    def test_set(self):
+        with AliasManager():
+            AliasManager.set(self.t1, 'foo')
+            self.assertEqual(AliasManager.get(self.t1), 'foo')

sql/tests/test_collate.py

@@ -17,8 +17,3 @@ class TestCollate(unittest.TestCase):
         collate = Collate("foo", 'C')
         self.assertEqual(str(collate), '%s COLLATE "C"')
         self.assertEqual(collate.params, ("foo",))
-
-    def test_collate_injection(self):
-        collate = Collate(self.column, 'C";')
-        with self.assertRaises(ValueError):
-            str(collate)

sql/tests/test_combining_query.py

@@ -2,7 +2,7 @@
 # this repository contains the full copyright notices and license terms.
 import unittest
 
-from sql import Table, Union, With
+from sql import CombiningQuery, Table, Union, With
 
 
 class TestUnion(unittest.TestCase):
@@ -10,6 +10,10 @@ class TestUnion(unittest.TestCase):
     q2 = Table('t2').select()
     q3 = Table('t3').select()
 
+    def test_invalid_queries(self):
+        with self.assertRaises(ValueError):
+            CombiningQuery('foo', 'bar')
+
     def test_union2(self):
         query = Union(self.q1, self.q2)
         self.assertEqual(str(query),

sql/tests/test_delete.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 Delete, Table, With
 
 
 class TestDelete(unittest.TestCase):
@@ -27,11 +27,31 @@ class TestDelete(unittest.TestCase):
             'SELECT "a"."c" FROM "t2" AS "a"))')
         self.assertEqual(query.params, ())
 
+    def test_delete_invalid_table(self):
+        with self.assertRaises(ValueError):
+            Delete('foo')
+
+    def test_delete_invalid_where(self):
+        with self.assertRaises(ValueError):
+            self.table.delete(where='foo')
+
     def test_delete_returning(self):
         query = self.table.delete(returning=[self.table.c])
         self.assertEqual(str(query), 'DELETE FROM "t" RETURNING "c"')
         self.assertEqual(query.params, ())
 
+    def test_delet_returning_select(self):
+        query = self.table.delete(returning=[self.table.select()])
+
+        self.assertEqual(
+            str(query),
+            'DELETE FROM "t" RETURNING (SELECT * FROM "t")')
+        self.assertEqual(query.params, ())
+
+    def test_delete_invalid_returning(self):
+        with self.assertRaises(ValueError):
+            self.table.delete(returning='foo')
+
     def test_with(self):
         t1 = Table('t1')
         w = With(query=t1.select(t1.c1))

sql/tests/test_excluded.py

@@ -0,0 +1,15 @@
+# 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 Excluded
+
+
+class TestExcluded(unittest.TestCase):
+
+    def test_alias(self):
+        self.assertEqual(Excluded.alias, 'EXCLUDED')
+
+    def test_has_alias(self):
+        self.assertFalse(Excluded.has_alias)

sql/tests/test_expression.py

@@ -0,0 +1,17 @@
+# 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 Expression
+
+
+class TestExpression(unittest.TestCase):
+
+    def test_str(self):
+        with self.assertRaises(NotImplementedError):
+            str(Expression())
+
+    def test_params(self):
+        with self.assertRaises(NotImplementedError):
+            Expression().params

sql/tests/test_flavor.py

@@ -0,0 +1,46 @@
+# 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 Flavor
+
+
+class TestFlavor(unittest.TestCase):
+
+    def test(self):
+        Flavor()
+
+    def test_limitstyle(self):
+        flavor = Flavor(limitstyle='rownum')
+
+        self.assertEqual(flavor.limitstyle, 'rownum')
+
+    def test_invalid_limitstyle(self):
+        with self.assertRaises(ValueError):
+            Flavor(limitstyle='foo')
+
+    def test_max_limit(self):
+        flavor = Flavor(max_limit=42)
+
+        self.assertEqual(flavor.max_limit, 42)
+
+    def test_invalid_max_limit(self):
+        with self.assertRaises(ValueError):
+            Flavor(max_limit='foo')
+
+    def test_paramstyle_format(self):
+        flavor = Flavor(paramstyle='format')
+
+        self.assertEqual(flavor.paramstyle, 'format')
+        self.assertEqual(flavor.param, '%s')
+
+    def test_paramstyle_qmark(self):
+        flavor = Flavor(paramstyle='qmark')
+
+        self.assertEqual(flavor.paramstyle, 'qmark')
+        self.assertEqual(flavor.param, '?')
+
+    def test_invalid_paramstyle(self):
+        with self.assertRaises(ValueError):
+            Flavor(paramstyle='foo')

sql/tests/test_for.py

@@ -14,3 +14,7 @@ class TestFor(unittest.TestCase):
         for_ = For('UPDATE')
         for_.tables = Table('t1')
         self.assertEqual(str(for_), 'FOR UPDATE OF "t1"')
+
+    def test_invalid_type(self):
+        with self.assertRaises(ValueError):
+            For('foo')

sql/tests/test_from.py

@@ -0,0 +1,25 @@
+# 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 CombiningQuery, From, Table
+
+
+class TestFrom(unittest.TestCase):
+
+    def test_add(self):
+        t1 = Table('t1')
+        t2 = Table('t2')
+        from_ = From([t1]) + t2
+
+        self.assertEqual(from_, [t1, t2])
+
+    def test_invalid_add(self):
+        with self.assertRaises(TypeError):
+            From([Table('t')]) + 'foo'
+
+    def test_invalid_add_combining_query(self):
+        with self.assertRaises(TypeError):
+            From([Table('t')]) + CombiningQuery(
+                Table('t1').select(), Table('t2').select())

sql/tests/test_from_item.py

@@ -0,0 +1,46 @@
+# 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 AliasManager, Column, From, FromItem
+
+
+class TestFromItem(unittest.TestCase):
+
+    def test_from_item(self):
+        from_item = FromItem()
+
+        with AliasManager():
+            self.assertFalse(from_item.has_alias)
+            from_item.alias
+            self.assertTrue(from_item.has_alias)
+
+    def test_get_column(self):
+        from_item = FromItem()
+
+        foo = from_item.foo
+
+        self.assertIsInstance(foo, Column)
+        self.assertEqual(foo.name, 'foo')
+
+    def test_get_invalid_column(self):
+        from_item = FromItem()
+
+        with self.assertRaises(AttributeError):
+            from_item.__foo__
+
+    def test_add(self):
+        from_item1 = FromItem()
+        from_item2 = FromItem()
+
+        from_ = from_item1 + from_item2
+
+        self.assertIsInstance(from_, From)
+        self.assertEqual(from_, [from_item1, from_item2])
+
+    def test_invalid_add(self):
+        from_item = FromItem()
+
+        with self.assertRaises(TypeError):
+            from_item + 'foo'

sql/tests/test_functions.py

@@ -5,12 +5,16 @@ import unittest
 from sql import AliasManager, Flavor, Table, Window
 from sql.functions import (
     Abs, AtTimeZone, CurrentTime, Div, Function, FunctionKeyword,
-    FunctionNotCallable, Overlay, Rank, Trim)
+    FunctionNotCallable, Overlay, Rank, Trim, WindowFunction)
 
 
 class TestFunctions(unittest.TestCase):
     table = Table('t')
 
+    def test_invalid_columns_definitions(self):
+        with self.assertRaises(ValueError):
+            Function(columns_definitions='foo')
+
     def test_abs(self):
         abs_ = Abs(self.table.c1)
         self.assertEqual(str(abs_), 'ABS("c1")')
@@ -87,6 +91,10 @@ class TestFunctions(unittest.TestCase):
         self.assertEqual(str(trim), 'TRIM(BOTH %s FROM "c1")')
         self.assertEqual(trim.params, (' ',))
 
+    def test_trim_invalid_position(self):
+        with self.assertRaises(ValueError):
+            Trim('test', 'foo')
+
     def test_at_time_zone(self):
         time_zone = AtTimeZone(self.table.c1, 'UTC')
         self.assertEqual(str(time_zone), '"c1" AT TIME ZONE %s')
@@ -142,6 +150,10 @@ class TestWindowFunction(unittest.TestCase):
             self.assertEqual(str(function), 'RANK("a"."c") OVER ()')
         self.assertEqual(function.params, ())
 
+    def test_invalid_window(self):
+        with self.assertRaises(ValueError):
+            WindowFunction(window='foo')
+
     def test_filter(self):
         t = Table('t')
         function = Rank(t.c, filter_=t.c > 0, window=Window([]))
@@ -150,3 +162,7 @@ class TestWindowFunction(unittest.TestCase):
             self.assertEqual(str(function),
                 'RANK("a"."c") FILTER (WHERE ("a"."c" > %s)) OVER ()')
         self.assertEqual(function.params, (0,))
+
+    def test_invalid_filter(self):
+        with self.assertRaises(ValueError):
+            WindowFunction(filter_='foo', window=Window([]))

sql/tests/test_grouping.py

@@ -0,0 +1,13 @@
+# 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 Grouping
+
+
+class TestGrouping(unittest.TestCase):
+
+    def test_invalid_sets(self):
+        with self.assertRaises(ValueError):
+            Grouping('foo')

sql/tests/test_insert.py

@@ -2,13 +2,25 @@
 # this repository contains the full copyright notices and license terms.
 import unittest
 
-from sql import Conflict, Excluded, Table, With
+from sql import Conflict, Excluded, Insert, Table, With
 from sql.functions import Abs
 
 
 class TestInsert(unittest.TestCase):
     table = Table('t')
 
+    def test_insert_invalid_table(self):
+        with self.assertRaises(ValueError):
+            Insert('foo')
+
+    def test_insert_invalid_columns(self):
+        with self.assertRaises(ValueError):
+            self.table.insert(['foo'], [['foo']])
+
+    def test_insert_invalid_values(self):
+        with self.assertRaises(ValueError):
+            self.table.insert([self.table.c], 'foo')
+
     def test_insert_default(self):
         query = self.table.insert()
         self.assertEqual(str(query), 'INSERT INTO "t" DEFAULT VALUES')
@@ -64,6 +76,10 @@ class TestInsert(unittest.TestCase):
             'WHERE (("a"."c1" = "b"."c") AND ("a"."c2" = %s)))')
         self.assertEqual(tuple(query.params), ('foo', 'bar'))
 
+    def test_insert_invalid_returning(self):
+        with self.assertRaises(ValueError):
+            self.table.insert(returning='foo')
+
     def test_with(self):
         t1 = Table('t1')
         w = With(query=t1.select())
@@ -104,6 +120,14 @@ class TestInsert(unittest.TestCase):
             'INSERT INTO "default"."t1" ("c1") VALUES (%s)')
         self.assertEqual(tuple(query.params), ('foo',))
 
+    def test_upsert_invalid_on_conflict(self):
+        with self.assertRaises(ValueError):
+            self.table.insert(on_conflict='foo')
+
+    def test_upsert_invalid_table_on_conflict(self):
+        with self.assertRaises(ValueError):
+            self.table.insert(on_conflict=Conflict(Table('t1')))
+
     def test_upsert_nothing(self):
         query = self.table.insert(
             [self.table.c1], [['foo']],
@@ -196,3 +220,35 @@ class TestInsert(unittest.TestCase):
             'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
             'ON CONFLICT DO UPDATE SET "c1" = (("EXCLUDED"."c1" + %s))')
         self.assertEqual(tuple(query.params), (1, 2))
+
+    def test_conflict_invalid_table(self):
+        with self.assertRaises(ValueError):
+            Conflict('foo')
+
+    def test_conflict_invalid_indexed_columns(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, indexed_columns=['foo'])
+
+    def test_conflict_indexed_columns_invalid_table(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, indexed_columns=[Table('t').c])
+
+    def test_conflict_invalid_index_where(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, index_where='foo')
+
+    def test_conflict_invalid_columns(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, columns=['foo'])
+
+    def test_conflict_columns_invalid_table(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, columns=[Table('t').c])
+
+    def test_conflict_invalid_values(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, values='foo')
+
+    def test_conflict_invalid_where(self):
+        with self.assertRaises(ValueError):
+            Conflict(self.table, where='foo')

sql/tests/test_join.py

@@ -20,6 +20,22 @@ class TestJoin(unittest.TestCase):
             self.assertEqual(str(join),
                 '"t1" AS "a" INNER JOIN "t2" AS "b" ON ("a"."c" = "b"."c")')
 
+    def test_join_invalid_left(self):
+        with self.assertRaises(ValueError):
+            Join('foo', Table('t1'))
+
+    def test_join_invalid_right(self):
+        with self.assertRaises(ValueError):
+            Join(Table('t1'), 'foo')
+
+    def test_join_invalid_condition(self):
+        with self.assertRaises(ValueError):
+            Join(Table('t1'), Table('t2'), condition='foo')
+
+    def test_join_invalid_type(self):
+        with self.assertRaises(ValueError):
+            Join(Table('t1'), Table('t2'), type_='foo')
+
     def test_join_subselect(self):
         t1 = Table('t1')
         t2 = Table('t2')
@@ -50,3 +66,10 @@ class TestJoin(unittest.TestCase):
                 join = getattr(t1, method)(t2)
                 type_ = method[:-len('_join')].replace('_', ' ').upper()
                 self.assertEqual(join.type_, type_)
+
+    def test_join_alias(self):
+        join = Join(Table('t1'), Table('t2'))
+        with self.assertRaises(AttributeError):
+            join.alias
+        with self.assertRaises(AttributeError):
+            join.has_alias

sql/tests/test_lateral.py

@@ -11,7 +11,7 @@ class TestLateral(unittest.TestCase):
     def test_lateral_select(self):
         t1 = Table('t1')
         t2 = Table('t2')
-        lateral = Lateral(t2.select(where=t2.id == t1.t2))
+        lateral = t2.select(where=t2.id == t1.t2).lateral()
         query = From([t1, lateral]).select()
 
         self.assertEqual(str(query),