piccolo 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.8.0"
+__VERSION__ = "1.9.0"

piccolo/columns/base.py

@@ -830,7 +830,11 @@ class Column(Selectable):
             engine_type=engine_type, with_alias=False
         )
 
-    def get_sql_value(self, value: t.Any) -> t.Any:
+    def get_sql_value(
+        self,
+        value: t.Any,
+        delimiter: str = "'",
+    ) -> str:
         """
         When using DDL statements, we can't parameterise the values. An example
         is when setting the default for a column. So we have to convert from
@@ -839,11 +843,18 @@ class Column(Selectable):
 
         :param value:
             The Python value to convert to a string usable in a DDL statement
-            e.g. 1.
+            e.g. ``1``.
+        :param delimiter:
+            The string returned by this function is wrapped in delimiters,
+            ready to be added to a DDL statement. For example:
+            ``'hello world'``.
         :returns:
-            The string usable in the DDL statement e.g. '1'.
+            The string usable in the DDL statement e.g. ``'1'``.
 
         """
+        from piccolo.engine.sqlite import ADAPTERS as sqlite_adapters
+
+        # Common across all DB engines
         if isinstance(value, Default):
             return getattr(value, self._meta.engine_type)
         elif value is None:
@@ -851,37 +862,52 @@ class Column(Selectable):
         elif isinstance(value, (float, decimal.Decimal)):
             return str(value)
         elif isinstance(value, str):
-            return f"'{value}'"
+            return f"{delimiter}{value}{delimiter}"
         elif isinstance(value, bool):
             return str(value).lower()
-        elif isinstance(value, datetime.datetime):
-            return f"'{value.isoformat().replace('T', ' ')}'"
-        elif isinstance(value, datetime.date):
-            return f"'{value.isoformat()}'"
-        elif isinstance(value, datetime.time):
-            return f"'{value.isoformat()}'"
-        elif isinstance(value, datetime.timedelta):
-            interval = IntervalCustom.from_timedelta(value)
-            return getattr(interval, self._meta.engine_type)
         elif isinstance(value, bytes):
