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

sql/tests/test_functions.py

@@ -4,7 +4,7 @@ import unittest
 
 from sql import AliasManager, Flavor, Table, Window
 from sql.functions import (
-    Abs, AtTimeZone, CurrentTime, Div, Function, FunctionKeyword,
+    Abs, AtTimeZone, CurrentTime, Div, Extract, Function, FunctionKeyword,
     FunctionNotCallable, Overlay, Rank, Trim, WindowFunction)
 
 
@@ -70,7 +70,7 @@ class TestFunctions(unittest.TestCase):
         abs_ = Abs(self.table.select(self.table.c1,
                 where=self.table.c2 == 'foo'))
         self.assertEqual(str(abs_),
-            'ABS((SELECT "a"."c1" FROM "t" AS "a" WHERE ("a"."c2" = %s)))')
+            'ABS((SELECT "a"."c1" FROM "t" AS "a" WHERE "a"."c2" = %s))')
         self.assertEqual(abs_.params, ('foo',))
 
     def test_overlay(self):
@@ -110,7 +110,7 @@ class TestFunctions(unittest.TestCase):
             self.table.select(self.table.tz, where=self.table.c1 == 'foo'))
         self.assertEqual(str(time_zone),
             '"c1" AT TIME ZONE '
-            '(SELECT "a"."tz" FROM "t" AS "a" WHERE ("a"."c1" = %s))')
+            '(SELECT "a"."tz" FROM "t" AS "a" WHERE "a"."c1" = %s)')
         self.assertEqual(time_zone.params, ('foo',))
 
     def test_at_time_zone_mapping(self):
@@ -139,6 +139,38 @@ class TestFunctions(unittest.TestCase):
         self.assertEqual(str(current_time), 'CURRENT_TIME')
         self.assertEqual(current_time.params, ())
 
+    def test_extract(self):
+        extract = Extract(Extract.Fields.DAY, self.table.c)
+        self.assertEqual(str(extract), 'EXTRACT(DAY FROM "c")')
+        self.assertEqual(extract.params, ())
+
+        extract = Extract('day', self.table.c)
+        self.assertEqual(str(extract), 'EXTRACT(DAY FROM "c")')
+        self.assertEqual(extract.params, ())
+
+        extract = Extract(Extract.Fields.DAY, '2000-01-01')
+        self.assertEqual(str(extract), 'EXTRACT(DAY FROM %s)')
+        self.assertEqual(extract.params, ('2000-01-01',))
+
+    def test_extract_mapping(self):
+        class MyExtract(Function):
+            _function = 'MY_EXTRACT'
+
+        extract = Extract(Extract.Fields.DAY, '2000-01-01')
+        flavor = Flavor(function_mapping={
+                Extract: MyExtract,
+                })
+        Flavor.set(flavor)
+        try:
+            self.assertEqual(str(extract), 'MY_EXTRACT(%s, %s)')
+            self.assertEqual(extract.params, ('DAY', '2000-01-01'))
+        finally:
+            Flavor.set(Flavor())
+
+    def test_extract_invalid_field(self):
+        with self.assertRaises(ValueError):
+            Extract('foo', self.table.c)
+
 
 class TestWindowFunction(unittest.TestCase):
 
@@ -160,7 +192,7 @@ class TestWindowFunction(unittest.TestCase):
 
         with AliasManager():
             self.assertEqual(str(function),
-                'RANK("a"."c") FILTER (WHERE ("a"."c" > %s)) OVER ()')
+                'RANK("a"."c") FILTER (WHERE "a"."c" > %s) OVER ()')
         self.assertEqual(function.params, (0,))
 
     def test_invalid_filter(self):

sql/tests/test_insert.py

@@ -73,7 +73,7 @@ class TestInsert(unittest.TestCase):
         self.assertEqual(str(query),
             'INSERT INTO "t1" AS "b" ("c") VALUES (%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(tuple(query.params), ('foo', 'bar'))
 
     def test_insert_invalid_returning(self):
@@ -160,7 +160,7 @@ class TestInsert(unittest.TestCase):
 
         self.assertEqual(str(query),
             'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
-            'ON CONFLICT ("c1") WHERE ("a"."c2" = %s) DO NOTHING')
+            'ON CONFLICT ("c1") WHERE "a"."c2" = %s DO NOTHING')
         self.assertEqual(tuple(query.params), ('foo', 'bar'))
 
     def test_upsert_update(self):
@@ -188,7 +188,7 @@ class TestInsert(unittest.TestCase):
         self.assertEqual(str(query),
             'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
             'ON CONFLICT DO UPDATE SET "c1" = (%s) '
-            'WHERE ("a"."c2" = %s)')
+            'WHERE "a"."c2" = %s')
         self.assertEqual(tuple(query.params), ('baz', 'foo', 'bar'))
 
     def test_upsert_update_subquery(self):
