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

sql/tests/test_merge.py

@@ -4,8 +4,8 @@
 import unittest
 
 from sql import (
-    Matched, MatchedDelete, MatchedUpdate, NotMatched, NotMatchedInsert, Table,
-    With)
+    Literal, Matched, MatchedDelete, MatchedUpdate, Merge, NotMatched,
+    NotMatchedInsert, Table, With)
 
 
 class TestMerge(unittest.TestCase):
@@ -22,6 +22,22 @@ class TestMerge(unittest.TestCase):
             'WHEN MATCHED THEN DO NOTHING')
         self.assertEqual(query.params, ())
 
+    def test_merge_invalid_target(self):
+        with self.assertRaises(ValueError):
+            Merge('foo', self.source, Literal(True))
+
+    def test_merge_invalid_source(self):
+        with self.assertRaises(ValueError):
+            self.target.merge('foo', Literal(True))
+
+    def test_merge_invalid_condition(self):
+        with self.assertRaises(ValueError):
+            self.target.merge(self.source, 'foo')
+
+    def test_merge_invalid_whens(self):
+        with self.assertRaises(ValueError):
+            self.target.merge(self.source, Literal(True), 'foo')
+
     def test_condition(self):
         query = self.target.merge(
             self.source,
@@ -51,14 +67,16 @@ class TestMerge(unittest.TestCase):
     def test_matched_update(self):
         query = self.target.merge(
             self.source, self.target.c1 == self.source.c2,
-            MatchedUpdate([self.target.c1], [self.target.c1 + self.source.c2]))
+            MatchedUpdate(
+                [self.target.c1, self.target.c2],
+                [self.target.c1 + self.source.c2, 42]))
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
             'ON ("a"."c1" = "b"."c2") '
             'WHEN MATCHED THEN '
-            'UPDATE SET "c1" = ("a"."c1" + "b"."c2")')
-        self.assertEqual(query.params, ())
+            'UPDATE SET "c1" = ("a"."c1" + "b"."c2"), "c2" = %s')
+        self.assertEqual(query.params, (42,))
 
     def test_matched_delete(self):
         query = self.target.merge(
@@ -94,6 +112,26 @@ class TestMerge(unittest.TestCase):
             'INSERT ("c1", "c2") VALUES ("b"."c3", "b"."c4")')
         self.assertEqual(query.params, ())
 
+    def test_not_matched_insert_default(self):
+        query = self.target.merge(
+            self.source, self.target.c1 == self.source.c2,
+            NotMatchedInsert([self.target.c1, self.target.c2], None))
+        self.assertEqual(
+            str(query),
+            'MERGE INTO "t" AS "a" USING "s" AS "b" '
+            'ON ("a"."c1" = "b"."c2") '
+            'WHEN NOT MATCHED THEN '
+            'INSERT ("c1", "c2") DEFAULT VALUES')
+        self.assertEqual(query.params, ())
+
+    def test_matched_invalid_condition(self):
+        with self.assertRaises(ValueError):
+            Matched('foo')
+
+    def test_matched_values_invalid_columns(self):
+        with self.assertRaises(ValueError):
+            MatchedUpdate('foo', [])
+
     def test_with(self):
         t1 = Table('t1')
         w = With(query=t1.select(where=t1.c2 == 42))

sql/tests/test_operators.py

@@ -9,12 +9,19 @@ from sql.operators import (
     Abs, And, Between, Div, Equal, Exists, FloorDiv, Greater, GreaterEqual,
     ILike, In, Is, IsDistinct, IsNot, IsNotDistinct, Less, LessEqual, Like,
     LShift, Mod, Mul, Neg, Not, NotBetween, NotEqual, NotILike, NotIn, NotLike,
-    Or, Pos, Pow, RShift, Sub)
+    Operator, Or, Pos, Pow, RShift, Sub)
 
 
 class TestOperators(unittest.TestCase):
     table = Table('t')
 
+    def test_operator_operands(self):
+        self.assertEqual(Operator()._operands, ())
+
+    def test_operator_str(self):
+        with self.assertRaises(NotImplementedError):
+            str(Operator())
+
     def test_and(self):
         for and_ in [And((self.table.c1, self.table.c2)),
                 self.table.c1 & self.table.c2]:
@@ -25,6 +32,10 @@ class TestOperators(unittest.TestCase):
         self.assertEqual(str(and_), '(%s AND "c2")')
         self.assertEqual(and_.params, (True,))
 
+        and_ = And((Literal(True), 'foo'))
+        self.assertEqual(str(and_), '(%s AND %s)')
+        self.assertEqual(and_.params, (True, 'foo'))
+
     def test_operator_operators(self):
         and_ = And((Literal(True), self.table.c1))
         and2 = and_ & And((Literal(True), self.table.c2))
@@ -200,6 +211,10 @@ class TestOperators(unittest.TestCase):
             self.assertEqual(str(is_), '("c1" IS FALSE)')
             self.assertEqual(is_.params, ())
 
+    def test_is_invalid_right(self):
+        with self.assertRaises(ValueError):
+            Is(self.table.c, 'foo')
+
     def test_is_not(self):
         for is_ in [IsNot(self.table.c1, None),
                 ~Is(self.table.c1, None)]:
@@ -315,6 +330,10 @@ class TestOperators(unittest.TestCase):
         finally:
             Flavor.set(Flavor())
 
+    def test_like_invalid_escape(self):
+        with self.assertRaises(ValueError):
+            Like(self.table.c, 'test', escape='fo')
+
     def test_ilike(self):
         flavor = Flavor(ilike=True)
         Flavor.set(flavor)

sql/tests/test_order.py

@@ -3,28 +3,33 @@
 import unittest
 
 from sql import (
-    Asc, Column, Desc, Flavor, Literal, NullsFirst, NullsLast, Table)
+    Asc, Column, Desc, Flavor, Literal, NullOrder, NullsFirst, NullsLast,
+    Order, Table)
 
 
 class TestOrder(unittest.TestCase):
     column = Column(Table('t'), 'c')
 
     def test_asc(self):
-        self.assertEqual(str(Asc(self.column)), '"c" ASC')
+        self.assertEqual(str(self.column.asc), '"c" ASC')
 
     def test_desc(self):
-        self.assertEqual(str(Desc(self.column)), '"c" DESC')
+        self.assertEqual(str(self.column.desc), '"c" DESC')
 
     def test_nulls_first(self):
-        self.assertEqual(str(NullsFirst(self.column)), '"c" NULLS FIRST')
-        self.assertEqual(str(NullsFirst(Asc(self.column))),
+        self.assertEqual(str(self.column.nulls_first), '"c" NULLS FIRST')
+        self.assertEqual(str(Asc(self.column).nulls_first),
             '"c" ASC NULLS FIRST')
 
     def test_nulls_last(self):
-        self.assertEqual(str(NullsLast(self.column)), '"c" NULLS LAST')
-        self.assertEqual(str(NullsLast(Asc(self.column))),
+        self.assertEqual(str(self.column.nulls_last), '"c" NULLS LAST')
+        self.assertEqual(str(Asc(self.column).nulls_last),
             '"c" ASC NULLS LAST')
 
+    def test_null_order_case_values(self):
+        with self.assertRaises(NotImplementedError):
+            NullOrder(self.column)._case_values()
+
     def test_no_null_ordering(self):
         try:
             Flavor.set(Flavor(null_ordering=False))
@@ -54,3 +59,7 @@ class TestOrder(unittest.TestCase):
             '(SELECT "a"."c" FROM "t" AS "a") ASC')
         self.assertEqual(str(Desc(query)),
             '(SELECT "a"."c" FROM "t" AS "a") DESC')
+
+    def test_invalid_expression(self):
+        with self.assertRaises(ValueError):
+            Order('foo')

sql/tests/test_rollup.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 Rollup
+
+
+class TestRollup(unittest.TestCase):
+
+    def test_invalid_expressions(self):
+        with self.assertRaises(ValueError):
+            Rollup('foo')

sql/tests/test_select.py

@@ -34,6 +34,12 @@ class TestSelect(unittest.TestCase):
             'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s)')
         self.assertEqual(tuple(query.params), ('foo',))
 
+    def test_select_iter(self):
+        query = self.table.select()
+        self.assertEqual(
+            tuple(query),
+            ('SELECT * FROM "t" AS "a"', ()))
+
     def test_select_without_from(self):
         query = Select([Literal(1)])
         self.assertEqual(str(query), 'SELECT %s')