-            return f"'{value.hex()}'"
-        elif isinstance(value, uuid.UUID):
-            return f"'{value}'"
-        elif isinstance(value, list):
-            # Convert to the array syntax.
-            return (
-                "'{"
-                + ", ".join(
-                    (
-                        f'"{i}"'
-                        if isinstance(i, str)
-                        else str(self.get_sql_value(i))
+            return f"{delimiter}{value.hex()}{delimiter}"
+
+        # SQLite specific
+        if self._meta.engine_type == "sqlite":
+            if adapter := sqlite_adapters.get(type(value)):
+                sqlite_value = adapter(value)
+                return (
+                    f"{delimiter}{sqlite_value}{delimiter}"
+                    if isinstance(sqlite_value, str)
+                    else sqlite_value
+                )
+
+        # Postgres and Cockroach
+        if self._meta.engine_type in ["postgres", "cockroach"]:
+            if isinstance(value, datetime.datetime):
+                return f"{delimiter}{value.isoformat().replace('T', ' ')}{delimiter}"  # noqa: E501
+            elif isinstance(value, datetime.date):
+                return f"{delimiter}{value.isoformat()}{delimiter}"
+            elif isinstance(value, datetime.time):
+                return f"{delimiter}{value.isoformat()}{delimiter}"
+            elif isinstance(value, datetime.timedelta):
+                interval = IntervalCustom.from_timedelta(value)
+                return getattr(interval, self._meta.engine_type)
+            elif isinstance(value, uuid.UUID):
+                return f"{delimiter}{value}{delimiter}"
+            elif isinstance(value, list):
+                # Convert to the array syntax.
+                return (
+                    delimiter
+                    + "{"
+                    + ",".join(
+                        self.get_sql_value(
+                            i,
+                            delimiter="" if isinstance(i, list) else '"',
+                        )
+                        for i in value
                     )
-                    for i in value
+                    + "}"
+                    + delimiter
                 )
-            ) + "}'"
-        else:
-            return value
+
+        return str(value)
 
     @property
     def column_type(self):

piccolo/columns/defaults/base.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 import typing as t
-from abc import ABC, abstractmethod, abstractproperty
+from abc import ABC, abstractmethod
 
 from piccolo.utils.repr import repr_class_instance
 
 
 class Default(ABC):
-    @abstractproperty
+    @property
+    @abstractmethod
     def postgres(self) -> str:
         pass
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def sqlite(self) -> str:
         pass
 

piccolo/query/functions/__init__.py

@@ -1,17 +1,22 @@
 from .aggregate import Avg, Count, Max, Min, Sum
+from .math import Abs, Ceil, Floor, Round
 from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
 from .type_conversion import Cast
 
 __all__ = (
+    "Abs",
     "Avg",
     "Cast",
+    "Ceil",
     "Count",
+    "Floor",
     "Length",
     "Lower",
     "Ltrim",
     "Max",
     "Min",
     "Reverse",
+    "Round",
     "Rtrim",
     "Sum",
     "Upper",

piccolo/query/functions/math.py

@@ -0,0 +1,48 @@
+"""
+These functions mirror their counterparts in the Postgresql docs:
+
+https://www.postgresql.org/docs/current/functions-math.html
+
+"""
+
+from .base import Function
+
+
+class Abs(Function):
+    """
+    Absolute value.
+    """
+
+    function_name = "ABS"
+
+
+class Ceil(Function):
+    """
+    Nearest integer greater than or equal to argument.
+    """
+
+    function_name = "CEIL"
+
+
+class Floor(Function):
+    """
+    Nearest integer less than or equal to argument.
+    """
+
+    function_name = "FLOOR"
+
+
+class Round(Function):
+    """
+    Rounds to nearest integer.
+    """
+
+    function_name = "ROUND"
+
+
+__all__ = (
+    "Abs",
+    "Ceil",
+    "Floor",
+    "Round",
+)

piccolo/querystring.py

@@ -282,12 +282,30 @@ class QueryString(Selectable):
     def __le__(self, value) -> QueryString:
         return QueryString("{} <= {}", self, value)
 
+    def __truediv__(self, value) -> QueryString:
+        return QueryString("{} / {}", self, value)
+
+    def __mul__(self, value) -> QueryString:
+        return QueryString("{} * {}", self, value)
+
+    def __pow__(self, value) -> QueryString:
+        return QueryString("{} ^ {}", self, value)
+
+    def __mod__(self, value) -> QueryString:
+        return QueryString("{} % {}", self, value)
+
     def is_in(self, value) -> QueryString:
         return QueryString("{} IN {}", self, value)
 
     def not_in(self, value) -> QueryString:
         return QueryString("{} NOT IN {}", self, value)
 
+    def like(self, value: str) -> QueryString:
+        return QueryString("{} LIKE {}", self, value)
+
+    def ilike(self, value: str) -> QueryString:
+        return QueryString("{} ILIKE {}", self, value)
+
 
 class Unquoted(QueryString):
     """

piccolo/schema.py

@@ -13,7 +13,8 @@ class SchemaDDLBase(abc.ABC):
 
     db: Engine
 
-    @abc.abstractproperty
+    @property
+    @abc.abstractmethod
     def ddl(self) -> str:
         pass
 

{piccolo-1.8.0.dist-info → piccolo-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.8.0
+Version: 1.9.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.8.0.dist-info → piccolo-1.9.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-piccolo/__init__.py,sha256=mRuIID3n4xkvLnANZAYlJEC5QgpM7rOXi2uxp1_jzHg,22
+piccolo/__init__.py,sha256=Gh6i3k_DUgCHpLwjrSRIPrDHNQum_zcZ2tZi3wiqRkU,22
 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=Mn00hb4HGOe9MIR7WOhJ3qO1uNex21zj0m2heOeDvZk,9057
-piccolo/schema.py,sha256=aWPuZxEulgBRD5NTqKN-RAZchxu-PoIrn0iFrWGZuq4,7731
+piccolo/querystring.py,sha256=_3enTH0oBx77LfpS9UG_5OGp5fMxmu50Dod5s1Gn9mY,9655
+piccolo/schema.py,sha256=S_0dwyOVPx90wWbCOP_Y9YHWtb-2JCuAJWAoLkTbFbU,7743
 piccolo/table.py,sha256=DJT8jTgirPpzkydjSzaCgcG0DiC75XRtW_xtFqTyg80,49457
 piccolo/table_reflection.py,sha256=jrN1nHerDJ4tU09GtNN3hz7ap-7rXnSUjljFO6LB2H0,7094
 piccolo/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -115,7 +115,7 @@ piccolo/apps/user/piccolo_migrations/2020-06-11T21-38-55.py,sha256=JG_LFPrEljnSE
 piccolo/apps/user/piccolo_migrations/2021-04-30T16-14-15.py,sha256=Y_Dj4ROSxjnPsRDqcnpWeyk8UpF8c80T08_O2uq-GoA,1219
 piccolo/apps/user/piccolo_migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/columns/__init__.py,sha256=OYhO_n9anMiU9nL-K6ATq9FhAtm8RyMpqYQ7fTVbhxI,1120
-piccolo/columns/base.py,sha256=FuMLSplFuNoK919nkas2Fn4kZjmPLMmutc4cRtmLhyY,31378
+piccolo/columns/base.py,sha256=sgMiBvq-xLW6_W86g6XZTMc_3cskyeoMF6yIvIlnXsA,32487
 piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,723
 piccolo/columns/column_types.py,sha256=CzbNnP_VWvz6_r4aaRcMHiHZOaWHeq5IGaN8WJ7JGPA,81685
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
@@ -124,7 +124,7 @@ piccolo/columns/m2m.py,sha256=vRJZqBcBP3TQ9Mmb7UEqTgg0QoxIIjIu6JfGLAi4X8Q,14595
 piccolo/columns/readable.py,sha256=hganxUPfIK5ZXn-qgteBxsOJfBJucgr9U0QLsLFYcuI,1562
 piccolo/columns/reference.py,sha256=FqE9rpMBMwNNkKXR3Wi4ce-fyT2Vh4KM8YpdC21s6gg,3574
 piccolo/columns/defaults/__init__.py,sha256=7hpB13baEJgc1zbZjRKDFr-5hltxM2VGj8KnKfOiS8c,145
-piccolo/columns/defaults/base.py,sha256=kxh5jgU9G1zpcncmqISZgwMeHnNPBgNCvuqPPQYO_zs,1854
+piccolo/columns/defaults/base.py,sha256=kZ63QVI5nacQdVj2oZ_0Kr5KKtEZTkotKrFibUS6axk,1860
 piccolo/columns/defaults/date.py,sha256=7tW_tTfsnzU8LXn9Qkrtk8OPyi80SESa-dY_UMlNTp0,2455
 piccolo/columns/defaults/interval.py,sha256=QTx-iW0J5Eogv72_xXg8hWHEqbRx7jyTxrrV-eIq9HI,1947
 piccolo/columns/defaults/time.py,sha256=UEtfdMkn8YdlzyEmqO6DrVnuwZrYUrvG_gTJ-SOMmwk,2355
@@ -149,9 +149,10 @@ piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
 piccolo/query/base.py,sha256=G8Mwz0GcHY4Xs5Co9ubCNMI-3orfOsDdRDOnFRws7TU,15212
 piccolo/query/mixins.py,sha256=1RyhORDRwTZF9m_2uEgc6sOSd2uViXivBAaFN8geq5g,21982
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
-piccolo/query/functions/__init__.py,sha256=9ikQo6qPkCBaWSiuimEACWbYRk9KHoLboRsEC1VcSVw,312
+piccolo/query/functions/__init__.py,sha256=e-BEHlGR3JhE2efWG_rmXdURKL4Fa8tjdGmPsvH4kWo,403
 piccolo/query/functions/aggregate.py,sha256=OdjDjr_zyD4S9UbrZ2C3V5mz4OT2sIfAFAdTGr4WL54,4248
 piccolo/query/functions/base.py,sha256=Go2bg2r7GaVoyyX-wTb80WEQmtiU4OFYWQlq9eQ6Zcc,478
+piccolo/query/functions/math.py,sha256=2Wapq0lpXZh77z0uzXUhnOfmUkbkM0xjQ4tiyuCsbiE,661
 piccolo/query/functions/string.py,sha256=srxsQJFS6L4gPvFjvuAFQj7QtnCF7X6YoJNKARR2XP0,1236
 piccolo/query/functions/type_conversion.py,sha256=OYbZc6TEk6b5yTwCMw2rmZ-UiQiUiWZOyxwMLzUjXwE,2583
 piccolo/query/methods/__init__.py,sha256=tm4gLeV_obDqpgnouVjFbGubbaoJcqm_cbNd4LPo48Q,622
@@ -242,7 +243,7 @@ tests/apps/user/commands/test_change_permissions.py,sha256=uVKEiT1EKot3VA2TDETdQ
 tests/apps/user/commands/test_create.py,sha256=iJ3Tti62rHwvdcTwNXrc5JPam6vR1qxKRdMN456vm3o,2250
 tests/apps/user/commands/test_list.py,sha256=ipPfGdW6fH7q-Jc7JcYUvlioGmH9GQU0WImZGC2m-XQ,2840
 tests/columns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/columns/test_array.py,sha256=Kd8yy3C4cXJIgutY-cv0MrE4mvgr52qqVUdkcazW_uI,9298
+tests/columns/test_array.py,sha256=uElfAcJhuB0m9_O1qTgURbrwE2Php5Bc7IB9hyXoQ_Q,10772
 tests/columns/test_base.py,sha256=CTqCNcrqAJTjLXe3MCZgTczrmB3jcVRcOpU4FilpLoQ,3918
 tests/columns/test_bigint.py,sha256=a0B4y1H02ww5qaW574X2lyenbY6o29ztOhiaqybPC0c,1149
 tests/columns/test_boolean.py,sha256=kDESp6FnRtSZhuqIu0dBRwKMSpS5TFbbs3sz2MyZSs8,1720
@@ -253,6 +254,7 @@ tests/columns/test_date.py,sha256=lz3AF64CkQzulfniGs0fxuvbH2grR3pF2sxipXiyvHU,12
 tests/columns/test_db_column_name.py,sha256=v0QFOQp_atqzMB1n40simVwHeBDi5nyN1N2bSPX5k6w,7670
 tests/columns/test_defaults.py,sha256=rwlU1fXt3cCl7C51eLlZXqgWkE-K5W0pHvTrwkAKyCo,2896
 tests/columns/test_double_precision.py,sha256=CuobfnQnuwqAIuuOPoh2mKHnY9A7gZosoMIGpY-ubfE,639
+tests/columns/test_get_sql_value.py,sha256=mKgsInN374jzV99y9mg_ZiG-AvnJgz36SZi89xL7RZM,1768
 tests/columns/test_interval.py,sha256=SbeRgTBWPBL5_LYQUdaP3qyN6eTNtTJtu8JXWollhQw,2993
 tests/columns/test_json.py,sha256=ErGytVqMVO86YiqGmQIcqb2zUcAUY_ya-cY9tSKKXhQ,3920
 tests/columns/test_jsonb.py,sha256=7MeH0h2SJt_uCUL6D5-6DLTBPlaz6qKSJcnyhuwvzHg,6914
@@ -296,10 +298,15 @@ tests/query/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/query/test_await.py,sha256=imGazmG0l4qilveNPwsxvYQogFJtos4YB8N9iggPEFU,412
 tests/query/test_camelcase.py,sha256=AcL2gZera1GfpVJNpuKuh5ZBosNCY_ezPWh6-duU5vU,1765
 tests/query/test_freeze.py,sha256=p3iXqHzgV39YWlqzXtZvaDa7iKZaaaelOGX3UZ8CMf0,3887
-tests/query/test_functions.py,sha256=B_M-giOf1xGvdCaYgJdKWLSoV8vtTiRQtEyvL4-7eCY,6401
 tests/query/test_gather.py,sha256=okWANrBoh0Ut1RomWoffiWNpFqiITF6qti-Aa3uYtRk,730
-tests/query/test_querystring.py,sha256=hHljfdnOTlwIMs-7Q2yP5YekYXTT2It-Q-3mP6T9e58,880
+tests/query/test_querystring.py,sha256=QrqyjwUlFlf5LrsJ7DgjCruq811I0UvrDFPud6rfZNI,5019
 tests/query/test_slots.py,sha256=I9ZjAYqAJNSFAWg9UyAqy7bm-Z52KiyQ2C_yHk2qqqI,1010
+tests/query/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/query/functions/base.py,sha256=RLCzLT7iN_Z5DtIFZqVESTJGES2JKb8VDU25sv5OtN4,811
+tests/query/functions/test_functions.py,sha256=510fqRrOrAZ9NyFoZtlF6lIdiiLriWhZ7vvveWZ8rsc,1984
+tests/query/functions/test_math.py,sha256=Qw2MXqgY_y7vGd0bLtPhWW7HB3tJkot1o-Rh9nCmmBk,1273
+tests/query/functions/test_string.py,sha256=7yNkpWNBaIowzXTP_qbmQg-mJZLWrTk0lx2mgY1NIfA,825
+tests/query/functions/test_type_conversion.py,sha256=WeYR9UfJnbidle07-akQ1g9hFCd93qT8xUhDF3c58n4,3235
 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
@@ -356,9 +363,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.8.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.8.0.dist-info/METADATA,sha256=Uoe1LLvND5fOBdQKOSgFI1T047qzIlbICmwXV1zg7e4,5177
-piccolo-1.8.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
-piccolo-1.8.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.8.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.8.0.dist-info/RECORD,,
+piccolo-1.9.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.9.0.dist-info/METADATA,sha256=DPQmRGRjgG1-6bHmApuUOwew9PIbDzX1KOEbnyxqW20,5177
+piccolo-1.9.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
+piccolo-1.9.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.9.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.9.0.dist-info/RECORD,,

tests/columns/test_array.py

@@ -1,6 +1,8 @@
 import datetime
 from unittest import TestCase
 
+import pytest
+
 from piccolo.columns.column_types import (
     Array,
     BigInt,
@@ -10,8 +12,9 @@ from piccolo.columns.column_types import (
     Timestamp,
     Timestamptz,
 )
+from piccolo.querystring import QueryString
 from piccolo.table import Table
-from tests.base import engines_only, sqlite_only
+from tests.base import engines_only, engines_skip, sqlite_only
 
 
 class MyTable(Table):
@@ -40,12 +43,18 @@ class TestArray(TestCase):
     def tearDown(self):
         MyTable.alter().drop_table().run_sync()
 
-    @engines_only("postgres", "sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_storage(self):
         """
         Make sure data can be stored and retrieved.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 2, 3]).save().run_sync()
@@ -54,12 +63,19 @@ class TestArray(TestCase):
         assert row is not None
         self.assertEqual(row.value, [1, 2, 3])
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_index(self):
         """
         Indexes should allow individual array elements to be queried.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 2, 3]).save().run_sync()
@@ -68,66 +84,92 @@ class TestArray(TestCase):
             MyTable.select(MyTable.value[0]).first().run_sync(), {"value": 1}
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_all(self):
         """
         Make sure rows can be retrieved where all items in an array match a
         given value.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 1, 1]).save().run_sync()
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.all(1))
+            .where(MyTable.value.all(QueryString("{}::INTEGER", 1)))
             .first()
             .run_sync(),
             {"value": [1, 1, 1]},
         )
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.all(0))
+            .where(MyTable.value.all(QueryString("{}::INTEGER", 0)))
             .first()
             .run_sync(),
             None,
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_any(self):
         """
         Make sure rows can be retrieved where any items in an array match a
         given value.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
+
         MyTable(value=[1, 2, 3]).save().run_sync()
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.any(1))
+            .where(MyTable.value.any(QueryString("{}::INTEGER", 1)))
             .first()
             .run_sync(),
             {"value": [1, 2, 3]},
         )
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.any(0))
+            .where(MyTable.value.any(QueryString("{}::INTEGER", 0)))
             .first()
             .run_sync(),
             None,
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_cat(self):
         """
         Make sure values can be appended to an array.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 1, 1]).save().run_sync()