@@ -218,7 +218,7 @@ class TestInsert(unittest.TestCase):
 
         self.assertEqual(str(query),
             'INSERT INTO "t" AS "a" ("c1") VALUES (%s) '
-            'ON CONFLICT DO UPDATE SET "c1" = (("EXCLUDED"."c1" + %s))')
+            'ON CONFLICT DO UPDATE SET "c1" = ("EXCLUDED"."c1" + %s)')
         self.assertEqual(tuple(query.params), (1, 2))
 
     def test_conflict_invalid_table(self):

sql/tests/test_join.py

@@ -18,7 +18,7 @@ class TestJoin(unittest.TestCase):
         join.condition = t1.c == t2.c
         with AliasManager():
             self.assertEqual(str(join),
-                '"t1" AS "a" INNER JOIN "t2" AS "b" ON ("a"."c" = "b"."c")')
+                '"t1" AS "a" INNER JOIN "t2" AS "b" ON "a"."c" = "b"."c"')
 
     def test_join_invalid_left(self):
         with self.assertRaises(ValueError):
@@ -45,7 +45,7 @@ class TestJoin(unittest.TestCase):
         with AliasManager():
             self.assertEqual(str(join),
                 '"t1" AS "a" INNER JOIN (SELECT * FROM "t2" AS "c") AS "b" '
-                'ON ("a"."c" = "b"."c")')
+                'ON "a"."c" = "b"."c"')
             self.assertEqual(tuple(join.params), ())
 
     def test_join_function(self):

sql/tests/test_lateral.py

@@ -16,7 +16,7 @@ class TestLateral(unittest.TestCase):
 
         self.assertEqual(str(query),
             'SELECT * FROM "t1" AS "a", LATERAL '
-            '(SELECT * FROM "t2" AS "c" WHERE ("c"."id" = "a"."t2")) AS "b"')
+            '(SELECT * FROM "t2" AS "c" WHERE "c"."id" = "a"."t2") AS "b"')
         self.assertEqual(tuple(query.params), ())
 
     def test_lateral_function(self):

sql/tests/test_merge.py

@@ -18,7 +18,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN MATCHED THEN DO NOTHING')
         self.assertEqual(query.params, ())
 
@@ -46,7 +46,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON (("a"."c1" = "b"."c2") AND ("a"."c3" = %s)) '
+            'ON ("a"."c1" = "b"."c2") AND ("a"."c3" = %s) '
             'WHEN MATCHED THEN DO NOTHING')
         self.assertEqual(query.params, (42,))
 
@@ -58,9 +58,9 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN MATCHED '
-            'AND (("b"."c3" = %s) AND ("a"."c4" = "b"."c5")) '
+            'AND ("b"."c3" = %s) AND ("a"."c4" = "b"."c5") '
             'THEN DO NOTHING')
         self.assertEqual(query.params, (42,))
 
@@ -73,9 +73,9 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN MATCHED THEN '
-            'UPDATE SET "c1" = ("a"."c1" + "b"."c2"), "c2" = %s')
+            'UPDATE SET "c1" = "a"."c1" + "b"."c2", "c2" = %s')
         self.assertEqual(query.params, (42,))
 
     def test_matched_delete(self):
@@ -84,7 +84,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN MATCHED THEN DELETE')
         self.assertEqual(query.params, ())
 
@@ -94,7 +94,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN NOT MATCHED THEN DO NOTHING')
         self.assertEqual(query.params, ())
 
@@ -107,7 +107,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN NOT MATCHED THEN '
             'INSERT ("c1", "c2") VALUES ("b"."c3", "b"."c4")')
         self.assertEqual(query.params, ())
@@ -119,7 +119,7 @@ class TestMerge(unittest.TestCase):
         self.assertEqual(
             str(query),
             'MERGE INTO "t" AS "a" USING "s" AS "b" '
-            'ON ("a"."c1" = "b"."c2") '
+            'ON "a"."c1" = "b"."c2" '
             'WHEN NOT MATCHED THEN '
             'INSERT ("c1", "c2") DEFAULT VALUES')
         self.assertEqual(query.params, ())
@@ -141,9 +141,9 @@ class TestMerge(unittest.TestCase):
             source, self.target.c1 == source.c2, Matched(), with_=[w])
         self.assertEqual(
             str(query),
-            'WITH "a" AS (SELECT * FROM "t1" AS "d" WHERE ("d"."c2" = %s)) '
+            'WITH "a" AS (SELECT * FROM "t1" AS "d" WHERE "d"."c2" = %s) '
             'MERGE INTO "t" AS "b" '
             'USING (SELECT * FROM "a" AS "a") AS "c" '
-            'ON ("b"."c1" = "c"."c2") '
+            'ON "b"."c1" = "c"."c2" '
             'WHEN MATCHED THEN DO NOTHING')
         self.assertEqual(query.params, (42,))