@@ -49,6 +55,14 @@ class TestSelect(unittest.TestCase):
         self.assertEqual(str(query), 'SELECT (SELECT %s) AS "foo"')
         self.assertEqual(tuple(query.params), (1,))
 
+    def test_select_invalid_column(self):
+        with self.assertRaises(ValueError):
+            Select(['foo'])
+
+    def test_select_invalid_where(self):
+        with self.assertRaises(ValueError):
+            self.table.select(where='foo')
+
     def test_select_distinct(self):
         query = self.table.select(self.table.c, distinct=True)
         self.assertEqual(
@@ -68,6 +82,10 @@ class TestSelect(unittest.TestCase):
             'SELECT DISTINCT ON ("a"."a", "a"."b") "a"."c" FROM "t" AS "a"')
         self.assertEqual(tuple(query.params), ())
 
+    def test_select_invalid_distinct_on(self):
+        with self.assertRaises(ValueError):
+            self.table.select(self.table.c, distinct_on='foo')
+
     def test_select_from_list(self):
         t2 = Table('t2')
         t3 = Table('t3')
@@ -231,6 +249,10 @@ class TestSelect(unittest.TestCase):
             'GROUP BY CUBE ("a"."a", "a"."b")')
         self.assertEqual(tuple(query.params), ('*',))
 
+    def test_select_invalid_group_by(self):
+        with self.assertRaises(ValueError):
+            self.table.select(group_by=['foo'])
+
     def test_select_having(self):
         col1 = self.table.col1
         col2 = self.table.col2
@@ -241,6 +263,10 @@ class TestSelect(unittest.TestCase):
             'HAVING (MIN("a"."col2") > %s)')
         self.assertEqual(tuple(query.params), (3,))
 
+    def test_select_invalid_having(self):
+        with self.assertRaises(ValueError):
+            self.table.select(having='foo')
+
     def test_select_order(self):
         c = self.table.c
         query = self.table.select(c, order_by=Literal(1))
@@ -248,6 +274,10 @@ class TestSelect(unittest.TestCase):
             'SELECT "a"."c" FROM "t" AS "a" ORDER BY %s')
         self.assertEqual(tuple(query.params), (1,))
 
+    def test_select_invalid_order(self):
+        with self.assertRaises(ValueError):
+            self.table.select(order_by='foo')
+
     def test_select_limit_offset(self):
         try:
             Flavor.set(Flavor(limitstyle='limit'))
@@ -285,6 +315,14 @@ class TestSelect(unittest.TestCase):
         finally:
             Flavor.set(Flavor())
 
+    def test_select_invalid_limit(self):
+        with self.assertRaises(ValueError):
+            self.table.select(limit='foo')
+
+    def test_select_invalid_offset(self):
+        with self.assertRaises(ValueError):
+            self.table.select(offset='foo')
+
     def test_select_offset_fetch(self):
         try:
             Flavor.set(Flavor(limitstyle='fetch'))
@@ -390,6 +428,10 @@ class TestSelect(unittest.TestCase):
             'SELECT "a"."c" FROM "t" AS "a" FOR UPDATE')
         self.assertEqual(tuple(query.params), ())
 
+    def test_select_invalid_for(self):
+        with self.assertRaises(ValueError):
+            self.table.select(for_=['foo'])
+
     def test_copy(self):
         query = self.table.select()
         copy_query = deepcopy(query)
@@ -472,6 +514,20 @@ class TestSelect(unittest.TestCase):
             'WINDOW "b" AS (PARTITION BY "a"."c2")')
         self.assertEqual(tuple(query.params), (1,))
 
+    def test_window_with_alias(self):
+        query = self.table.select(
+            Min(self.table.c1, window=Window([self.table.c2])).as_('min'))
+
+        self.assertEqual(
+            str(query),
+            'SELECT MIN("a"."c1") OVER "b" AS "min" FROM "t" AS "a" '
+            'WINDOW "b" AS (PARTITION BY "a"."c2")')
+        self.assertEqual(query.params, ())
+
+    def test_select_invalid_window(self):
+        with self.assertRaises(ValueError):
+            self.table.select(windows=['foo'])
+
     def test_order_params(self):
         with_ = With(query=self.table.select(self.table.c,
                 where=(self.table.c > 1)))

