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

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.21.0"
+__VERSION__ = "1.22.0"

piccolo/apps/playground/commands/run.py

@@ -233,6 +233,11 @@ def populate():
             RecordingStudio.facilities: {
                 "restaurant": True,
                 "mixing_desk": True,
+                "instruments": {"electric_guitars": 10, "drum_kits": 2},
+                "technicians": [
+                    {"name": "Alice Jones"},
+                    {"name": "Bob Williams"},
+                ],
             },
         }
     )
@@ -244,6 +249,10 @@ def populate():
             RecordingStudio.facilities: {
                 "restaurant": False,
                 "mixing_desk": True,
+                "instruments": {"electric_guitars": 6, "drum_kits": 3},
+                "technicians": [
+                    {"name": "Frank Smith"},
+                ],
             },
         },
     )

piccolo/columns/column_types.py

@@ -70,6 +70,10 @@ from piccolo.utils.warnings import colored_warning
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.base import ColumnMeta
+    from piccolo.query.operators.json import (
+        GetChildElement,
+        GetElementFromPath,
+    )
     from piccolo.table import Table
 
 
@@ -2319,6 +2323,76 @@ class JSON(Column):
         else:
             return "JSON"
 
+    ###########################################################################
+
+    def arrow(self, key: t.Union[str, int, QueryString]) -> GetChildElement:
+        """
+        Allows a child element of the JSON structure to be returned - for
+        example::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.arrow("restaurant")
+            ... )
+
+        """
+        from piccolo.query.operators.json import GetChildElement
+
+        alias = self._alias or self._meta.get_default_alias()
+        return GetChildElement(identifier=self, key=key, alias=alias)
+
+    def __getitem__(
+        self, value: t.Union[str, int, QueryString]
+    ) -> GetChildElement:
+        """
+        A shortcut for the ``arrow`` method, used for retrieving a child
+        element.
+
+        For example:
+
+        .. code-block:: python
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities["restaurant"]
+            ... )
+
+        """
+        return self.arrow(key=value)
+
+    def from_path(
+        self,
+        path: t.List[t.Union[str, int]],
+    ) -> GetElementFromPath:
+        """
+        Allows an element of the JSON structure to be returned, which can be
+        arbitrarily deep. For example::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.from_path([
+            ...         "technician",
+            ...         0,
+            ...         "first_name"
+            ...     ])
+            ... )
+
+        It's the same as calling ``arrow`` multiple times, but is more
+        efficient / convenient if extracting highly nested data::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.facilities.arrow(
+            ...         "technician"
+            ...     ).arrow(
+            ...         0
+            ...     ).arrow(
+            ...         "first_name"
+            ...     )
+            ... )
+
+        """
+        from piccolo.query.operators.json import GetElementFromPath
+
+        alias = self._alias or self._meta.get_default_alias()
+        return GetElementFromPath(identifier=self, path=path, alias=alias)
+
     ###########################################################################
     # Descriptors
 
