piccolo 1.21.0__py3-none-any.whl → 1.23.0__py3-none-any.whl

tests/columns/test_jsonb.py

@@ -1,6 +1,6 @@
 from piccolo.columns.column_types import JSONB, ForeignKey, Varchar
 from piccolo.table import Table
-from piccolo.testing.test_case import TableTest
+from piccolo.testing.test_case import AsyncTableTest, TableTest
 from tests.base import engines_only, engines_skip
 
 
@@ -137,93 +137,150 @@ class TestJSONB(TableTest):
             [{"name": "Guitar", "studio_facilities": {"mixing_desk": True}}],
         )
 
-    def test_arrow(self):
+
+@engines_only("postgres", "cockroach")
+class TestArrow(AsyncTableTest):
+    tables = [RecordingStudio, Instrument]
+
+    async def insert_row(self):
+        await RecordingStudio(
+            name="Abbey Road", facilities='{"mixing_desk": true}'
+        ).save()
+
+    async def test_arrow(self):
         """
         Test using the arrow function to retrieve a subset of the JSON.
         """
-        RecordingStudio(
-            name="Abbey Road", facilities='{"mixing_desk": true}'
-        ).save().run_sync()
+        await self.insert_row()
 
-        row = (
-            RecordingStudio.select(
-                RecordingStudio.facilities.arrow("mixing_desk")
-            )
-            .first()
-            .run_sync()
-        )
+        row = await RecordingStudio.select(
+            RecordingStudio.facilities.arrow("mixing_desk")
+        ).first()
         assert row is not None
         self.assertEqual(row["facilities"], "true")
 