@@ -137,7 +179,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(), [{"id": 1, "value": [1, 1, 1, 2]}]
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2]}],
         )
 
         # Try plus symbol
@@ -147,7 +190,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(), [{"id": 1, "value": [1, 1, 1, 2, 3]}]
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2, 3]}],
         )
 
         # Make sure non-list values work
@@ -157,8 +201,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(),
-            [{"id": 1, "value": [1, 1, 1, 2, 3, 4]}],
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2, 3, 4]}],
         )
 
     @sqlite_only

tests/columns/test_get_sql_value.py

@@ -0,0 +1,66 @@
+import datetime
+from unittest import TestCase
+
+from tests.base import engines_only
+from tests.example_apps.music.tables import Band
+
+
+@engines_only("postgres", "cockroach")
+class TestArrayPostgres(TestCase):
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]),
+            '\'{"a","b","c"}\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]),
+            "'{1,2,3}'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]),
+            "'{1,2,3,{4,5,6}}'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'{\"08:00:00\"}'",
+        )
+
+
+@engines_only("sqlite")
+class TestArraySQLite(TestCase):
+    """
+    Note, we use ``.replace(" ", "")`` because we serialise arrays using
+    Python's json library, and there is inconsistency between Python versions
+    (some output ``["a", "b", "c"]``, and others ``["a","b","c"]``).
+    """
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]).replace(" ", ""),
+            '\'["a","b","c"]\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]).replace(" ", ""),
+            "'[1,2,3]'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]).replace(" ", ""),
+            "'[1,2,3,[4,5,6]]'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'[\"08:00:00\"]'",
+        )