@@ -2337,10 +2411,10 @@ class JSON(Column):
 
 class JSONB(JSON):
     """
-    Used for storing JSON strings - Postgres only. The data is stored in a
-    binary format, and can be queried. Insertion can be slower (as it needs to
-    be converted to the binary format). The benefits of JSONB generally
-    outweigh the downsides.
+    Used for storing JSON strings - Postgres / CochroachDB only. The data is
+    stored in a binary format, and can be queried more efficiently. Insertion
+    can be slower (as it needs to be converted to the binary format). The
+    benefits of JSONB generally outweigh the downsides.
 
     :param default:
         Either a JSON string can be provided, or a Python ``dict`` or ``list``
@@ -2352,41 +2426,6 @@ class JSONB(JSON):
     def column_type(self):
         return "JSONB"  # Must be defined, we override column_type() in JSON()
 
-    def arrow(self, key: str) -> JSONB:
-        """
-        Allows part of the JSON structure to be returned - for example,
-        for {"a": 1}, and a key value of "a", then 1 will be returned.
-        """
-        instance = t.cast(JSONB, self.copy())
-        instance.json_operator = f"-> '{key}'"
-        return instance
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> QueryString:
-        select_string = self._meta.get_full_name(with_alias=False)
-
-        if self.json_operator is not None:
-            select_string += f" {self.json_operator}"
-
-        if with_alias:
-            alias = self._alias or self._meta.get_default_alias()
-            select_string += f' AS "{alias}"'
-
-        return QueryString(select_string)
-
-    def eq(self, value) -> Where:
-        """
-        See ``Boolean.eq`` for more details.
-        """
-        return self.__eq__(value)
-
-    def ne(self, value) -> Where:
-        """
-        See ``Boolean.ne`` for more details.
-        """
-        return self.__ne__(value)
-
     ###########################################################################
     # Descriptors
 

piccolo/query/base.py

@@ -6,6 +6,7 @@ from time import time
 from piccolo.columns.column_types import JSON, JSONB
 from piccolo.custom_types import QueryResponseType, TableInstance
 from piccolo.query.mixins import ColumnsDelegate
+from piccolo.query.operators.json import JSONQueryString
 from piccolo.querystring import QueryString
 from piccolo.utils.encoding import load_json
 from piccolo.utils.objects import make_nested_object
@@ -65,16 +66,20 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
                 self, "columns_delegate", None
             )
 
+            json_column_names: t.List[str] = []
+
             if columns_delegate is not None:
-                json_columns = [
-                    i
-                    for i in columns_delegate.selected_columns
-                    if isinstance(i, (JSON, JSONB))
-                ]
+                json_columns: t.List[t.Union[JSON, JSONB]] = []
+
+                for column in columns_delegate.selected_columns:
+                    if isinstance(column, (JSON, JSONB)):
+                        json_columns.append(column)
+                    elif isinstance(column, JSONQueryString):
+                        if alias := column._alias:
+                            json_column_names.append(alias)
             else:
                 json_columns = self.table._meta.json_columns
 
-            json_column_names = []
             for column in json_columns:
                 if column._alias is not None:
                     json_column_names.append(column._alias)

piccolo/query/operators/json.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import typing as t
+
+from piccolo.querystring import QueryString
+from piccolo.utils.encoding import dump_json
+
+if t.TYPE_CHECKING:
+    from piccolo.columns.column_types import JSON
+
+
+class JSONQueryString(QueryString):
+
+    def clean_value(self, value: t.Any):
+        if not isinstance(value, (str, QueryString)):
+            value = dump_json(value)
+        return value
+
+    def __eq__(self, value) -> QueryString:  # type: ignore[override]
+        value = self.clean_value(value)
+        return QueryString("{} = {}", self, value)
+
+    def __ne__(self, value) -> QueryString:  # type: ignore[override]
+        value = self.clean_value(value)
+        return QueryString("{} != {}", self, value)
+
+    def eq(self, value) -> QueryString:
+        return self.__eq__(value)
+
+    def ne(self, value) -> QueryString:
+        return self.__ne__(value)
+
+
+class GetChildElement(JSONQueryString):
+    """
+    Allows you to get a child element from a JSON object.
+
+    You can access this via the ``arrow`` function on ``JSON`` and ``JSONB``
+    columns.
+
+    """
+
+    def __init__(
+        self,
+        identifier: t.Union[JSON, QueryString],
+        key: t.Union[str, int, QueryString],
+        alias: t.Optional[str] = None,
+    ):
+        if isinstance(key, int):
+            # asyncpg only accepts integer keys if we explicitly mark it as an
+            # int.
+            key = QueryString("{}::int", key)
+
+        super().__init__("{} -> {}", identifier, key, alias=alias)
+
+    def arrow(self, key: t.Union[str, int, QueryString]) -> GetChildElement:
+        """
+        This allows you to drill multiple levels deep into a JSON object if
+        needed.
+
+        For example::
+
+            >>> await RecordingStudio.select(
+            ...     RecordingStudio.name,
+            ...     RecordingStudio.facilities.arrow(
+            ...         "instruments"
+            ...     ).arrow(
+            ...         "drum_kits"
+            ...     ).as_alias("drum_kits")
+            ... ).output(load_json=True)
+            [
+                {'name': 'Abbey Road', 'drum_kits': 2},
+                {'name': 'Electric Lady', 'drum_kits': 3}
+            ]
+
+        """
+        return GetChildElement(identifier=self, key=key, alias=self._alias)
+
+    def __getitem__(
+        self, value: t.Union[str, int, QueryString]
+    ) -> GetChildElement:
+        return GetChildElement(identifier=self, key=value, alias=self._alias)
+
+
+class GetElementFromPath(JSONQueryString):
+    """
+    Allows you to retrieve an element from a JSON object by specifying a path.
+    It can be several levels deep.
+
+    You can access this via the ``from_path`` function on ``JSON`` and
+    ``JSONB`` columns.
+
+    """
+
+    def __init__(
+        self,
+        identifier: t.Union[JSON, QueryString],
+        path: t.List[t.Union[str, int]],
+        alias: t.Optional[str] = None,
+    ):
+        """
+        :param path:
+            For example: ``["technician", 0, "name"]``.
+
+        """
+        super().__init__(
+            "{} #> {}",
+            identifier,
+            [str(i) if isinstance(i, int) else i for i in path],
+            alias=alias,
+        )

piccolo/querystring.py

@@ -259,10 +259,22 @@ class QueryString(Selectable):
     # Basic logic
 
     def __eq__(self, value) -> QueryString:  # type: ignore[override]
-        return QueryString("{} = {}", self, value)
+        if value is None:
+            return QueryString("{} IS NULL", self)
+        else:
+            return QueryString("{} = {}", self, value)
 
     def __ne__(self, value) -> QueryString:  # type: ignore[override]
-        return QueryString("{} != {}", self, value)
+        if value is None:
+            return QueryString("{} IS NOT NULL", self, value)
+        else:
+            return QueryString("{} != {}", self, value)
+
+    def eq(self, value) -> QueryString:
+        return self.__eq__(value)
+
+    def ne(self, value) -> QueryString:
+        return self.__ne__(value)
 
     def __add__(self, value) -> QueryString:
         return QueryString("{} + {}", self, value)

piccolo/table_reflection.py

@@ -8,6 +8,8 @@ import typing as t
 from dataclasses import dataclass
 
 from piccolo.apps.schema.commands.generate import get_output_schema
+from piccolo.engine import engine_finder
+from piccolo.engine.base import Engine
 from piccolo.table import Table
 
 
@@ -78,9 +80,16 @@ class TableStorage(metaclass=Singleton):
     works with Postgres.
     """
 