sql/tests/test_update.py

@@ -27,6 +27,14 @@ class TestUpdate(unittest.TestCase):
             'WHERE ("b"."c" = "a"."c")')
         self.assertEqual(query.params, ('foo',))
 
+    def test_update_invalid_values(self):
+        with self.assertRaises(ValueError):
+            self.table.update([self.table.c], 'foo')
+
+    def test_update_invalid_where(self):
+        with self.assertRaises(ValueError):
+            self.table.update([self.table.c], ['foo'], where='foo')
+
     def test_update_subselect(self):
         t1 = Table('t1')
         t2 = Table('t2')

sql/tests/test_window.py

@@ -14,6 +14,10 @@ class TestWindow(unittest.TestCase):
         self.assertEqual(str(window), 'PARTITION BY "c1", "c2"')
         self.assertEqual(window.params, ())
 
+    def test_window_invalid_partition(self):
+        with self.assertRaises(ValueError):
+            Window(['foo'])
+
     def test_window_order(self):
         t = Table('t')
         window = Window([t.c], order_by=t.c)
@@ -21,6 +25,10 @@ class TestWindow(unittest.TestCase):
         self.assertEqual(str(window), 'PARTITION BY "c" ORDER BY "c"')
         self.assertEqual(window.params, ())
 
+    def test_window_invalid_order(self):
+        with self.assertRaises(ValueError):
+            Window([Table('t').c], order_by='foo')
+
     def test_window_range(self):
         t = Table('t')
         window = Window([t.c], frame='RANGE')
@@ -50,6 +58,18 @@ class TestWindow(unittest.TestCase):
             'BETWEEN %s FOLLOWING AND UNBOUNDED FOLLOWING')
         self.assertEqual(window.params, (1,))
 
+    def test_window_invalid_frame(self):
+        with self.assertRaises(ValueError):
+            Window([Table('t').c], frame='foo')
+
+    def test_window_invalid_start(self):
+        with self.assertRaises(ValueError):
+            Window([Table('t').c], start='foo')
+
+    def test_window_invalid_end(self):
+        with self.assertRaises(ValueError):
+            Window([Table('t').c], end='foo')
+
     def test_window_exclude(self):
         t = Table('t')
         window = Window([t.c], exclude='TIES')
@@ -58,6 +78,10 @@ class TestWindow(unittest.TestCase):
             'PARTITION BY "c" EXCLUDE TIES')
         self.assertEqual(window.params, ())
 
+    def test_window_invalid_exclude(self):
+        with self.assertRaises(ValueError):
+            Window([Table('t').c], exclude='foo')
+
     def test_window_rows(self):
         t = Table('t')
         window = Window([t.c], frame='ROWS')

sql/tests/test_with.py

@@ -62,3 +62,7 @@ class TestWith(unittest.TestCase):
             'SELECT ("a"."n" + %s) FROM "a" AS "a" WHERE ("a"."n" < %s)'
             ') SELECT * FROM "a" AS "a"')
         self.assertEqual(tuple(q.params), (1, 1, 100))
+
+    def test_invalid_with(self):
+        with self.assertRaises(ValueError):
+            WithQuery(with_=['foo'])

python_sql-1.5.1.dist-info/RECORD

