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

sql/tests/test_select.py

@@ -31,7 +31,7 @@ class TestSelect(unittest.TestCase):
     def test_select3(self):
         query = self.table.select(where=(self.table.c == 'foo'))
         self.assertEqual(str(query),
-            'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s)')
+            'SELECT * FROM "t" AS "a" WHERE "a"."c" = %s')
         self.assertEqual(tuple(query.params), ('foo',))
 
     def test_select_iter(self):
@@ -110,7 +110,7 @@ class TestSelect(unittest.TestCase):
             'SELECT * FROM "t2" AS "c") AS "a"')
         query1.where = self.table.c == 'foo'
         self.assertEqual(str(union),
-            'SELECT * FROM "t" AS "a" WHERE ("a"."c" = %s) UNION ALL '
+            'SELECT * FROM "t" AS "a" WHERE "a"."c" = %s UNION ALL '
             'SELECT * FROM "t2" AS "b"')
         self.assertEqual(tuple(union.params), ('foo',))
 
@@ -197,7 +197,7 @@ class TestSelect(unittest.TestCase):
         output = column.as_('c1')
         query = self.table.select(output, group_by=output)
         self.assertEqual(str(query),
-            'SELECT "a"."c" AS "c1" FROM "t" AS "a" GROUP BY "c1"')
+            'SELECT "a"."c" AS "c1" FROM "t" AS "a" GROUP BY 1')
         self.assertEqual(tuple(query.params), ())
 
         query = self.table.select(Literal('foo'), group_by=Literal('foo'))
@@ -205,6 +205,19 @@ class TestSelect(unittest.TestCase):
             'SELECT %s FROM "t" AS "a" GROUP BY %s')
         self.assertEqual(tuple(query.params), ('foo', 'foo'))
 
+        output1 = column.as_('c1')
+        output2 = column.as_('c2')
+        query = self.table.select(output1, output2, group_by=output2)
+        self.assertEqual(str(query),
+            'SELECT "a"."c" AS "c1", "a"."c" AS "c2" FROM "t" AS "a" '
+            'GROUP BY 2')
+        self.assertEqual(tuple(query.params), ())
+
+        query = self.table.select(column, group_by=output)
+        self.assertEqual(str(query),
+            'SELECT "a"."c" FROM "t" AS "a" GROUP BY "c1"')
+        self.assertEqual(tuple(query.params), ())
+
     def test_select_group_by_grouping_sets(self):
         query = self.table.select(
             Literal('*'),
@@ -253,6 +266,12 @@ class TestSelect(unittest.TestCase):
         with self.assertRaises(ValueError):
             self.table.select(group_by=['foo'])
 
+    def test_select_invalid_group_by_alias(self):
+        query = self.table.select(
+            self.table.c1.as_('c'), group_by=self.table.c2.as_('c'))
+        with self.assertRaises(ValueError):
+            str(query)
+
     def test_select_having(self):
         col1 = self.table.col1
         col2 = self.table.col2
@@ -260,7 +279,7 @@ class TestSelect(unittest.TestCase):
             having=(Min(col2) > 3))
         self.assertEqual(str(query),
             'SELECT "a"."col1", MIN("a"."col2") FROM "t" AS "a" '
-            'HAVING (MIN("a"."col2") > %s)')
+            'HAVING MIN("a"."col2") > %s')
         self.assertEqual(tuple(query.params), (3,))
 
     def test_select_invalid_having(self):
@@ -268,16 +287,28 @@ class TestSelect(unittest.TestCase):
             self.table.select(having='foo')
 
     def test_select_order(self):
-        c = self.table.c
-        query = self.table.select(c, order_by=Literal(1))
+        column = self.table.c
+        query = self.table.select(column, order_by=column)
         self.assertEqual(str(query),
-            'SELECT "a"."c" FROM "t" AS "a" ORDER BY %s')
-        self.assertEqual(tuple(query.params), (1,))
+            'SELECT "a"."c" FROM "t" AS "a" ORDER BY "a"."c"')
+        self.assertEqual(tuple(query.params), ())
+
+        output = column.as_('c1')
+        query = self.table.select(output, order_by=output)
+        self.assertEqual(str(query),
+            'SELECT "a"."c" AS "c1" FROM "t" AS "a" ORDER BY "c1"')
+        self.assertEqual(tuple(query.params), ())
 
     def test_select_invalid_order(self):
         with self.assertRaises(ValueError):
             self.table.select(order_by='foo')
 