tests/query/functions/base.py

@@ -0,0 +1,34 @@
+import typing as t
+from unittest import TestCase
+
+from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
+from tests.example_apps.music.tables import Band, Manager
+
+
+class FunctionTest(TestCase):
+    tables: t.List[t.Type[Table]]
+
+    def setUp(self) -> None:
+        create_db_tables_sync(*self.tables)
+
+    def tearDown(self) -> None:
+        drop_db_tables_sync(*self.tables)
+
+
+class BandTest(FunctionTest):
+    tables = [Band, Manager]
+
+    def setUp(self) -> None:
+        super().setUp()
+
+        manager = Manager({Manager.name: "Guido"})
+        manager.save().run_sync()
+
+        band = Band(
+            {
+                Band.name: "Pythonistas",
+                Band.manager: manager,
+                Band.popularity: 1000,
+            }
+        )
+        band.save().run_sync()

tests/query/functions/test_functions.py

@@ -0,0 +1,64 @@
+from piccolo.query.functions import Reverse, Upper
+from piccolo.querystring import QueryString
+from tests.base import engines_skip
+from tests.example_apps.music.tables import Band
+
+from .base import BandTest
+
+
+@engines_skip("sqlite")
+class TestNested(BandTest):
+    """
+    Skip the the test for SQLite, as it doesn't support ``Reverse``.
+    """
+
+    def test_nested(self):
+        """
+        Make sure we can nest functions.
+        """
+        response = Band.select(Upper(Reverse(Band.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "SATSINOHTYP"}])
+
+    def test_nested_with_joined_column(self):
+        """
+        Make sure nested functions can be used on a column from a joined table.
+        """
+        response = Band.select(Upper(Reverse(Band.manager._.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "ODIUG"}])
+
+    def test_nested_within_querystring(self):
+        """
+        If we wrap a function in a custom QueryString - make sure the columns
+        are still accessible, so joins are successful.
+        """
+        response = Band.select(
+            QueryString("CONCAT({}, '!')", Upper(Band.manager._.name)),
+        ).run_sync()
+
+        self.assertListEqual(response, [{"concat": "GUIDO!"}])
+
+
+class TestWhereClause(BandTest):
+
+    def test_where(self):
+        """
+        Make sure where clauses work with functions.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.name) == "PYTHONISTAS")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+    def test_where_with_joined_column(self):
+        """
+        Make sure where clauses work with functions, when a joined column is
+        used.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.manager._.name) == "GUIDO")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])