@@ -1,34 +0,0 @@
-sql/__init__.py,sha256=gmmbZtl-Xz2V_wc5HDJMcTdjoXdfgYueu42AaAoha_Y,60610
-sql/aggregate.py,sha256=Dmog1JIuFZ8fFT8RjeGbWGU7kCdJcMrNlwTSO1HIwc8,5241
-sql/conditionals.py,sha256=xJY6ffEBeES6CiGKErXSa2dK2FXaEaR_QQl_CKILP30,2541
-sql/functions.py,sha256=qdmLZ5eoqIsc7erlPsdByecUey7rexhVdUTSB_RnOZ4,12373
-sql/operators.py,sha256=cuh2pvRDNbWbWwE4su9dwsuDxPlJ_S9gn3U-iVvrbKE,10788
-sql/tests/__init__.py,sha256=oHBEqcjoFLDwTiSIDwYNLS8Vj1lkq8-O5DsTKCh1BJw,675
-sql/tests/test_aggregate.py,sha256=7KDN81zxzkVjjoHHLpQMvB-yVqwkKdPoKuppqmWfDYI,2592
-sql/tests/test_alias.py,sha256=AcMrKVvFPsR84BRGc_dN6t3O5vAqNjBeWicb6I6EuBI,1884
-sql/tests/test_as.py,sha256=OfXDu0CnJ2paRKR29dMdx7q_Q9TFY60MWlvib6MR5LY,926
-sql/tests/test_cast.py,sha256=ejrqHQZwA3967UhszYR3caZYvH3waPcF6li4rnmxGi4,653
-sql/tests/test_collate.py,sha256=LWJhwcmVBsbJpEtaBRu-BUkBufXktUgCHS4XR7LbAYA,842
-sql/tests/test_column.py,sha256=_GkBkBzLW_fDoJy5yUWDtHTSyka1s5Drd4gDuvtIM_8,866
-sql/tests/test_combining_query.py,sha256=SyVHnIUiikGwc7ViAEalCKwgYRRfayNmsBD1NhCWoNM,2277
-sql/tests/test_conditionals.py,sha256=kNkgsjOatXpJnF9AED03ANNd0zWIwWTrnWdi4PWfl3E,2705
-sql/tests/test_delete.py,sha256=0xEllZmXVc9YH6lGJI0_DVXCpB1CTc-e62GK0_fnoM4,1591
-sql/tests/test_for.py,sha256=6e4n7NbKTdlEp_z6MrNT_eM8rwXR94gANtBmWzhxcjk,550
-sql/tests/test_functions.py,sha256=CM-a0c1ey9uEhw3wFL8PWETB3Kpl5wtkGNLt44r_0EE,5377
-sql/tests/test_insert.py,sha256=1jt2nNrNRdxH7VykkQCwjiVK-LJmmjaGiDaqUJWeh9U,7378
-sql/tests/test_join.py,sha256=OWFqe2Zbb-uDTzg9b0GcH2p2xzhinuvy6E_ANMCOD-Y,1891
-sql/tests/test_lateral.py,sha256=f6hlapGKJ-ZWobMPktN4mSNXgfyNr7O5ZwZASb_oo30,1046
-sql/tests/test_literal.py,sha256=ht-VLhGdpUm_rbtOzpQgbX3YQup_xp7F9va0RSWY0Ts,1010
-sql/tests/test_merge.py,sha256=CWF7grhpfqlgNUlafDr9Xbx-EY9uGMFbJRPGoLf5pd8,4074
-sql/tests/test_operators.py,sha256=6j6AEK5_xKJq-WC7Q9fXDE5YxDrwW7Z3LhJwkLo1tI8,15542
-sql/tests/test_order.py,sha256=VXfs5ZMQQiLqrSVFn-EykjJ3cHgJAiStiUELjlbZefY,1996
-sql/tests/test_select.py,sha256=MSwnN-JF5sxia_rxfWvVgtxApXSNJi7gEQaQ6eg7QTc,19903
-sql/tests/test_table.py,sha256=ZF6VzLcx54ulj69Qnt0hdQ7_XamAqpofyTKs0WiGB4E,758
-sql/tests/test_update.py,sha256=ki2O9PkLbAd5kX4TJkmttB7OicSWhlYbQQXKWHOR2gg,3490
-sql/tests/test_values.py,sha256=qKvaFSDEQmVWajWhMZgqD2-rQcWJeW_nsevVMsV3jD8,1053
-sql/tests/test_window.py,sha256=4WJCrdk0YeCujhZqu87UnXNhdJelOuXVJ-ttwSOR_S0,2392
-sql/tests/test_with.py,sha256=A8jwi8FctjFIKI3ppGv3sO9EV2rmJ9pcP3HFmhx7YiY,2256
-python_sql-1.5.1.dist-info/METADATA,sha256=XNgCKTalL5eVIhPQZzBfiCQsCyeL1uAsb0w67hWo9So,8514
-python_sql-1.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-python_sql-1.5.1.dist-info/top_level.txt,sha256=hwJHmWfbRP5a_XNfqgHwi2zrjAAzAJk24QZoTocslow,4
-python_sql-1.5.1.dist-info/RECORD,,