+    def test_select_invalid_order_alias(self):
+        query = self.table.select(
+            self.table.c1.as_('c'), order_by=self.table.c2.as_('c'))
+        with self.assertRaises(ValueError):
+            str(query)
+
     def test_select_limit_offset(self):
         try:
             Flavor.set(Flavor(limitstyle='limit'))
@@ -352,8 +383,8 @@ class TestSelect(unittest.TestCase):
                 'SELECT "a".* FROM ('
                     'SELECT "b".*, ROWNUM AS "rnum" FROM ('
                         'SELECT * FROM "t" AS "c") AS "b" '
-                    'WHERE (ROWNUM <= %s)) AS "a" '
-                'WHERE ("rnum" > %s)')
+                    'WHERE ROWNUM <= %s) AS "a" '
+                'WHERE "rnum" > %s')
             self.assertEqual(tuple(query.params), (60, 10))
 
             query = self.table.select(
@@ -364,8 +395,8 @@ class TestSelect(unittest.TestCase):
                     'SELECT "b"."col1", "b"."col2", ROWNUM AS "rnum" FROM ('
                         'SELECT "c"."c1" AS "col1", "c"."c2" AS "col2" '
                         'FROM "t" AS "c") AS "b" '
-                    'WHERE (ROWNUM <= %s)) AS "a" '
-                'WHERE ("rnum" > %s)')
+                    'WHERE ROWNUM <= %s) AS "a" '
+                'WHERE "rnum" > %s')
             self.assertEqual(tuple(query.params), (60, 10))
 
             subquery = query.select(query.col1, query.col2)
@@ -376,8 +407,8 @@ class TestSelect(unittest.TestCase):
                         'FROM ('
                             'SELECT "c"."c1" AS "col1", "c"."c2" AS "col2" '
                             'FROM "t" AS "c") AS "a" '
-                        'WHERE (ROWNUM <= %s)) AS "b" '
-                    'WHERE ("rnum" > %s)) AS "a"')
+                        'WHERE ROWNUM <= %s) AS "b" '
+                    'WHERE "rnum" > %s) AS "a"')
             # XXX alias of query is reused but not a problem
             # as it is hidden in subquery
             self.assertEqual(tuple(query.params), (60, 10))
@@ -388,15 +419,15 @@ class TestSelect(unittest.TestCase):
                 'SELECT "a".* FROM ('
                     'SELECT "b".*, ROWNUM AS "rnum" FROM ('
                         'SELECT * FROM "t" AS "c" ORDER BY "c"."c") AS "b" '
-                    'WHERE (ROWNUM <= %s)) AS "a" '
-                'WHERE ("rnum" > %s)')
+                    'WHERE ROWNUM <= %s) AS "a" '
+                'WHERE "rnum" > %s')
             self.assertEqual(tuple(query.params), (60, 10))
 
             query = self.table.select(limit=50)
             self.assertEqual(str(query),
                 'SELECT "a".* FROM ('
                     'SELECT * FROM "t" AS "b") AS "a" '
-                'WHERE (ROWNUM <= %s)')
+                'WHERE ROWNUM <= %s')
             self.assertEqual(tuple(query.params), (50,))
 
             query = self.table.select(offset=10)
@@ -404,7 +435,7 @@ class TestSelect(unittest.TestCase):
                 'SELECT "a".* FROM ('
                     'SELECT "b".*, ROWNUM AS "rnum" FROM ('
                         'SELECT * FROM "t" AS "c") AS "b") AS "a" '
-                'WHERE ("rnum" > %s)')
+                'WHERE "rnum" > %s')
             self.assertEqual(tuple(query.params), (10,))
 
             query = self.table.select(self.table.c.as_('col'),
@@ -414,9 +445,9 @@ class TestSelect(unittest.TestCase):
                 'SELECT "a"."col" FROM ('
                     'SELECT "b"."col", ROWNUM AS "rnum" FROM ('
                         'SELECT "c"."c" AS "col" FROM "t" AS "c" '
-                        'WHERE ("c"."c" >= %s)) AS "b" '
-                    'WHERE (ROWNUM <= %s)) AS "a" '
-                'WHERE ("rnum" > %s)')
+                        'WHERE "c"."c" >= %s) AS "b" '
+                    'WHERE ROWNUM <= %s) AS "a" '
+                'WHERE "rnum" > %s')
             self.assertEqual(tuple(query.params), (20, 60, 10))
         finally:
             Flavor.set(Flavor())
