piccolo 1.14.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.14.0"
+__VERSION__ = "1.15.0"

piccolo/apps/user/tables.py

@@ -91,10 +91,14 @@ class BaseUser(Table, tablename="piccolo_user"):
             raise ValueError("A password must be provided.")
 
         if len(password) < cls._min_password_length:
-            raise ValueError("The password is too short.")
+            raise ValueError(
+                f"The password is too short. (min {cls._min_password_length})"
+            )
 
         if len(password) > cls._max_password_length:
-            raise ValueError("The password is too long.")
+            raise ValueError(
+                f"The password is too long. (max {cls._max_password_length})"
+            )
 
         if password.startswith("pbkdf2_sha256"):
             logger.warning(

piccolo/query/base.py

@@ -79,9 +79,7 @@ class Query(t.Generic[TableInstance, QueryResponseType]):
                 if column._alias is not None:
                     json_column_names.append(column._alias)
                 elif len(column._meta.call_chain) > 0:
-                    json_column_names.append(
-                        column._meta.get_default_alias().replace("$", ".")
-                    )
+                    json_column_names.append(column._meta.get_default_alias())
                 else:
                     json_column_names.append(column._meta.name)
 

piccolo/query/methods/refresh.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import typing as t
-from dataclasses import dataclass
 
+from piccolo.utils.encoding import JSONDict
 from piccolo.utils.sync import run_sync
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -10,7 +10,6 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table
 
 
-@dataclass
 class Refresh:
     """
     Used to refresh :class:`Table <piccolo.table.Table>` instances with the
@@ -22,11 +21,33 @@ class Refresh:
     :param columns:
         Which columns to refresh - it not specified, then all columns are
         refreshed.
+    :param load_json:
+        Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+        just a string.
 
     """
 
-    instance: Table
-    columns: t.Optional[t.Sequence[Column]] = None
+    def __init__(
+        self,
+        instance: Table,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
+    ):
+        self.instance = instance
+
+        if columns:
+            for column in columns:
+                if len(column._meta.call_chain) > 0:
+                    raise ValueError(
+                        "We can't currently selectively refresh certain "
+                        "columns on child objects (e.g. Concert.band_1.name). "
+                        "Please just specify top level columns (e.g. "
+                        "Concert.band_1), and the entire child object will be "
+                        "refreshed."
+                    )
+
+        self.columns = columns
+        self.load_json = load_json
 
     @property
     def _columns(self) -> t.Sequence[Column]:
@@ -40,6 +61,63 @@ class Refresh:
             i for i in self.instance._meta.columns if not i._meta.primary_key
         ]
 
+    def _get_columns(self, instance: Table, columns: t.Sequence[Column]):
+        """
+        If `prefetch` was used on the object, for example::
+
+            >>> await Band.objects(Band.manager)
+
+        We should also update the prefetched object.
+
+        It works multiple level deep. If we refresh this::
+
+            >>> await Album.objects(Album.band.manager).first()
+
+        It will update the nested `band` object, and also the `manager`
+        object.
+
+        """
+        from piccolo.columns.column_types import ForeignKey
+        from piccolo.table import Table
+
+        select_columns = []
+
+        for column in columns:
+            if isinstance(column, ForeignKey) and isinstance(
+                (child_instance := getattr(instance, column._meta.name)),
+                Table,
+            ):
+                select_columns.extend(
+                    self._get_columns(
+                        child_instance,
+                        # Fetch all columns (even the primary key, just in
+                        # case the foreign key now references a different row).
+                        column.all_columns(),
+                    )
+                )
+            else:
+                select_columns.append(column)
+
+        return select_columns
+
+    def _update_instance(self, instance: Table, data_dict: t.Dict):
+        """
+        Update the table instance. It is called recursively, if the instance
+        has child instances.
+        """
+        for key, value in data_dict.items():
+            if isinstance(value, dict) and not isinstance(value, JSONDict):
+                # If the value is a dict, then it's a child instance.
+                if all(i is None for i in value.values()):
+                    # If all values in the nested object are None, then we can
+                    # safely assume that the object itself is null, as the
+                    # primary key value must be null.
+                    setattr(instance, key, None)
+                else:
+                    self._update_instance(getattr(instance, key), value)
+            else:
+                setattr(instance, key, value)
+
     async def run(
         self, in_pool: bool = True, node: t.Optional[str] = None
     ) -> Table:
@@ -54,7 +132,6 @@ class Refresh:
         Modifies the instance in place, but also returns it as a convenience.
 
         """
-
         instance = self.instance
 
         if not instance._exists_in_db:
@@ -71,20 +148,24 @@ class Refresh:
         if not columns:
             raise ValueError("No columns to fetch.")
 
-        updated_values = (
-            await instance.__class__.select(*columns)
+        select_columns = self._get_columns(
+            instance=self.instance, columns=columns
+        )
+
+        data_dict = (
+            await instance.__class__.select(*select_columns)
             .where(pk_column == primary_key_value)
+            .output(nested=True, load_json=self.load_json)
             .first()
             .run(node=node, in_pool=in_pool)
         )
 
-        if updated_values is None:
+        if data_dict is None:
             raise ValueError(
                 "The object doesn't exist in the database any more."
             )
 
-        for key, value in updated_values.items():
-            setattr(instance, key, value)
+        self._update_instance(instance=instance, data_dict=data_dict)
 
         return instance
 

piccolo/query/methods/select.py

@@ -406,6 +406,9 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
     def output(self: Self, *, load_json: bool, as_list: bool) -> SelectJSON:  # type: ignore  # noqa: E501
         ...
 
+    @t.overload
+    def output(self: Self, *, load_json: bool, nested: bool) -> Self: ...
+
     @t.overload
     def output(self: Self, *, nested: bool) -> Self: ...
 

piccolo/table.py

@@ -541,7 +541,9 @@ class Table(metaclass=TableMetaclass):
         )
 
     def refresh(
-        self, columns: t.Optional[t.Sequence[Column]] = None
+        self,
+        columns: t.Optional[t.Sequence[Column]] = None,
+        load_json: bool = False,
     ) -> Refresh:
         """
         Used to fetch the latest data for this instance from the database.
@@ -551,6 +553,10 @@ class Table(metaclass=TableMetaclass):
             If you only want to refresh certain columns, specify them here.
             Otherwise all columns are refreshed.
 
+        :param load_json:
+            Whether to load ``JSON`` / ``JSONB`` columns as objects, instead of
+            just a string.
+
         Example usage::
 
             # Get an instance from the database.