-        row = (
+        row = await (
             RecordingStudio.select(
                 RecordingStudio.facilities.arrow("mixing_desk")
             )
             .output(load_json=True)
             .first()
-            .run_sync()
         )
         assert row is not None
         self.assertEqual(row["facilities"], True)
 
-    def test_arrow_as_alias(self):
+    async def test_arrow_as_alias(self):
         """
         Test using the arrow function to retrieve a subset of the JSON.
         """
-        RecordingStudio(
-            name="Abbey Road", facilities='{"mixing_desk": true}'
-        ).save().run_sync()
+        await self.insert_row()
 
-        row = (
-            RecordingStudio.select(
-                RecordingStudio.facilities.arrow("mixing_desk").as_alias(
-                    "mixing_desk"
-                )
+        row = await RecordingStudio.select(
+            RecordingStudio.facilities.arrow("mixing_desk").as_alias(
+                "mixing_desk"
             )
-            .first()
-            .run_sync()
-        )
+        ).first()
+        assert row is not None
+        self.assertEqual(row["mixing_desk"], "true")
+
+    async def test_square_brackets(self):
+        """
+        Make sure we can use square brackets instead of calling ``arrow``
+        explicitly.
+        """
+        await self.insert_row()
+
+        row = await RecordingStudio.select(
+            RecordingStudio.facilities["mixing_desk"].as_alias("mixing_desk")
+        ).first()
         assert row is not None
         self.assertEqual(row["mixing_desk"], "true")
 
-    def test_arrow_where(self):
+    async def test_multiple_levels_deep(self):
+        """
+        Make sure elements can be extracted multiple levels deep, and using
+        array indexes.
+        """
+        await RecordingStudio(
+            name="Abbey Road",
+            facilities={
+                "technicians": [
+                    {"name": "Alice Jones"},
+                    {"name": "Bob Williams"},
+                ]
+            },
+        ).save()
+
+        response = await RecordingStudio.select(
+            RecordingStudio.facilities["technicians"][0]["name"].as_alias(
+                "technician_name"
+            )
+        ).output(load_json=True)
+        assert response is not None
+        self.assertListEqual(response, [{"technician_name": "Alice Jones"}])
+
+    async def test_arrow_where(self):
         """
         Make sure the arrow function can be used within a WHERE clause.
         """
-        RecordingStudio(
-            name="Abbey Road", facilities='{"mixing_desk": true}'
-        ).save().run_sync()
+        await self.insert_row()
 
         self.assertEqual(
-            RecordingStudio.count()
-            .where(RecordingStudio.facilities.arrow("mixing_desk").eq(True))
-            .run_sync(),
+            await RecordingStudio.count().where(
+                RecordingStudio.facilities.arrow("mixing_desk").eq(True)
+            ),
             1,
         )
 
         self.assertEqual(
-            RecordingStudio.count()
-            .where(RecordingStudio.facilities.arrow("mixing_desk").eq(False))
-            .run_sync(),
+            await RecordingStudio.count().where(
+                RecordingStudio.facilities.arrow("mixing_desk").eq(False)
+            ),
             0,
         )
 
-    def test_arrow_first(self):
+    async def test_arrow_first(self):
         """
         Make sure the arrow function can be used with the first clause.
         """
-        RecordingStudio.insert(
+        await RecordingStudio.insert(
             RecordingStudio(facilities='{"mixing_desk": true}'),
             RecordingStudio(facilities='{"mixing_desk": false}'),
-        ).run_sync()
+        )
 
         self.assertEqual(
-            RecordingStudio.select(
+            await RecordingStudio.select(
                 RecordingStudio.facilities.arrow("mixing_desk").as_alias(
                     "mixing_desk"
                 )
-            )
-            .first()
-            .run_sync(),
+            ).first(),
             {"mixing_desk": "true"},
         )
+
+
+@engines_only("postgres", "cockroach")
+class TestFromPath(AsyncTableTest):
+
+    tables = [RecordingStudio, Instrument]
+
+    async def test_from_path(self):
+        """
+        Make sure ``from_path`` can be used for complex nested data.
+        """
+        await RecordingStudio(
+            name="Abbey Road",
+            facilities={
+                "technicians": [
+                    {"name": "Alice Jones"},
+                    {"name": "Bob Williams"},
+                ]
+            },
+        ).save()
+
+        response = await RecordingStudio.select(
+            RecordingStudio.facilities.from_path(
+                ["technicians", 0, "name"]
+            ).as_alias("technician_name")
+        ).output(load_json=True)
+        assert response is not None
+        self.assertListEqual(response, [{"technician_name": "Alice Jones"}])

tests/query/operators/test_json.py

@@ -0,0 +1,52 @@
+from unittest import TestCase
+
+from piccolo.columns import JSONB
+from piccolo.query.operators.json import GetChildElement, GetElementFromPath
+from piccolo.table import Table
+from tests.base import engines_skip
+
+
+class RecordingStudio(Table):
+    facilities = JSONB(null=True)
+
+
+@engines_skip("sqlite")
+class TestGetChildElement(TestCase):
+
+    def test_query(self):
+        """
+        Make sure the generated SQL looks correct.
+        """
+        querystring = GetChildElement(
+            GetChildElement(RecordingStudio.facilities, "a"), "b"
+        )
+
+        sql, query_args = querystring.compile_string()
+
+        self.assertEqual(
+            sql,
+            '"recording_studio"."facilities" -> $1 -> $2',
+        )
+
+        self.assertListEqual(query_args, ["a", "b"])
+
+
+@engines_skip("sqlite")
+class TestGetElementFromPath(TestCase):
+
+    def test_query(self):
+        """
+        Make sure the generated SQL looks correct.
+        """
+        querystring = GetElementFromPath(
+            RecordingStudio.facilities, ["a", "b"]
+        )
+
+        sql, query_args = querystring.compile_string()
+
+        self.assertEqual(
+            sql,
+            '"recording_studio"."facilities" #> $1',
+        )
+
+        self.assertListEqual(query_args, [["a", "b"]])

tests/table/test_insert.py

@@ -201,7 +201,7 @@ class TestOnConflict(TestCase):
         Make sure that a composite unique constraint can be used as a target.
 
         We only run it on Postgres and Cockroach because we use ALTER TABLE
-        to add a contraint, which SQLite doesn't support.
+        to add a constraint, which SQLite doesn't support.
         """
         Band = self.Band