@@ -468,7 +499,7 @@ class TestSelect(unittest.TestCase):
             Rank(filter_=self.table.c1 > 0, window=window),
             Min(self.table.c1, window=window))
         self.assertEqual(str(query),
-            'SELECT RANK() FILTER (WHERE ("a"."c1" > %s)) OVER "b", '
+            'SELECT RANK() FILTER (WHERE "a"."c1" > %s) OVER "b", '
             'MIN("a"."c1") OVER "b" FROM "t" AS "a" '
             'WINDOW "b" AS (PARTITION BY "a"."c1")')
         self.assertEqual(tuple(query.params), (0,))
@@ -486,8 +517,8 @@ class TestSelect(unittest.TestCase):
             Max(self.table.c1, window=window)
             / Min(self.table.c1, window=window))
         self.assertEqual(str(query),
-            'SELECT (MAX("a"."c1") OVER (PARTITION BY "a"."c2") '
-            '/ MIN("a"."c1") OVER (PARTITION BY "a"."c2")) '
+            'SELECT MAX("a"."c1") OVER (PARTITION BY "a"."c2") '
+            '/ MIN("a"."c1") OVER (PARTITION BY "a"."c2") '
             'FROM "t" AS "a"')
         self.assertEqual(tuple(query.params), ())
 
@@ -496,8 +527,8 @@ class TestSelect(unittest.TestCase):
             Max(self.table.c1, window=window)
             / Min(self.table.c1, window=window))
         self.assertEqual(str(query),
-            'SELECT (MAX("a"."c1") OVER (PARTITION BY %s) '
-            '/ MIN("a"."c1") OVER (PARTITION BY %s)) '
+            'SELECT MAX("a"."c1") OVER (PARTITION BY %s) '
+            '/ MIN("a"."c1") OVER (PARTITION BY %s) '
             'FROM "t" AS "a"')
         self.assertEqual(tuple(query.params), (1, 1))
 
@@ -508,8 +539,8 @@ class TestSelect(unittest.TestCase):
             / Min(self.table.c1, window=window2),
             windows=[window1])
         self.assertEqual(str(query),
-            'SELECT (MAX("a"."c1") OVER "b" '
-            '/ MIN("a"."c1") OVER (PARTITION BY %s)) '
+            'SELECT MAX("a"."c1") OVER "b" '
+            '/ MIN("a"."c1") OVER (PARTITION BY %s) '
             'FROM "t" AS "a" '
             'WINDOW "b" AS (PARTITION BY "a"."c2")')
         self.assertEqual(tuple(query.params), (1,))
@@ -541,10 +572,10 @@ class TestSelect(unittest.TestCase):
             order_by=[Literal(8)])
         self.assertEqual(
             str(query),
-            'WITH "c" AS (SELECT "a"."c" FROM "t" AS "a" WHERE ("a"."c" > %s))'
+            'WITH "c" AS (SELECT "a"."c" FROM "t" AS "a" WHERE "a"."c" > %s)'
             ' SELECT %s, MIN("a"."c") OVER "b" '
-            'FROM SELECT * FROM "t" AS "a" WHERE ("a"."c" > %s) '
-            'WHERE ("a"."c" > %s) '
+            'FROM SELECT * FROM "t" AS "a" WHERE "a"."c" > %s '
+            'WHERE "a"."c" > %s '
             'GROUP BY %s '
             'HAVING %s '
             'WINDOW "b" AS (PARTITION BY %s) '

sql/tests/test_update.py

@@ -15,7 +15,7 @@ class TestUpdate(unittest.TestCase):
 
         query.where = (self.table.b == Literal(True))
         self.assertEqual(str(query),
-            'UPDATE "t" AS "a" SET "c" = %s WHERE ("a"."b" = %s)')
+            'UPDATE "t" AS "a" SET "c" = %s WHERE "a"."b" = %s')
         self.assertEqual(query.params, ('foo', True))
 
     def test_update2(self):
@@ -24,7 +24,7 @@ class TestUpdate(unittest.TestCase):
         query = t1.update([t1.c], ['foo'], from_=[t2], where=(t1.c == t2.c))
         self.assertEqual(str(query),
             'UPDATE "t1" AS "b" SET "c" = %s FROM "t2" AS "a" '
-            'WHERE ("b"."c" = "a"."c")')
+            'WHERE "b"."c" = "a"."c"')
         self.assertEqual(query.params, ('foo',))
 
     def test_update_invalid_values(self):
@@ -43,7 +43,7 @@ class TestUpdate(unittest.TestCase):
         for query in [query_list, query_nolist]:
             self.assertEqual(str(query),
                 'UPDATE "t1" AS "b" SET "c" = ('
-                'SELECT "a"."c" FROM "t2" AS "a" WHERE ("a"."i" = "b"."i"))')
+                'SELECT "a"."c" FROM "t2" AS "a" WHERE "a"."i" = "b"."i")')
             self.assertEqual(query.params, ())
 
     def test_update_returning(self):