tests/query/functions/test_math.py

@@ -0,0 +1,39 @@
+import decimal
+
+from piccolo.columns import Numeric
+from piccolo.query.functions.math import Abs, Ceil, Floor, Round
+from piccolo.table import Table
+
+from .base import FunctionTest
+
+
+class Ticket(Table):
+    price = Numeric(digits=(5, 2))
+
+
+class TestMath(FunctionTest):
+
+    tables = [Ticket]
+
+    def setUp(self):
+        super().setUp()
+        self.ticket = Ticket({Ticket.price: decimal.Decimal("36.50")})
+        self.ticket.save().run_sync()
+
+    def test_floor(self):
+        response = Ticket.select(Floor(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("36.00")}])
+
+    def test_ceil(self):
+        response = Ticket.select(Ceil(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])
+
+    def test_abs(self):
+        self.ticket.price = decimal.Decimal("-1.50")
+        self.ticket.save().run_sync()
+        response = Ticket.select(Abs(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("1.50")}])
+
+    def test_round(self):
+        response = Ticket.select(Round(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])

tests/query/functions/test_string.py

@@ -0,0 +1,25 @@
+from piccolo.query.functions.string import Upper
+from tests.example_apps.music.tables import Band
+
+from .base import BandTest
+
+
+class TestUpperFunction(BandTest):
+
+    def test_column(self):
+        """
+        Make sure we can uppercase a column's value.
+        """
+        response = Band.select(Upper(Band.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "PYTHONISTAS"}])
+
+    def test_alias(self):
+        response = Band.select(Upper(Band.name, alias="name")).run_sync()
+        self.assertListEqual(response, [{"name": "PYTHONISTAS"}])
+
+    def test_joined_column(self):
+        """
+        Make sure we can uppercase a column's value from a joined table.
+        """
+        response = Band.select(Upper(Band.manager._.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "GUIDO"}])