-    def __init__(self):
+    def __init__(self, engine: t.Optional[Engine] = None):
+        """
+        :param engine:
+            Which engine to use to make the database queries. If not specified,
+            we try importing an engine from ``piccolo_conf.py``.
+
+        """
+        self.engine = engine or engine_finder()
         self.tables = ImmutableDict()
-        self._schema_tables = {}
+        self._schema_tables: t.Dict[str, t.List[str]] = {}
 
     async def reflect(
         self,
@@ -120,10 +129,13 @@ class TableStorage(metaclass=Singleton):
         exclude_list = self._to_list(exclude)
 
         if keep_existing:
-            exclude += self._schema_tables.get(schema_name, [])
+            exclude_list += self._schema_tables.get(schema_name, [])
 
         output_schema = await get_output_schema(
-            schema_name=schema_name, include=include_list, exclude=exclude_list
+            schema_name=schema_name,
+            include=include_list,
+            exclude=exclude_list,
+            engine=self.engine,
         )
         add_tables = [
             self._add_table(schema_name=schema_name, table=table)
@@ -177,7 +189,7 @@ class TableStorage(metaclass=Singleton):
 
     def _add_to_schema_tables(self, schema_name: str, table_name: str) -> None:
         """
-        We keep record of schemas and their tables for easy use. This method
+        We keep a record of schemas and their tables for easy use. This method
         adds a table to its schema.
 
         """

{piccolo-1.21.0.dist-info → piccolo-1.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.21.0
+Version: 1.22.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend
@@ -9,19 +9,20 @@ License: MIT
 Project-URL: Documentation, https://piccolo-orm.readthedocs.io/en/latest/index.html
 Project-URL: Source, https://github.com/piccolo-orm/piccolo
 Project-URL: Tracker, https://github.com/piccolo-orm/piccolo/issues
+Platform: UNKNOWN
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Framework :: AsyncIO
 Classifier: Typing :: Typed
 Classifier: Topic :: Database
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: black
@@ -34,7 +35,7 @@ Requires-Dist: pydantic[email] (==2.*)
 Provides-Extra: all
 Requires-Dist: orjson (>=3.5.1) ; extra == 'all'
 Requires-Dist: ipython ; extra == 'all'
-Requires-Dist: asyncpg (>=0.21.0) ; extra == 'all'
+Requires-Dist: asyncpg (>=0.30.0) ; extra == 'all'
 Requires-Dist: aiosqlite (>=0.16.0) ; extra == 'all'
 Requires-Dist: uvloop (>=0.12.0) ; (sys_platform != "win32") and extra == 'all'
 Provides-Extra: orjson
@@ -42,7 +43,7 @@ Requires-Dist: orjson (>=3.5.1) ; extra == 'orjson'
 Provides-Extra: playground
 Requires-Dist: ipython ; extra == 'playground'
 Provides-Extra: postgres
-Requires-Dist: asyncpg (>=0.21.0) ; extra == 'postgres'
+Requires-Dist: asyncpg (>=0.30.0) ; extra == 'postgres'
 Provides-Extra: sqlite
 Requires-Dist: aiosqlite (>=0.16.0) ; extra == 'sqlite'
 Provides-Extra: uvloop
@@ -155,3 +156,5 @@ We have a handy page which shows the equivalent of [common Django queries in Pic
 Our documentation is on [Read the docs](https://piccolo-orm.readthedocs.io/en/latest/piccolo/getting_started/index.html).
 
 We also have some great [tutorial videos on YouTube](https://www.youtube.com/channel/UCE7x5nm1Iy9KDfXPNrNQ5lA).
+
+

{piccolo-1.21.0.dist-info → piccolo-1.22.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-piccolo/__init__.py,sha256=lfg4osIcO7gnlgKb0zY1KT8t1Ngd2pATD-6YnBkIDcU,23
+piccolo/__init__.py,sha256=aVoeQDKbkLtZX6_B3ZNdv8mqfI_4pHUT1Go9Ek88OVI,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/querystring.py,sha256=yZdURtiVSlxkkEVJoFKAmL2OfNxrUr8xfsfuBBB7IuY,9662
+piccolo/querystring.py,sha256=kb7RYTvQZEyPsC4GH8vR2b_w35wnM-ita242S0_eyvQ,10013
 piccolo/schema.py,sha256=qNNy4tG_HqnXR9t3hHMgYXtGxHabwQAhUpc6RKLJ_gE,7960
 piccolo/table.py,sha256=UvEbagMYRkTbyFHTUwUshZlL_dC4UKDP7vUOwF8OXmg,50593
-piccolo/table_reflection.py,sha256=jrN1nHerDJ4tU09GtNN3hz7ap-7rXnSUjljFO6LB2H0,7094
+piccolo/table_reflection.py,sha256=02baOSLX6f2LEo0kruFZYF_nPPTbIvaCTH_KPGe0DKw,7540
 piccolo/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/piccolo_app.py,sha256=8z2ITpxQQ-McxSYwQ5H_vyEnRXbY6cyAh2JSqhiylYk,340
@@ -77,7 +77,7 @@ piccolo/apps/migrations/commands/templates/migration.py.jinja,sha256=wMC8RTIcQj3
 piccolo/apps/playground/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/playground/piccolo_app.py,sha256=zs6nGxt-lgUF8nEwI0uDTNZDKQqjZaNDH8le5RqrMNE,222
 piccolo/apps/playground/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/apps/playground/commands/run.py,sha256=S8osLV4s_mWdvvVYGn-49wel-d1SFRB17fO3ZtMcv8Y,8629
+piccolo/apps/playground/commands/run.py,sha256=lpCbVmXabWBlsgwE-8cK4woIK_78E3nq9CTfA5hEJFI,9014
 piccolo/apps/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/project/piccolo_app.py,sha256=mT3O0m3QcCfS0oOr3jt0QZ9TX6gUavGPjJeNn2C_fdM,220
 piccolo/apps/project/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -117,7 +117,7 @@ piccolo/apps/user/piccolo_migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 piccolo/columns/__init__.py,sha256=OYhO_n9anMiU9nL-K6ATq9FhAtm8RyMpqYQ7fTVbhxI,1120
 piccolo/columns/base.py,sha256=_bg9yMWjMwE76Z7RDqi9iYSmtRuFx5bkx9uYJsFHKjQ,32487
 piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,723
-piccolo/columns/column_types.py,sha256=X_ZsA0C4WBNVonV2OsizRdt1osMshgtQ3Ob6JN-amfg,83485
+piccolo/columns/column_types.py,sha256=XVI6qA_qsP1BD6bqVqQdj7a8dldoYz4VgOPI-wW696I,84747
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
 piccolo/columns/indexes.py,sha256=NfNok3v_791jgDlN28KmhP9ZCjl6031BXmjxV3ovXJk,372
 piccolo/columns/m2m.py,sha256=QMeSOnm4DT2cG9U5jC6sOZ6z9DxCWwDyZMSqk0wR2q4,14682
@@ -146,7 +146,7 @@ piccolo/engine/finder.py,sha256=GjzBNtzRzH79fjtRn7OI3nZiOXE8JfoQWAvHVPrPNx4,507
 piccolo/engine/postgres.py,sha256=DekL3KafCdzSAEQ6_EgOiUB1ERXh2xpePYwI9QvmN-c,18955
 piccolo/engine/sqlite.py,sha256=KwJc3UttBP_8qSREbLJshqEfROF17ENf0Ju9BwI5_so,25236
 piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
-piccolo/query/base.py,sha256=iI9Fv3oOw7T4ZWZvRKRwdtClvQtSaAepslH24vwxZVA,14616
+piccolo/query/base.py,sha256=sO5VyicbWjgYaQukr6jqUqUUrOctL6QJ1MjcsgDKHXM,14912
 piccolo/query/mixins.py,sha256=X9HEYnj6uOjgTkGr4vgqTwN_dokJPzVagwbFx385atQ,24468
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
 piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
@@ -172,6 +172,8 @@ piccolo/query/methods/refresh.py,sha256=wg1zghKfwz-VmqK4uWa4GNMiDtK-skTqow591Hb3
 piccolo/query/methods/select.py,sha256=41OW-DIE_wr5VdxSusMKNT2aUhzQsCwK2Qh1XqgXHg0,22424
 piccolo/query/methods/table_exists.py,sha256=0yb3n6Jd2ovSBWlZ-gl00K4E7Jnbj7J8qAAX5d7hvNk,1259
 piccolo/query/methods/update.py,sha256=LfWqIXEl1aecc0rkVssTFmwyD6wXGhlKcTrUVhtlEsw,3705
+piccolo/query/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+piccolo/query/operators/json.py,sha256=hdo1M6N9qTHJTJ0sRV9Bwt_iQZTgs4VdCKOPH1sXe-k,3168
 piccolo/testing/__init__.py,sha256=pRFSqRInfx95AakOq54atmvqoB-ue073q2aR8u8zR40,83
 piccolo/testing/model_builder.py,sha256=lVEiEe71xrH8SSjzFc2l0s-VaCXHeg9Bo5oAYOEbLrI,6545
 piccolo/testing/random_builder.py,sha256=0LkGpanQ7P1R82gLIMQyK9cm1LdZkPvxbShTEf3jeH4,2128
@@ -259,7 +261,7 @@ tests/columns/test_double_precision.py,sha256=7rhcSfDkb2fBh_zEG4UGwD_GW1sy6U9-8N
 tests/columns/test_get_sql_value.py,sha256=mKgsInN374jzV99y9mg_ZiG-AvnJgz36SZi89xL7RZM,1768
 tests/columns/test_interval.py,sha256=2M18pfoGxLLosEvwTmuC4zQkM6jWwU0Nv2fqViW3xOs,2780
 tests/columns/test_json.py,sha256=_cziJvw2uT8e_4u9lKhmU56lgQeE7bEqCXYf6AzfChA,3482
-tests/columns/test_jsonb.py,sha256=eJQoxpyuQ4yrX-GMJhRkZntyd4tX6M6RhAxYn2-ISII,6727
+tests/columns/test_jsonb.py,sha256=KXPgJTchobzHNss86Gb0CeTDlaa5S3pQ8cM3D06-7J8,8592
 tests/columns/test_numeric.py,sha256=AkTvdvjSsfRsMM79tx4AskUpsTizGBLMY_tC2OII9U4,751
 tests/columns/test_primary_key.py,sha256=foNG9eTQUJ5yiEVQ7faIEMycW_VuZ7vgzknYXaZ-QXM,4886
 tests/columns/test_readable.py,sha256=xKVfJuxZcfyncNVKXNryl2WFREX655jwD9DxiLArQiU,758
@@ -313,6 +315,8 @@ tests/query/functions/test_type_conversion.py,sha256=WeYR9UfJnbidle07-akQ1g9hFCd
 tests/query/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/query/mixins/test_columns_delegate.py,sha256=Zw9uaqOEb7kpPQzzO9yz0jhQEeCfoPSjsy-BCLg_8XU,2032
 tests/query/mixins/test_order_by_delegate.py,sha256=mOV3Gxs0XeliONxjWSOniI1z6lbZ_xTfcGYd53JLnaY,507
+tests/query/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/query/operators/test_json.py,sha256=SEYEdbyF0wB3nvONqyBGFlLe8OhgtSIvxx19P2uJ8Bw,1269
 tests/table/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/table/test_all_columns.py,sha256=wZ7i9mTT9wKWLE2BoQ9jDbPaqnBHfV-ZlsROp7SZq7k,667
 tests/table/test_alter.py,sha256=pMD38BIFfta1vxFqp8YoaRfMxdwxhQSwcxYO4erpUi8,12394
@@ -368,9 +372,9 @@ tests/utils/test_sql_values.py,sha256=vzxRmy16FfLZPH-sAQexBvsF9MXB8n4smr14qoEOS5
 tests/utils/test_sync.py,sha256=9ytVo56y2vPQePvTeIi9lHIouEhWJbodl1TmzkGFrSo,799
 tests/utils/test_table_reflection.py,sha256=SIzuat-IpcVj1GCFyOWKShI8YkhdOPPFH7qVrvfyPNE,3794
 tests/utils/test_warnings.py,sha256=NvSC_cvJ6uZcwAGf1m-hLzETXCqprXELL8zg3TNLVMw,269
-piccolo-1.21.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.21.0.dist-info/METADATA,sha256=CMfZm7IYerdMTQLFwzuyCPWZMlrGf1G_shqoq2LlnGM,5178
-piccolo-1.21.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-piccolo-1.21.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.21.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.21.0.dist-info/RECORD,,
+piccolo-1.22.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.22.0.dist-info/METADATA,sha256=eL8y2tQr2Vd5Wmmqe0ICPO145ccpTL_5cthuK_zXIVU,5199
+piccolo-1.22.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
+piccolo-1.22.0.dist-info/entry_points.txt,sha256=zYhu-YNtMlh2N_8wptCS8YWKOgc81UPL3Ji5gly8ouc,47
+piccolo-1.22.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.22.0.dist-info/RECORD,,

{piccolo-1.21.0.dist-info → piccolo-1.22.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: bdist_wheel (0.38.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{piccolo-1.21.0.dist-info → piccolo-1.22.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 piccolo = piccolo.main:main
+

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"]])