@@ -62,7 +62,7 @@ class TestUpdate(unittest.TestCase):
         self.assertEqual(str(query),
             'UPDATE "t1" AS "b" SET "c" = %s '
             'RETURNING (SELECT "a"."c" FROM "t2" AS "a" '
-            'WHERE (("a"."c1" = "b"."c") AND ("a"."c2" = %s)))')
+            'WHERE ("a"."c1" = "b"."c") AND ("a"."c2" = %s))')
         self.assertEqual(query.params, ('foo', 'bar'))
 
     def test_with(self):
@@ -76,7 +76,7 @@ class TestUpdate(unittest.TestCase):
         self.assertEqual(str(query),
             'WITH "a" AS (SELECT "b"."c1" FROM "t1" AS "b") '
             'UPDATE "t" AS "c" SET "c2" = (SELECT "a"."c3" FROM "a" AS "a" '
-            'WHERE ("a"."c4" = %s))')
+            'WHERE "a"."c4" = %s)')
         self.assertEqual(query.params, (2,))
 
     def test_schema(self):
@@ -95,5 +95,5 @@ class TestUpdate(unittest.TestCase):
         self.assertEqual(str(query),
             'UPDATE "default"."t1" AS "b" SET "c1" = ('
             'SELECT "a"."c" FROM "default"."t2" AS "a" '
-            'WHERE ("a"."i" = "b"."i"))')
+            'WHERE "a"."i" = "b"."i")')
         self.assertEqual(query.params, ())

sql/tests/test_with.py

@@ -15,7 +15,7 @@ class TestWith(unittest.TestCase):
 
             self.assertEqual(simple.statement(),
                 '"a" AS ('
-                'SELECT "b"."id" FROM "t" AS "b" WHERE ("b"."id" = %s)'
+                'SELECT "b"."id" FROM "t" AS "b" WHERE "b"."id" = %s'
                 ')')
             self.assertEqual(simple.statement_params(), (1,))
 
@@ -40,7 +40,7 @@ class TestWith(unittest.TestCase):
             wq = WithQuery(with_=[simple, second])
             self.assertEqual(wq._with_str(),
                 'WITH "a" AS ('
-                'SELECT "b"."id" FROM "t" AS "b" WHERE ("b"."id" = %s)'
+                'SELECT "b"."id" FROM "t" AS "b" WHERE "b"."id" = %s'
                 '), "c" AS ('
                 'SELECT * FROM "a" AS "a"'
                 ') ')
@@ -59,7 +59,7 @@ class TestWith(unittest.TestCase):
             'WITH RECURSIVE "a" ("n") AS ('
             'VALUES (%s) '
             'UNION ALL '
-            'SELECT ("a"."n" + %s) FROM "a" AS "a" WHERE ("a"."n" < %s)'
+            '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))
 

python_sql-1.6.0.dist-info/RECORD