@@ -564,7 +570,7 @@ class Table(metaclass=TableMetaclass):
             instance.refresh().run_sync()
 
         """
-        return Refresh(instance=self, columns=columns)
+        return Refresh(instance=self, columns=columns, load_json=load_json)
 
     @t.overload
     def get_related(

piccolo/utils/encoding.py

@@ -29,5 +29,46 @@ def dump_json(data: t.Any, pretty: bool = False) -> str:
         return json.dumps(data, **params)  # type: ignore
 
 
+class JSONDict(dict):
+    """
+    Once we have parsed a JSON string into a dictionary, we can't distinguish
+    it from other dictionaries.
+
+    Sometimes we might want to - for example::
+
+        >>> await Album.select(
+        ...     Album.all_columns(),
+        ...     Album.recording_studio.all_columns()
+        ... ).output(
+        ...     nested=True,
+        ...     load_json=True
+        ... )
+
+        [{
+            'id': 1,
+            'band': 1,
+            'name': 'Awesome album 1',
+            'recorded_at': {
+                'id': 1,
+                'facilities': {'restaurant': True, 'mixing_desk': True},
+                'name': 'Abbey Road'
+            },
+            'release_date': datetime.date(2021, 1, 1)
+        }]
+
+    Facilities could be mistaken for a table.
+
+    """
+
+    ...
+
+
 def load_json(data: str) -> t.Any:
-    return orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
+    response = (
+        orjson.loads(data) if ORJSON else json.loads(data)  # type: ignore
+    )
+
+    if isinstance(response, dict):
+        return JSONDict(**response)
+
+    return response

{piccolo-1.14.0.dist-info → piccolo-1.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.14.0
+Version: 1.15.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

{piccolo-1.14.0.dist-info → piccolo-1.15.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-piccolo/__init__.py,sha256=vQd7XyktulZvg_rtkaOpG-2W02Gb_wFd8aev4i-MHeA,23
+piccolo/__init__.py,sha256=PzCSZ5iBV_NCcXFBA13Mmkxa8tLr-WxcGYxYBnMCjhA,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/schema.py,sha256=qNNy4tG_HqnXR9t3hHMgYXtGxHabwQAhUpc6RKLJ_gE,7960
-piccolo/table.py,sha256=IfXT9rtm1sBN-u_A8-_0gj6fJf3_RGSPtWMJa-FX9jw,49569
+piccolo/table.py,sha256=nS3zuhGNPZ4H9s_E3ieFbrE_u1Tr6TenBVw_nrrtmRQ,49766
 piccolo/table_reflection.py,sha256=jrN1nHerDJ4tU09GtNN3hz7ap-7rXnSUjljFO6LB2H0,7094
 piccolo/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -104,7 +104,7 @@ piccolo/apps/tester/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 piccolo/apps/tester/commands/run.py,sha256=phFxim2ogARAviW-YT11y9F-L5SJxSioAIepUzQeAWU,2431
 piccolo/apps/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/user/piccolo_app.py,sha256=yfw1J9FEnBWdgGdUdNMnqp06Wzm5_s9TO2r5KLchrLM,842
-piccolo/apps/user/tables.py,sha256=ZSXtOC9OANCKC6cq5ZCj3CqRwraibFDwtf1VVIBfmKQ,8954
+piccolo/apps/user/tables.py,sha256=KgPqONdl1SDV-3cGq5aS-za_v_5_TGHQqNFYXF0M3Jw,9082
 piccolo/apps/user/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/user/commands/change_password.py,sha256=F7mlhtTUY7uENSK8vds5oibIDJTz7QBQdrl7EB-lF9Q,649
 piccolo/apps/user/commands/change_permissions.py,sha256=LScsKJUMJqIi54cZ1SgS9Wb356KB0t7smu94FDXLfVk,1463
@@ -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=2eyfgqdzl5bKQBRpmxil_HoXpCEDGGrh84q62ZmfBNk,14680
+piccolo/query/base.py,sha256=iI9Fv3oOw7T4ZWZvRKRwdtClvQtSaAepslH24vwxZVA,14616
 piccolo/query/mixins.py,sha256=EFEFb9It4y1mR6_JXLn139h5M9KgeP750STYy5M4MLs,21951
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
 piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
@@ -168,8 +168,8 @@ piccolo/query/methods/indexes.py,sha256=J-QUqaBJwpgahskUH0Cu0Mq7zEKcfVAtDsUVIVX-
 piccolo/query/methods/insert.py,sha256=ssLJ_wn08KnOwwr7t-VILyn1P4hrvM63CfPIcAJWT5k,4701
 piccolo/query/methods/objects.py,sha256=iahDUziUtlx7pJ2uBAhdm3hCTmg2AS9C8cal1my5KR0,11705
 piccolo/query/methods/raw.py,sha256=VhYpCB52mZk4zqFTsqK5CHKTDGskUjISXTBV7UjohmA,600
-piccolo/query/methods/refresh.py,sha256=P1Eo_HYU_L7kcGM_cvDDgyLi1boCXY7Pc4tv_eDAzvc,2769
-piccolo/query/methods/select.py,sha256=KDbLRkADM9xNQsoNYN_eNSwapFACQCUNiCvw0B5tmko,21315
+piccolo/query/methods/refresh.py,sha256=wg1zghKfwz-VmqK4uWa4GNMiDtK-skTqow591Hb3ONM,5854
+piccolo/query/methods/select.py,sha256=UH-y2g3Ub7bEowfLObrrhw0W-HepTXWCmuMPhk13roE,21406
 piccolo/query/methods/table_exists.py,sha256=0yb3n6Jd2ovSBWlZ-gl00K4E7Jnbj7J8qAAX5d7hvNk,1259
 piccolo/query/methods/update.py,sha256=LfWqIXEl1aecc0rkVssTFmwyD6wXGhlKcTrUVhtlEsw,3705
 piccolo/testing/__init__.py,sha256=pRFSqRInfx95AakOq54atmvqoB-ue073q2aR8u8zR40,83
@@ -177,7 +177,7 @@ piccolo/testing/model_builder.py,sha256=lVEiEe71xrH8SSjzFc2l0s-VaCXHeg9Bo5oAYOEb
 piccolo/testing/random_builder.py,sha256=0LkGpanQ7P1R82gLIMQyK9cm1LdZkPvxbShTEf3jeH4,2128
 piccolo/utils/__init__.py,sha256=SDFFraauI9Op8dCRkreQv1dwUcab8Mi1eC-n0EwlTy8,36
 piccolo/utils/dictionary.py,sha256=8vRPxgaXadDVhqihP1UxL7nUBgM6Gpe_Eu3xJq7zzGM,1886
-piccolo/utils/encoding.py,sha256=W34oj1F2f8zeirMceHZnAnJL2T8rPoiqXt-DJ-hzRGk,835
+piccolo/utils/encoding.py,sha256=CtSODJOkT3TVHfGlTDXozDsClBCJbGGqluc6_UlJ-7c,1761
 piccolo/utils/lazy_loader.py,sha256=T8GChEqtKWcBegn-6g_BQ7hOg2Xu1bedFh7Z8E7xcOY,1912
 piccolo/utils/list.py,sha256=4hPGiksJWxL226W7gyYBcqVGgMTgVa2jP8zvalc3zw8,1541
 piccolo/utils/naming.py,sha256=d7_mMscguK799RMhxFDifRgn8Ply5wiy2k1KkP22WUs,276
@@ -237,7 +237,7 @@ tests/apps/sql_shell/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 tests/apps/sql_shell/commands/test_run.py,sha256=6p0nqCoG_qNLrKeBuHspmer_SrMwEF-vfp9LbPj2W2E,425
 tests/apps/tester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/apps/user/test_tables.py,sha256=E9mGAOiDjVtIJYqZzlvPU_JFz6RZzGAVeE0Lk5VjGb4,9523
+tests/apps/user/test_tables.py,sha256=5ImGAWpIKxlqweGeJRMiVOHaBJxRwSzsp3GZ7x6lzCo,9807
 tests/apps/user/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/user/commands/test_change_password.py,sha256=IEIlnny68jt4UFOaUOwHk9C7WHED51wYoSNX-YIi7rU,1051
 tests/apps/user/commands/test_change_permissions.py,sha256=uVKEiT1EKot3VA2TDETdQ1hsWL-83rLQrJl4jIxPgqo,2108
@@ -273,7 +273,7 @@ tests/columns/test_uuid.py,sha256=ifCyIrO6usYO33WM0FgwuPPhYzs4zVKD3MViIT61J7c,35
 tests/columns/test_varchar.py,sha256=Oyt8t7msCfIiZdU9B23zjlV6atFv4sX3iMSDJc565Oc,681
 tests/columns/m2m/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/columns/m2m/base.py,sha256=uH92ECQuY5AjpQXPySwrlruZPZzB4LH2V2FUSXmHRLQ,14563
-tests/columns/m2m/test_m2m.py,sha256=LtNsHQ8xAzBFLiZVZhWEB56zu25FnaWtzJ62FZH3heI,12647
+tests/columns/m2m/test_m2m.py,sha256=0ObmIHUJF6CZoNBznc5xXVr5_BbGBqOmWwtpg8IcPt4,13055
 tests/columns/m2m/test_m2m_schema.py,sha256=oxu7eAjFFpDjnq9Eq-5OTNmlnsEIMFWx18OItfpVs-s,339
 tests/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conf/example.py,sha256=K8sTttLpEac8rQlOLDY500IGkHj3P3NoyFbCMnT1EqY,347
@@ -336,7 +336,7 @@ tests/table/test_objects.py,sha256=bir86ks-Ngy8x9Eu9bekOrh6twBYdEkIgTdbBWY6x9s,8
 tests/table/test_output.py,sha256=ZnpPbgVp79JcB6E_ooWQxOpOlhkwNUlMxC-1LSIEc2Y,4304
 tests/table/test_raw.py,sha256=9PTvYngQi41nYd5lKzkJdTqsEcwrdOXcvZjq-W26CwQ,1683
 tests/table/test_ref.py,sha256=eYNRnYHzNMXuMbV3B1ca5EidpIg4500q6hr1ccuVaso,269
-tests/table/test_refresh.py,sha256=ZXGLGHeMZcWnhZPB4eCasv1RkojPt6nUbxaE7WlyJbo,2804
+tests/table/test_refresh.py,sha256=VqTNT0_UGifCYr0wWVEXqI53G51RlMu0-oaw8tUTTLs,9213
 tests/table/test_repr.py,sha256=uahz3_GffGQrf2mDE-4-Pu4AmSLBAyso6-9rbohCl58,446
 tests/table/test_select.py,sha256=jgeiahIlNFVijxYb3a54g1sJWVfH3llaYrsTBmdicrs,40390
 tests/table/test_str.py,sha256=eztWNULcjARR1fr9X5n4tojhDNgDfatVyNHwuYrzHAo,1731
@@ -365,9 +365,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.14.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.14.0.dist-info/METADATA,sha256=4rDBz-Wbqp-MdHwcZd3LaxJToiNqW5hVFQkCOkCD8LU,5178
-piccolo-1.14.0.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
-piccolo-1.14.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.14.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.14.0.dist-info/RECORD,,
+piccolo-1.15.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.15.0.dist-info/METADATA,sha256=GGstF5gDdGfqb2J2-55eYcA9pbhIVN6W23Jir9GF4A4,5178
+piccolo-1.15.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+piccolo-1.15.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.15.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.15.0.dist-info/RECORD,,

{piccolo-1.14.0.dist-info → piccolo-1.15.0.dist-info}/WHEEL

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

tests/apps/user/test_tables.py

@@ -109,7 +109,7 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, malicious_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too long.",
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
         # Test short passwords
@@ -118,7 +118,10 @@ class TestLogin(TestCase):
             BaseUser.update_password_sync(username, short_password)
         self.assertEqual(
             manager.exception.__str__(),
-            "The password is too short.",
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
         # Test no password
@@ -205,7 +208,11 @@ class TestCreateUser(TestCase):
             BaseUser.create_user_sync(username="bob", password="abc")
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too short."
+            manager.exception.__str__(),
+            (
+                "The password is too short. (min "
+                f"{BaseUser._min_password_length})"
+            ),
         )
 
     def test_long_password_error(self):
@@ -216,7 +223,8 @@ class TestCreateUser(TestCase):
             )
 
         self.assertEqual(
-            manager.exception.__str__(), "The password is too long."
+            manager.exception.__str__(),
+            f"The password is too long. (max {BaseUser._max_password_length})",
         )
 
     def test_no_username_error(self):

tests/columns/m2m/test_m2m.py

@@ -4,6 +4,7 @@ import decimal
 import uuid
 from unittest import TestCase
 
+from piccolo.utils.encoding import JSONDict
 from tests.base import engines_skip
 
 try:
@@ -376,6 +377,9 @@ class TestM2MComplexSchema(TestCase):
 
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),
@@ -401,6 +405,9 @@ class TestM2MComplexSchema(TestCase):
             if isinstance(column, UUID):
                 self.assertIn(type(returned_value), (uuid.UUID, asyncpgUUID))
                 self.assertEqual(str(original_value), str(returned_value))
+            elif isinstance(column, (JSON, JSONB)):
+                self.assertEqual(type(returned_value), JSONDict)
+                self.assertEqual(original_value, returned_value)
             else:
                 self.assertEqual(
                     type(original_value),

tests/table/test_refresh.py

@@ -1,5 +1,13 @@
-from tests.base import DBTestCase
-from tests.example_apps.music.tables import Band
+import typing as t
+
+from tests.base import DBTestCase, TableTest
+from tests.example_apps.music.tables import (
+    Band,
+    Concert,
+    Manager,
+    RecordingStudio,
+    Venue,
+)
 
 
 class TestRefresh(DBTestCase):
@@ -24,9 +32,55 @@ class TestRefresh(DBTestCase):
         # Refresh `band`, and make sure it has the correct data.
         band.refresh().run_sync()
 
-        self.assertTrue(band.name == "Pythonistas!!!")
-        self.assertTrue(band.popularity == 8000)
-        self.assertTrue(band.id == initial_data["id"])
+        self.assertEqual(band.name, "Pythonistas!!!")
+        self.assertEqual(band.popularity, 8000)
+        self.assertEqual(band.id, initial_data["id"])
+
+    def test_refresh_with_prefetch(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objets (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        Manager.update({Manager.name: "Guido!!!"}).where(
+            Manager.name == "Guido"
+        ).run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+
+        self.assertEqual(band.manager.name, "Guido!!!")
+
+    def test_refresh_with_prefetch_multiple_layers_deep(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objets (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        Manager.update({Manager.name: "Guido!!!"}).where(
+            Manager.name == "Guido"
+        ).run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+
+        self.assertEqual(band.manager.name, "Guido!!!")
 
     def test_columns(self) -> None:
         """