tests/query/functions/test_type_conversion.py

@@ -0,0 +1,134 @@
+from piccolo.columns import Integer, Text, Varchar
+from piccolo.query.functions import Cast, Length
+from tests.example_apps.music.tables import Band, Manager
+
+from .base import BandTest
+
+
+class TestCast(BandTest):
+    def test_varchar(self):
+        """
+        Make sure that casting to ``Varchar`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Varchar(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_text(self):
+        """
+        Make sure that casting to ``Text`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Text(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_integer(self):
+        """
+        Make sure that casting to ``Integer`` works.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Cast(
+                Band.name,
+                as_type=Integer(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"name": 1111}],
+        )
+
+    def test_join(self):
+        """
+        Make sure that casting works with joins.
+        """
+        Manager.update({Manager.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Band.name,
+            Cast(
+                Band.manager.name,
+                as_type=Integer(),
+            ),
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "name": "Pythonistas",
+                    "manager.name": 1111,
+                }
+            ],
+        )
+
+    def test_nested_inner(self):
+        """
+        Make sure ``Cast`` can be passed into other functions.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Length(
+                Cast(
+                    Band.popularity,
+                    as_type=Varchar(),
+                )
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": 4}],
+        )
+
+    def test_nested_outer(self):
+        """
+        Make sure a querystring can be passed into ``Cast`` (meaning it can be
+        nested).
+        """
+        response = Band.select(
+            Cast(
+                Length(Band.name),
+                as_type=Varchar(),
+                alias="length",
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": str(len("Pythonistas"))}],
+        )
+
+    def test_where_clause(self):
+        """
+        Make sure ``Cast`` works in a where clause.
+        """
+        response = (
+            Band.select(Band.name, Band.popularity)
+            .where(Cast(Band.popularity, Varchar()) == "1000")
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response,
+            [{"name": "Pythonistas", "popularity": 1000}],
+        )

tests/query/test_querystring.py

@@ -1,6 +1,7 @@
 from unittest import TestCase
 
 from piccolo.querystring import QueryString
+from tests.base import postgres_only
 
 
 # TODO - add more extensive tests (increased nesting and argument count).
@@ -28,3 +29,138 @@ class TestQueryString(TestCase):
     def test_querystring_with_no_args(self):
         qs = QueryString("SELECT name FROM band")
         self.assertEqual(qs.compile_string(), ("SELECT name FROM band", []))
+
+
+@postgres_only
+class TestQueryStringOperators(TestCase):
+    """
+    Make sure basic operations can be used on ``QueryString``.
+    """
+
+    def test_add(self):
+        query = QueryString("SELECT price") + 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price + $1", [1]),
+        )
+
+    def test_multiply(self):
+        query = QueryString("SELECT price") * 2
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price * $1", [2]),
+        )
+
+    def test_divide(self):
+        query = QueryString("SELECT price") / 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price / $1", [1]),
+        )
+
+    def test_power(self):
+        query = QueryString("SELECT price") ** 2
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price ^ $1", [2]),
+        )
+
+    def test_subtract(self):
+        query = QueryString("SELECT price") - 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price - $1", [1]),
+        )
+
+    def test_modulus(self):
+        query = QueryString("SELECT price") % 1
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price % $1", [1]),
+        )
+
+    def test_like(self):
+        query = QueryString("strip(name)").like("Python%")
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("strip(name) LIKE $1", ["Python%"]),
+        )
+
+    def test_ilike(self):
+        query = QueryString("strip(name)").ilike("Python%")
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("strip(name) ILIKE $1", ["Python%"]),
+        )
+
+    def test_greater_than(self):
+        query = QueryString("SELECT price") > 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price > $1", [10]),
+        )
+
+    def test_greater_equal_than(self):
+        query = QueryString("SELECT price") >= 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price >= $1", [10]),
+        )
+
+    def test_less_than(self):
+        query = QueryString("SELECT price") < 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price < $1", [10]),
+        )
+
+    def test_less_equal_than(self):
+        query = QueryString("SELECT price") <= 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price <= $1", [10]),
+        )
+
+    def test_equals(self):
+        query = QueryString("SELECT price") == 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price = $1", [10]),
+        )
+
+    def test_not_equals(self):
+        query = QueryString("SELECT price") != 10
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price != $1", [10]),
+        )
+
+    def test_is_in(self):
+        query = QueryString("SELECT price").is_in([10, 20, 30])
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price IN $1", [[10, 20, 30]]),
+        )
+
+    def test_not_in(self):
+        query = QueryString("SELECT price").not_in([10, 20, 30])
+        self.assertIsInstance(query, QueryString)
+        self.assertEqual(
+            query.compile_string(),
+            ("SELECT price NOT IN $1", [[10, 20, 30]]),
+        )

tests/query/test_functions.py

@@ -1,238 +0,0 @@
-from unittest import TestCase
-
-from piccolo.columns import Integer, Text, Varchar
-from piccolo.query.functions import Cast, Length, Reverse, Upper
-from piccolo.querystring import QueryString
-from piccolo.table import create_db_tables_sync, drop_db_tables_sync
-from tests.base import engines_skip
-from tests.example_apps.music.tables import Band, Manager
-
-
-class FunctionTest(TestCase):
-    tables = (Band, Manager)
-
-    def setUp(self) -> None:
-        create_db_tables_sync(*self.tables)
-
-        manager = Manager({Manager.name: "Guido"})
-        manager.save().run_sync()
-
-        band = Band(
-            {
-                Band.name: "Pythonistas",
-                Band.manager: manager,
-                Band.popularity: 1000,
-            }
-        )
-        band.save().run_sync()
-
-    def tearDown(self) -> None:
-        drop_db_tables_sync(*self.tables)
-
-
-class TestUpperFunction(FunctionTest):
-
-    def test_column(self):
-        """
-        Make sure we can uppercase a column's value.
-        """
-        response = Band.select(Upper(Band.name)).run_sync()
-        self.assertListEqual(response, [{"upper": "PYTHONISTAS"}])
-
-    def test_alias(self):
-        response = Band.select(Upper(Band.name, alias="name")).run_sync()
-        self.assertListEqual(response, [{"name": "PYTHONISTAS"}])
-
-    def test_joined_column(self):
-        """
-        Make sure we can uppercase a column's value from a joined table.
-        """
-        response = Band.select(Upper(Band.manager._.name)).run_sync()
-        self.assertListEqual(response, [{"upper": "GUIDO"}])
-
-
-@engines_skip("sqlite")
-class TestNested(FunctionTest):
-    """
-    Skip the the test for SQLite, as it doesn't support ``Reverse``.
-    """
-
-    def test_nested(self):
-        """
-        Make sure we can nest functions.
-        """
-        response = Band.select(Upper(Reverse(Band.name))).run_sync()
-        self.assertListEqual(response, [{"upper": "SATSINOHTYP"}])
-
-    def test_nested_with_joined_column(self):
-        """
-        Make sure nested functions can be used on a column from a joined table.
-        """
-        response = Band.select(Upper(Reverse(Band.manager._.name))).run_sync()
-        self.assertListEqual(response, [{"upper": "ODIUG"}])
-
-    def test_nested_within_querystring(self):
-        """
-        If we wrap a function in a custom QueryString - make sure the columns
-        are still accessible, so joins are successful.
-        """
-        response = Band.select(
-            QueryString("CONCAT({}, '!')", Upper(Band.manager._.name)),
-        ).run_sync()
-
-        self.assertListEqual(response, [{"concat": "GUIDO!"}])
-
-
-class TestWhereClause(FunctionTest):
-
-    def test_where(self):
-        """
-        Make sure where clauses work with functions.
-        """
-        response = (
-            Band.select(Band.name)
-            .where(Upper(Band.name) == "PYTHONISTAS")
-            .run_sync()
-        )
-        self.assertListEqual(response, [{"name": "Pythonistas"}])
-
-    def test_where_with_joined_column(self):
-        """
-        Make sure where clauses work with functions, when a joined column is
-        used.
-        """
-        response = (
-            Band.select(Band.name)
-            .where(Upper(Band.manager._.name) == "GUIDO")
-            .run_sync()
-        )
-        self.assertListEqual(response, [{"name": "Pythonistas"}])
-
-
-class TestCast(FunctionTest):
-    def test_varchar(self):
-        """
-        Make sure that casting to ``Varchar`` works.
-        """
-        response = Band.select(
-            Cast(
-                Band.popularity,
-                as_type=Varchar(),
-            )
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [{"popularity": "1000"}],
-        )
-
-    def test_text(self):
-        """
-        Make sure that casting to ``Text`` works.
-        """
-        response = Band.select(
-            Cast(
-                Band.popularity,
-                as_type=Text(),
-            )
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [{"popularity": "1000"}],
-        )
-
-    def test_integer(self):
-        """
-        Make sure that casting to ``Integer`` works.
-        """
-        Band.update({Band.name: "1111"}, force=True).run_sync()
-
-        response = Band.select(
-            Cast(
-                Band.name,
-                as_type=Integer(),
-            )
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [{"name": 1111}],
-        )
-
-    def test_join(self):
-        """
-        Make sure that casting works with joins.
-        """
-        Manager.update({Manager.name: "1111"}, force=True).run_sync()
-
-        response = Band.select(
-            Band.name,
-            Cast(
-                Band.manager.name,
-                as_type=Integer(),
-            ),
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [
-                {
-                    "name": "Pythonistas",
-                    "manager.name": 1111,
-                }
-            ],
-        )
-
-    def test_nested_inner(self):
-        """
-        Make sure ``Cast`` can be passed into other functions.
-        """
-        Band.update({Band.name: "1111"}, force=True).run_sync()
-
-        response = Band.select(
-            Length(
-                Cast(
-                    Band.popularity,
-                    as_type=Varchar(),
-                )
-            )
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [{"length": 4}],
-        )
-
-    def test_nested_outer(self):
-        """
-        Make sure a querystring can be passed into ``Cast`` (meaning it can be
-        nested).
-        """
-        response = Band.select(
-            Cast(
-                Length(Band.name),
-                as_type=Varchar(),
-                alias="length",
-            )
-        ).run_sync()
-
-        self.assertListEqual(
-            response,
-            [{"length": str(len("Pythonistas"))}],
-        )
-
-    def test_where_clause(self):
-        """
-        Make sure ``Cast`` works in a where clause.
-        """
-        response = (
-            Band.select(Band.name, Band.popularity)
-            .where(Cast(Band.popularity, Varchar()) == "1000")
-            .run_sync()
-        )
-
-        self.assertListEqual(
-            response,
-            [{"name": "Pythonistas", "popularity": 1000}],
-        )