@@ -1,41 +0,0 @@
-sql/__init__.py,sha256=-nJkGjLVQGCXqmhds4JZSFJv0hmWO_v9X3G3JaNbSEI,64423
-sql/aggregate.py,sha256=RXBhXHKRARhbTjMxuf6PR29vz5lHzEm_qJHzvfwHw2Q,5834
-sql/conditionals.py,sha256=xJY6ffEBeES6CiGKErXSa2dK2FXaEaR_QQl_CKILP30,2541
-sql/functions.py,sha256=IrX7ft6Psvr0XgoACE_iq6AupdeFJbo_62JoJCXnycs,12550
-sql/operators.py,sha256=Yw8cQCKT9p-OkwkCTjLg4Une2Daur14CbpsRo4SX-v8,10923
-sql/tests/__init__.py,sha256=QA18gftL_tykRkbGriAobA3THDVu34v8Pdn-a2qJywY,679
-sql/tests/test_aggregate.py,sha256=RZDc_6pQg7pBmrDEXY15N3ntojVhjR81qkzyp3P7PD8,3376
-sql/tests/test_alias.py,sha256=wtBwMkA8HADz3Tq6kz-MJXBG75hL0AbO2Z3LE7L2YTY,2408
-sql/tests/test_as.py,sha256=OfXDu0CnJ2paRKR29dMdx7q_Q9TFY60MWlvib6MR5LY,926
-sql/tests/test_cast.py,sha256=ejrqHQZwA3967UhszYR3caZYvH3waPcF6li4rnmxGi4,653
-sql/tests/test_collate.py,sha256=_RJM_t-YzCoO34b6k35jBoTyQedTK7EXywYosrK1bUQ,688
-sql/tests/test_column.py,sha256=_GkBkBzLW_fDoJy5yUWDtHTSyka1s5Drd4gDuvtIM_8,866
-sql/tests/test_combining_query.py,sha256=vag9FEKuGEFu6tlMc0lT6PkaE4mtl0KiuCNBxSfKTLY,2415
-sql/tests/test_conditionals.py,sha256=kNkgsjOatXpJnF9AED03ANNd0zWIwWTrnWdi4PWfl3E,2705
-sql/tests/test_delete.py,sha256=QmBt8QfS03uxWEBRetSv4q2PGFiAZRp_NavQd6E1aEs,2243
-sql/tests/test_excluded.py,sha256=aOdzg9oOTeaCPzQ2MOBC2F-KJl1hWI39MnM2cfaVSHs,388
-sql/tests/test_expression.py,sha256=39Z4hZXxUW6vJDmWMKJGpdf1tMP5i-1bfNaYvrHv2JY,457
-sql/tests/test_flavor.py,sha256=ho8wjHDbZDVB0NYN_lCPL3MdyzBhYYfCxolR1wQv3qU,1240
-sql/tests/test_for.py,sha256=_qk3ovyPtcq4XBK21OzmovLPiqgSvhGc4nhpX8IYC4s,651
-sql/tests/test_from.py,sha256=USwyW8WnbRO_oQBc-Fmgv9rwhARY2bOF-k5ZBxozyIw,713
-sql/tests/test_from_item.py,sha256=SJosqjO8UKPNppgtYRN_HKFlu17j5Aw6OVAQ4BGSNXo,1177
-sql/tests/test_functions.py,sha256=PAM3-QbdZs7_3UGbLGNIuW9f5LahkR8fyFiNadItM7w,5915
-sql/tests/test_grouping.py,sha256=hdUOeEhYIuKxvLrSmkFZlIW93uMq8exbtp9XqEodgEE,338
-sql/tests/test_insert.py,sha256=809miHmYCNVp0yi2sJW7TalutLzmYn8pfNam5Ncq4_o,9367
-sql/tests/test_join.py,sha256=Sg47Hs3NIhGq_eIajv36TzGykwqdNe9exPNwJwkffRg,2643
-sql/tests/test_lateral.py,sha256=cmdoNCGZZoiqQRKioYcLHLRJImfDjDPFz9Mbdt0qi_E,1047
-sql/tests/test_literal.py,sha256=ht-VLhGdpUm_rbtOzpQgbX3YQup_xp7F9va0RSWY0Ts,1010
-sql/tests/test_merge.py,sha256=1E9xxaJ8N1UxrAUcDpBI-OVIqzLpmzFn2Q7FE3cfEdk,5460
-sql/tests/test_operators.py,sha256=tyAnzTpUlhYXTJ2XKN8EEwan2p21xU1cB0cXhJmCQD0,16160
-sql/tests/test_order.py,sha256=jJJ2I5lshkACurwPqQekipzT6RzFuklbprxX5LMsGRI,2272
-sql/tests/test_rollup.py,sha256=Ae7PVTnyELICcjC00dkcAiHzr61NG8cnIcAoHagHr98,339
-sql/tests/test_select.py,sha256=etrdugGEUW9NG0AIOYU3ALxP9JQLAEkhIRlh1FeUJWQ,22164
-sql/tests/test_table.py,sha256=ZF6VzLcx54ulj69Qnt0hdQ7_XamAqpofyTKs0WiGB4E,758
-sql/tests/test_update.py,sha256=SCUsUCfMqtOS0m_87Ne24wgdPHgEs3jynbDEQP33oeg,3784
-sql/tests/test_values.py,sha256=qKvaFSDEQmVWajWhMZgqD2-rQcWJeW_nsevVMsV3jD8,1053
-sql/tests/test_window.py,sha256=EpqjZX2cyQ-m7UWMubrB5MOtL_5uF8jSnNhODfE74xc,3183
-sql/tests/test_with.py,sha256=SSLN1b0L8bLr5MwvCPOynP0HdfkUNPCNv7BWSJ4DalY,2371
-python_sql-1.6.0.dist-info/METADATA,sha256=yDf7Ch11yLkhncjfGgHtocDjQSrtDLvi_wiAlEOMvQo,8776
-python_sql-1.6.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-python_sql-1.6.0.dist-info/top_level.txt,sha256=hwJHmWfbRP5a_XNfqgHwi2zrjAAzAJk24QZoTocslow,4
-python_sql-1.6.0.dist-info/RECORD,,

python_sql-1.6.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-sql