@@ -50,9 +104,9 @@ class TestRefresh(DBTestCase):
         )
         query.run_sync()
 
-        self.assertTrue(band.name == "Pythonistas!!!")
-        self.assertTrue(band.popularity == initial_data["popularity"])
-        self.assertTrue(band.id == initial_data["id"])
+        self.assertEqual(band.name, "Pythonistas!!!")
+        self.assertEqual(band.popularity, initial_data["popularity"])
+        self.assertEqual(band.id, initial_data["id"])
 
     def test_error_when_not_in_db(self) -> None:
         """
@@ -85,3 +139,159 @@ class TestRefresh(DBTestCase):
             "The instance's primary key value isn't defined.",
             str(manager.exception),
         )
+
+
+class TestRefreshWithPrefetch(TableTest):
+
+    tables = [Manager, Band, Concert, Venue]
+
+    def setUp(self):
+        super().setUp()
+
+        self.manager = Manager({Manager.name: "Guido"})
+        self.manager.save().run_sync()
+
+        self.band = Band(
+            {Band.name: "Pythonistas", Band.manager: self.manager}
+        )
+        self.band.save().run_sync()
+
+        self.concert = Concert({Concert.band_1: self.band})
+        self.concert.save().run_sync()
+
+    def test_single_layer(self) -> None:
+        """
+        Make sure ``refresh`` works, when the object used prefetch to get
+        nested objects (the nested objects should be updated too).
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Modify the data in the database.
+        self.manager.name = "Guido!!!"
+        self.manager.save().run_sync()
+
+        # Refresh `band`, and make sure it has the correct data.
+        band.refresh().run_sync()
+        self.assertEqual(band.manager.name, "Guido!!!")
+
+    def test_multiple_layers(self) -> None:
+        """
+        Make sure ``refresh`` works when ``prefetch`` was used to fetch objects
+        multiple layers deep.
+        """
+        concert = (
+            Concert.objects(Concert.band_1._.manager)
+            .where(Concert.band_1._.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert concert is not None
+
+        # Modify the data in the database.
+        self.manager.name = "Guido!!!"
+        self.manager.save().run_sync()
+
+        concert.refresh().run_sync()
+        self.assertEqual(concert.band_1.manager.name, "Guido!!!")
+
+    def test_updated_foreign_key(self) -> None:
+        """
+        If a foreign key now references a different row, make sure this
+        is refreshed correctly.
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Assign a different manager to the band
+        new_manager = Manager({Manager.name: "New Manager"})
+        new_manager.save().run_sync()
+        Band.update({Band.manager: new_manager.id}, force=True).run_sync()
+
+        # Refresh `band`, and make sure it references the new manager.
+        band.refresh().run_sync()
+        self.assertEqual(band.manager.id, new_manager.id)
+        self.assertEqual(band.manager.name, "New Manager")
+
+    def test_foreign_key_set_to_null(self):
+        """
+        Make sure that if the foreign key was set to null, that ``refresh``
+        sets the nested object to ``None``.
+        """
+        band = (
+            Band.objects(Band.manager)
+            .where(Band.name == "Pythonistas")
+            .first()
+            .run_sync()
+        )
+        assert band is not None
+
+        # Remove the manager from band
+        Band.update({Band.manager: None}, force=True).run_sync()
+
+        # Refresh `band`, and make sure the foreign key value is now `None`,
+        # instead of a nested object.
+        band.refresh().run_sync()
+        self.assertIsNone(band.manager)
+
+    def test_exception(self) -> None:
+        """
+        We don't currently let the user refresh specific fields from nested
+        objects - an exception should be raised.
+        """
+        with self.assertRaises(ValueError):
+            self.concert.refresh(columns=[Concert.band_1._.manager]).run_sync()
+
+        # Shouldn't raise an exception:
+        self.concert.refresh(columns=[Concert.band_1]).run_sync()
+
+
+class TestRefreshWithLoadJSON(TableTest):
+
+    tables = [RecordingStudio]
+
+    def setUp(self):
+        super().setUp()
+
+        self.recording_studio = RecordingStudio(
+            {RecordingStudio.facilities: {"piano": True}}
+        )
+        self.recording_studio.save().run_sync()
+
+    def test_load_json(self):
+        """
+        Make sure we can refresh an object, and load the JSON as a Python
+        object.
+        """
+        RecordingStudio.update(
+            {RecordingStudio.facilities: {"electric piano": True}},
+            force=True,
+        ).run_sync()
+
+        # Refresh without load_json:
+        self.recording_studio.refresh().run_sync()
+
+        self.assertEqual(
+            # Remove the white space, because some versions of Python add
+            # whitespace around JSON, and some don't.
+            self.recording_studio.facilities.replace(" ", ""),
+            '{"electricpiano":true}',
+        )
+
+        # Refresh with load_json:
+        self.recording_studio.refresh(load_json=True).run_sync()
+
+        self.assertDictEqual(
+            t.cast(dict, self.recording_studio.facilities),
+            {"electric piano": True},
+        )