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

piccolo/__init__.py

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

piccolo/columns/base.py

@@ -201,6 +201,10 @@ class ColumnMeta:
             )
         return self._table
 
+    @table.setter
+    def table(self, value: t.Type[Table]):
+        self._table = value
+
     ###########################################################################
 
     # Used by Foreign Keys:

piccolo/columns/column_types.py

@@ -2532,7 +2532,14 @@ class Array(Column):
         if engine_type in ("postgres", "cockroach"):
             return f"{self.base_column.column_type}[]"
         elif engine_type == "sqlite":
-            return "ARRAY"
+            inner_column = self._get_inner_column()
+            return (
+                f"ARRAY_{inner_column.column_type}"
+                if isinstance(
+                    inner_column, (Date, Timestamp, Timestamptz, Time)
+                )
+                else "ARRAY"
+            )
         raise Exception("Unrecognized engine type")
 
     def _setup_base_column(self, table_class: t.Type[Table]):
@@ -2564,6 +2571,23 @@ class Array(Column):
         else:
             return start + 1
 
+    def _get_inner_column(self) -> Column:
+        """
+        A helper function to get the innermost ``Column`` for the array. For
+        example::
+
+            >>> Array(Varchar())._get_inner_column()
+            Varchar
+
+            >>> Array(Array(Varchar()))._get_inner_column()
+            Varchar
+
+        """
+        if isinstance(self.base_column, Array):
+            return self.base_column._get_inner_column()
+        else:
+            return self.base_column
+
     def _get_inner_value_type(self) -> t.Type:
         """
         A helper function to get the innermost value type for the array. For
@@ -2576,10 +2600,7 @@ class Array(Column):
             str
 
         """
-        if isinstance(self.base_column, Array):
-            return self.base_column._get_inner_value_type()
-        else:
-            return self.base_column.value_type
+        return self._get_inner_column().value_type
 
     def __getitem__(self, value: int) -> Array:
         """

piccolo/engine/sqlite.py

@@ -9,6 +9,7 @@ import typing as t
 import uuid
 from dataclasses import dataclass
 from decimal import Decimal
+from functools import partial, wraps
 
 from piccolo.engine.base import Batch, Engine, validate_savepoint_name
 from piccolo.engine.exceptions import TransactionError
@@ -35,14 +36,14 @@ if t.TYPE_CHECKING:  # pragma: no cover
 # In
 
 
-def convert_numeric_in(value):
+def convert_numeric_in(value: Decimal) -> float:
     """
     Convert any Decimal values into floats.
     """
     return float(value)
 
 
-def convert_uuid_in(value) -> str:
+def convert_uuid_in(value: uuid.UUID) -> str:
     """
     Converts the UUID value being passed into sqlite.
     """
@@ -56,7 +57,7 @@ def convert_time_in(value: datetime.time) -> str:
     return value.isoformat()
 
 
-def convert_date_in(value: datetime.date):
+def convert_date_in(value: datetime.date) -> str:
     """
     Converts the date value being passed into sqlite.
     """
@@ -74,122 +75,235 @@ def convert_datetime_in(value: datetime.datetime) -> str:
     return str(value)
 
 
-def convert_timedelta_in(value: datetime.timedelta):
+def convert_timedelta_in(value: datetime.timedelta) -> float:
     """
     Converts the timedelta value being passed into sqlite.
     """
     return value.total_seconds()
 
 
-def convert_array_in(value: list):
+def convert_array_in(value: list) -> str:
     """
-    Converts a list value into a string.
+    Converts a list value into a string (it handles nested lists, and type like
+    dateime/ time / date which aren't usually JSON serialisable.).
+
     """
-    if value and type(value[0]) not in [str, int, float, list]:
-        raise ValueError("Can only serialise str, int, float, and list.")
 
-    return dump_json(value)
+    def serialise(data: list):
+        output = []
+
+        for item in data:
+            if isinstance(item, list):
+                output.append(serialise(item))
+            elif isinstance(
+                item, (datetime.datetime, datetime.time, datetime.date)
+            ):
+                if adapter := ADAPTERS.get(type(item)):
+                    output.append(adapter(item))
+                else:
+                    raise ValueError("The adapter wasn't found.")
+            elif item is None or isinstance(item, (str, int, float, list)):
+                # We can safely JSON serialise these.
+                output.append(item)
+            else:
+                raise ValueError("We can't currently serialise this value.")
+
+        return output
+
+    return dump_json(serialise(value))
+
+
+###############################################################################
+
+# Register adapters
+
+ADAPTERS: t.Dict[t.Type, t.Callable[[t.Any], t.Any]] = {
+    Decimal: convert_numeric_in,
+    uuid.UUID: convert_uuid_in,
+    datetime.time: convert_time_in,
+    datetime.date: convert_date_in,
+    datetime.datetime: convert_datetime_in,
+    datetime.timedelta: convert_timedelta_in,
+    list: convert_array_in,
+}
 
+for value_type, adapter in ADAPTERS.items():
+    sqlite3.register_adapter(value_type, adapter)
+
+###############################################################################
 
 # Out
 
 
-def convert_numeric_out(value: bytes) -> Decimal:
+def decode_to_string(converter: t.Callable[[str], t.Any]):
+    """
+    This means we can use our converters with string and bytes. They are
+    passed bytes when used directly via SQLite, and are passed strings when
+    used by the array converters.
+    """
+
+    @wraps(converter)
+    def wrapper(value: t.Union[str, bytes]) -> t.Any:
+        if isinstance(value, bytes):
+            return converter(value.decode("utf8"))
+        elif isinstance(value, str):
+            return converter(value)
+        else:
+            raise ValueError("Unsupported type")
+
+    return wrapper
+
+
+@decode_to_string
+def convert_numeric_out(value: str) -> Decimal:
     """
     Convert float values into Decimals.
     """
-    return Decimal(value.decode("ascii"))
+    return Decimal(value)
 
 
-def convert_int_out(value: bytes) -> int:
+@decode_to_string
+def convert_int_out(value: str) -> int:
     """
     Make sure Integer values are actually of type int.
     """
     return int(float(value))
 
 
-def convert_uuid_out(value: bytes) -> uuid.UUID:
+@decode_to_string
+def convert_uuid_out(value: str) -> uuid.UUID:
     """
     If the value is a uuid, convert it to a UUID instance.
     """
-    return uuid.UUID(value.decode("utf8"))
+    return uuid.UUID(value)
 
 
-def convert_date_out(value: bytes) -> datetime.date:
-    return datetime.date.fromisoformat(value.decode("utf8"))
+@decode_to_string
+def convert_date_out(value: str) -> datetime.date:
+    return datetime.date.fromisoformat(value)
 
 
-def convert_time_out(value: bytes) -> datetime.time:
+@decode_to_string
+def convert_time_out(value: str) -> datetime.time:
     """
     If the value is a time, convert it to a UUID instance.
     """
-    return datetime.time.fromisoformat(value.decode("utf8"))
+    return datetime.time.fromisoformat(value)
 
 
-def convert_seconds_out(value: bytes) -> datetime.timedelta:
+@decode_to_string
+def convert_seconds_out(value: str) -> datetime.timedelta:
     """
     If the value is from a seconds column, convert it to a timedelta instance.
     """
-    return datetime.timedelta(seconds=float(value.decode("utf8")))
+    return datetime.timedelta(seconds=float(value))
 
 
-def convert_boolean_out(value: bytes) -> bool:
+@decode_to_string
+def convert_boolean_out(value: str) -> bool:
     """
     If the value is from a boolean column, convert it to a bool value.
     """
-    _value = value.decode("utf8")
-    return _value == "1"
+    return value == "1"
 
 
-def convert_timestamp_out(value: bytes) -> datetime.datetime:
+@decode_to_string
+def convert_timestamp_out(value: str) -> datetime.datetime:
     """
     If the value is from a timestamp column, convert it to a datetime value.
     """
-    return datetime.datetime.fromisoformat(value.decode("utf8"))
+    return datetime.datetime.fromisoformat(value)
 
 
-def convert_timestamptz_out(value: bytes) -> datetime.datetime:
+@decode_to_string
+def convert_timestamptz_out(value: str) -> datetime.datetime:
     """
     If the value is from a timestamptz column, convert it to a datetime value,
     with a timezone of UTC.
     """
-    _value = datetime.datetime.fromisoformat(value.decode("utf8"))
-    _value = _value.replace(tzinfo=datetime.timezone.utc)
-    return _value
+    return datetime.datetime.fromisoformat(value).replace(
+        tzinfo=datetime.timezone.utc
+    )
 
 
-def convert_array_out(value: bytes) -> t.List:
+@decode_to_string
+def convert_array_out(value: str) -> t.List:
     """
     If the value if from an array column, deserialise the string back into a
     list.
     """
-    return load_json(value.decode("utf8"))
-
-
-def convert_M2M_out(value: bytes) -> t.List:
-    _value = value.decode("utf8")
-    return _value.split(",")
-
-
-sqlite3.register_converter("Numeric", convert_numeric_out)
-sqlite3.register_converter("Integer", convert_int_out)
-sqlite3.register_converter("UUID", convert_uuid_out)
-sqlite3.register_converter("Date", convert_date_out)
-sqlite3.register_converter("Time", convert_time_out)
-sqlite3.register_converter("Seconds", convert_seconds_out)
-sqlite3.register_converter("Boolean", convert_boolean_out)
-sqlite3.register_converter("Timestamp", convert_timestamp_out)
-sqlite3.register_converter("Timestamptz", convert_timestamptz_out)
-sqlite3.register_converter("Array", convert_array_out)
-sqlite3.register_converter("M2M", convert_M2M_out)
-
-sqlite3.register_adapter(Decimal, convert_numeric_in)
-sqlite3.register_adapter(uuid.UUID, convert_uuid_in)
-sqlite3.register_adapter(datetime.time, convert_time_in)
-sqlite3.register_adapter(datetime.date, convert_date_in)
-sqlite3.register_adapter(datetime.datetime, convert_datetime_in)
-sqlite3.register_adapter(datetime.timedelta, convert_timedelta_in)
-sqlite3.register_adapter(list, convert_array_in)
+    return load_json(value)
+
+
+def convert_complex_array_out(value: bytes, converter: t.Callable):
+    """
+    This is used to handle arrays of things like timestamps, which we can't
+    just load from JSON without doing additional work to convert the elements
+    back into Python objects.
+    """
+    parsed = load_json(value.decode("utf8"))
+
+    def convert_list(list_value: t.List):
+        output = []
+
+        for value in list_value:
+            if isinstance(value, list):
+                # For nested arrays
+                output.append(convert_list(value))
+            elif isinstance(value, str):
+                output.append(converter(value))
+            else:
+                output.append(value)
+
+        return output
+
+    if isinstance(parsed, list):
+        return convert_list(parsed)
+    else:
+        return parsed
+
+
+@decode_to_string
+def convert_M2M_out(value: str) -> t.List:
+    return value.split(",")
+
+
+###############################################################################
+# Register the basic converters
+
+CONVERTERS = {
+    "NUMERIC": convert_numeric_out,
+    "INTEGER": convert_int_out,
+    "UUID": convert_uuid_out,
+    "DATE": convert_date_out,
+    "TIME": convert_time_out,
+    "SECONDS": convert_seconds_out,
+    "BOOLEAN": convert_boolean_out,
+    "TIMESTAMP": convert_timestamp_out,
+    "TIMESTAMPTZ": convert_timestamptz_out,
+    "M2M": convert_M2M_out,
+}
+
+for column_name, converter in CONVERTERS.items():
+    sqlite3.register_converter(column_name, converter)
+
+###############################################################################
+# Register the array converters
+
+# The ARRAY column type handles values which can be easily serialised to and
+# from JSON.
+sqlite3.register_converter("ARRAY", convert_array_out)
+
+# We have special column types for arrays of timestamps etc, as simply loading
+# the JSON isn't sufficient.
+for column_name in ("TIMESTAMP", "TIMESTAMPTZ", "DATE", "TIME"):
+    sqlite3.register_converter(
+        f"ARRAY_{column_name}",
+        partial(
+            convert_complex_array_out,
+            converter=CONVERTERS[column_name],
+        ),
+    )
 
 ###############################################################################
 

piccolo/query/functions/__init__.py

@@ -1,8 +1,10 @@
 from .aggregate import Avg, Count, Max, Min, Sum
 from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
+from .type_conversion import Cast
 
 __all__ = (
     "Avg",
+    "Cast",
     "Count",
     "Length",
     "Lower",

piccolo/query/functions/aggregate.py

@@ -12,17 +12,17 @@ class Avg(Function):
 
     .. code-block:: python
 
-        await Band.select(Avg(Band.popularity)).run()
+        await Band.select(Avg(Band.popularity))
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Avg(Band.popularity, alias="popularity_avg")
-        ).run()
+        )
 
         await Band.select(
             Avg(Band.popularity).as_alias("popularity_avg")
-        ).run()
+        )
 
     """
 
@@ -103,17 +103,17 @@ class Min(Function):
 
     .. code-block:: python
 
-        await Band.select(Min(Band.popularity)).run()
+        await Band.select(Min(Band.popularity))
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Min(Band.popularity, alias="popularity_min")
-        ).run()
+        )
 
         await Band.select(
             Min(Band.popularity).as_alias("popularity_min")
-        ).run()
+        )
 
     """
 
@@ -128,17 +128,17 @@ class Max(Function):
 
         await Band.select(
             Max(Band.popularity)
-        ).run()
+        )
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Max(Band.popularity, alias="popularity_max")
-        ).run()
+        )
 
         await Band.select(
             Max(Band.popularity).as_alias("popularity_max")
-        ).run()
+        )
 
     """
 
@@ -153,17 +153,17 @@ class Sum(Function):
 
         await Band.select(
             Sum(Band.popularity)
-        ).run()
+        )
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Sum(Band.popularity, alias="popularity_sum")
-        ).run()
+        )
 
         await Band.select(
             Sum(Band.popularity).as_alias("popularity_sum")
-        ).run()
+        )
 
     """
 

piccolo/query/functions/type_conversion.py

@@ -0,0 +1,82 @@
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.querystring import QueryString
+
+
+class Cast(QueryString):
+    def __init__(
+        self,
+        identifier: t.Union[Column, QueryString],
+        as_type: Column,
+        alias: t.Optional[str] = None,
+    ):
+        """
+        Cast a value to a different type. For example::
+
+            >>> from piccolo.query.functions import Cast
+
+            >>> await Concert.select(
+            ...     Cast(Concert.starts, Time(), "start_time")
+            ... )
+            [{"start_time": datetime.time(19, 0)}]
+
+        :param identifier:
+            Identifies what is being converted (e.g. a column).
+        :param as_type:
+            The type to be converted to.
+
+        """
+        # Make sure the identifier is a supported type.
+
+        if not isinstance(identifier, (Column, QueryString)):
+            raise ValueError(
+                "The identifier is an unsupported type - only Column and "
+                "QueryString instances are allowed."
+            )
+
+        #######################################################################
+        # Convert `as_type` to a string which can be used in the query.
+
+        if not isinstance(as_type, Column):
+            raise ValueError("The `as_type` value must be a Column instance.")
+
+        # We need to give the column a reference to a table, and hence
+        # the database engine, as the column type is sometimes dependent
+        # on which database is being used.
+        from piccolo.table import Table, create_table_class
+
+        table: t.Optional[t.Type[Table]] = None
+
+        if isinstance(identifier, Column):
+            table = identifier._meta.table
+        elif isinstance(identifier, QueryString):
+            table = (
+                identifier.columns[0]._meta.table
+                if identifier.columns
+                else None
+            )
+
+        as_type._meta.table = table or create_table_class("Table")
+        as_type_string = as_type.column_type
+
+        #######################################################################
+        # Preserve the original alias from the column.
+
+        if isinstance(identifier, Column):
+            alias = (
+                alias
+                or identifier._alias
+                or identifier._meta.get_default_alias()
+            )
+
+        #######################################################################
+
+        super().__init__(
+            f"CAST({{}} AS {as_type_string})",
+            identifier,
+            alias=alias,
+        )
+
+
+__all__ = ("Cast",)

piccolo/querystring.py

@@ -270,6 +270,18 @@ class QueryString(Selectable):
     def __sub__(self, value) -> QueryString:
         return QueryString("{} - {}", self, value)
 
+    def __gt__(self, value) -> QueryString:
+        return QueryString("{} > {}", self, value)
+
+    def __ge__(self, value) -> QueryString:
+        return QueryString("{} >= {}", self, value)
+
+    def __lt__(self, value) -> QueryString:
+        return QueryString("{} < {}", self, value)
+
+    def __le__(self, value) -> QueryString:
+        return QueryString("{} <= {}", self, value)
+
     def is_in(self, value) -> QueryString:
         return QueryString("{} IN {}", self, value)
 

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

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

@@ -1,8 +1,8 @@
-piccolo/__init__.py,sha256=goBemmcyJmGj3ijZ-wUC400jA5cZbAGtScaxWt1tqms,22
+piccolo/__init__.py,sha256=mRuIID3n4xkvLnANZAYlJEC5QgpM7rOXi2uxp1_jzHg,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=6uxfoCk7sj6bs_mDNV8W4ScgdG-h5wl1Y9HMlVW2abM,8671
+piccolo/querystring.py,sha256=Mn00hb4HGOe9MIR7WOhJ3qO1uNex21zj0m2heOeDvZk,9057
 piccolo/schema.py,sha256=aWPuZxEulgBRD5NTqKN-RAZchxu-PoIrn0iFrWGZuq4,7731
 piccolo/table.py,sha256=DJT8jTgirPpzkydjSzaCgcG0DiC75XRtW_xtFqTyg80,49457
 piccolo/table_reflection.py,sha256=jrN1nHerDJ4tU09GtNN3hz7ap-7rXnSUjljFO6LB2H0,7094
@@ -115,9 +115,9 @@ 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=XUhhx-wNc6nBPd39VIYuNfFERTaFzow9SHGfZjJ2YC0,31288
+piccolo/columns/base.py,sha256=FuMLSplFuNoK919nkas2Fn4kZjmPLMmutc4cRtmLhyY,31378
 piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,723
-piccolo/columns/column_types.py,sha256=tFOHOMOaZ3xPl6glQEd23N1oyeLGbu3qGlTuxPb7ToQ,81069
+piccolo/columns/column_types.py,sha256=CzbNnP_VWvz6_r4aaRcMHiHZOaWHeq5IGaN8WJ7JGPA,81685
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
 piccolo/columns/indexes.py,sha256=NfNok3v_791jgDlN28KmhP9ZCjl6031BXmjxV3ovXJk,372
 piccolo/columns/m2m.py,sha256=vRJZqBcBP3TQ9Mmb7UEqTgg0QoxIIjIu6JfGLAi4X8Q,14595
@@ -144,15 +144,16 @@ piccolo/engine/cockroach.py,sha256=7anXR3JPpGuR6-OpDLHM0FxKZhjuTvbRUuZV6fv9lXU,1
 piccolo/engine/exceptions.py,sha256=X8xZiTF-L9PIqFT-KDXnv1jFIIOZMF8fYK692chttJE,44
 piccolo/engine/finder.py,sha256=GjzBNtzRzH79fjtRn7OI3nZiOXE8JfoQWAvHVPrPNx4,507
 piccolo/engine/postgres.py,sha256=zUY6x52QrZ8waiqEUuqlVFiXyzAXrsFi3PY5EJnv3DM,18276
-piccolo/engine/sqlite.py,sha256=h5RrrDqy-28ck8L9SkLURfZWFSTcVdojTLDt1w8cTgk,22099
+piccolo/engine/sqlite.py,sha256=edwACs4RWsbzgoozBJRN5l9_Vq4nCMefRRLzuZYsF7M,25033
 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=O_uuMZbwMVAe-ebr-COdc9QZtvUSQFomPa29me6cscs,266
-piccolo/query/functions/aggregate.py,sha256=qSDb-2Of9FYXUKsdCsvaoPjGOefyhoxawWpA5oG3fQQ,4320
+piccolo/query/functions/__init__.py,sha256=9ikQo6qPkCBaWSiuimEACWbYRk9KHoLboRsEC1VcSVw,312
+piccolo/query/functions/aggregate.py,sha256=OdjDjr_zyD4S9UbrZ2C3V5mz4OT2sIfAFAdTGr4WL54,4248
 piccolo/query/functions/base.py,sha256=Go2bg2r7GaVoyyX-wTb80WEQmtiU4OFYWQlq9eQ6Zcc,478
 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
 piccolo/query/methods/alter.py,sha256=AI9YkJeip2EitrWJN_TDExXhA8HGAG3XuDz1NR-KirQ,16728
 piccolo/query/methods/count.py,sha256=Vxn_7Ry-rleC6OGRxh-cLbuEMsy1DNjAZJThGED-_do,1748
@@ -208,12 +209,12 @@ tests/apps/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 tests/apps/migrations/test_migration.py,sha256=JmPLtf2BCWX3Yofe0GQe40m8I_yWa_-3vk1lDfFDfIo,308
 tests/apps/migrations/auto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/migrations/auto/test_diffable_table.py,sha256=bok3G9pwEYnE3AL6UG4iEHrVBZJQ_ovYCdKC3we5JVQ,2932
-tests/apps/migrations/auto/test_migration_manager.py,sha256=XXdHHiimsyeNN6sILGQxN5RDLdR9MH_NlTC0PumLu3c,34741
+tests/apps/migrations/auto/test_migration_manager.py,sha256=NTNx4y5B0bMVLUR9BybX3zS4jxFI3_weLej8zOn3BkI,34798
 tests/apps/migrations/auto/test_schema_differ.py,sha256=UdsaZisA02j15wr1bXkXD6Cqu3p0A23NwFQLXsJdQL4,19391
 tests/apps/migrations/auto/test_schema_snapshot.py,sha256=ZyvGZqn3N3cwd-3S-FME5AJ8buDSHesw7yPIvY6mE5k,6196
 tests/apps/migrations/auto/test_serialisation.py,sha256=EFkhES1w9h51UCamWrhxs3mf4I718ggeP7Yl5J_UID4,13548
 tests/apps/migrations/auto/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/apps/migrations/auto/integration/test_migrations.py,sha256=G3iqDlNCC6S3N9pm7w0bf5YelDWDi1vz7OE0A2IEokk,46131
+tests/apps/migrations/auto/integration/test_migrations.py,sha256=7rmATPGZNuchabUb2y5C9QMmv6XFChn5EHlYoRVChd4,46744
 tests/apps/migrations/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/migrations/commands/test_base.py,sha256=NgHgVjNd3Hil9eODvW7Ic2D9muTa_grNaH3YpRFfR8I,1829
 tests/apps/migrations/commands/test_check.py,sha256=hOX_sVk1nfCRfbQ8tJoFEUBFhih9O4QuQLHTp5TQaiY,630
@@ -241,7 +242,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=R6dnUBGcMHi5pVhczI4ydWpXsu2FqRASu6KtkhDWfZo,6660
+tests/columns/test_array.py,sha256=Kd8yy3C4cXJIgutY-cv0MrE4mvgr52qqVUdkcazW_uI,9298
 tests/columns/test_base.py,sha256=CTqCNcrqAJTjLXe3MCZgTczrmB3jcVRcOpU4FilpLoQ,3918
 tests/columns/test_bigint.py,sha256=a0B4y1H02ww5qaW574X2lyenbY6o29ztOhiaqybPC0c,1149
 tests/columns/test_boolean.py,sha256=kDESp6FnRtSZhuqIu0dBRwKMSpS5TFbbs3sz2MyZSs8,1720
@@ -295,7 +296,7 @@ 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=_dYGLqsrYkWMxjb3MIlpsCbY1nC9n39IiRsrGhhrYJs,3182
+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_slots.py,sha256=I9ZjAYqAJNSFAWg9UyAqy7bm-Z52KiyQ2C_yHk2qqqI,1010
@@ -355,9 +356,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.6.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.6.0.dist-info/METADATA,sha256=48RdfV_g7BsGWelO0pWdGenSa6Ri1kSbN0bvWiaH85Q,5177
-piccolo-1.6.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
-piccolo-1.6.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.6.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.6.0.dist-info/RECORD,,
+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,,

tests/apps/migrations/auto/integration/test_migrations.py

@@ -288,7 +288,12 @@ class TestMigrations(MigrationTestCase):
                 [
                     x.data_type == "text",
                     x.is_nullable == "NO",
-                    x.column_default in ("''::text", "'':::STRING"),
+                    x.column_default
+                    in (
+                        "''",
+                        "''::text",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )
@@ -461,6 +466,7 @@ class TestMigrations(MigrationTestCase):
                     in (
                         "now()",
                         "CURRENT_TIMESTAMP",
+                        "current_timestamp()::TIMESTAMP",
                         "current_timestamp():::TIMESTAMPTZ::TIMESTAMP",
                     ),
                 ]
@@ -541,7 +547,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "interval",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("'00:00:00'::interval", "'00:00:00':::INTERVAL"),
+                    in (
+                        "'00:00:00'",
+                        "'00:00:00'::interval",
+                        "'00:00:00':::INTERVAL",
+                    ),
                 ]
             ),
         )
@@ -743,7 +753,12 @@ class TestMigrations(MigrationTestCase):
                 [
                     x.data_type == "jsonb",
                     x.is_nullable == "NO",
-                    x.column_default in ("'{}'::jsonb", "'{}':::JSONB"),
+                    x.column_default
+                    in (
+                        "'{}'",
+                        "'{}'::jsonb",
+                        "'{}':::JSONB",
+                    ),
                 ]
             ),
         )
@@ -766,7 +781,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "character varying",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("''::character varying", "'':::STRING"),
+                    in (
+                        "''",
+                        "''::character varying",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )
@@ -788,7 +807,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "character varying",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("''::character varying", "'':::STRING"),
+                    in (
+                        "''",
+                        "''::character varying",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )

tests/apps/migrations/auto/test_migration_manager.py

@@ -768,15 +768,15 @@ class TestMigrationManager(DBTestCase):
         )
 
         asyncio.run(manager.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Unknown':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Unknown'", "'Unknown':::STRING"],
         )
 
         asyncio.run(manager.run(backwards=True))
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["''", "'':::STRING"],
         )
 
     @engines_only("postgres")
@@ -856,9 +856,9 @@ class TestMigrationManager(DBTestCase):
             old_params={"default": None},
         )
         asyncio.run(manager_1.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         # Drop the default.
@@ -879,9 +879,9 @@ class TestMigrationManager(DBTestCase):
         # And add it back once more to be sure.
         manager_3 = manager_1
         asyncio.run(manager_3.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         # Run them all backwards
@@ -892,9 +892,9 @@ class TestMigrationManager(DBTestCase):
         )
 
         asyncio.run(manager_2.run(backwards=True))
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         asyncio.run(manager_1.run(backwards=True))

tests/columns/test_array.py

@@ -1,6 +1,15 @@
+import datetime
 from unittest import TestCase
 
-from piccolo.columns.column_types import Array, BigInt, Integer
+from piccolo.columns.column_types import (
+    Array,
+    BigInt,
+    Date,
+    Integer,
+    Time,
+    Timestamp,
+    Timestamptz,
+)
 from piccolo.table import Table
 from tests.base import engines_only, sqlite_only
 
@@ -22,7 +31,7 @@ class TestArrayDefault(TestCase):
 
 class TestArray(TestCase):
     """
-    Make sure an Array column can be created, and work correctly.
+    Make sure an Array column can be created, and works correctly.
     """
 
     def setUp(self):
@@ -166,6 +175,84 @@ class TestArray(TestCase):
         )
 
 
+###############################################################################
+# Date and time arrays
+
+
+class DateTimeArrayTable(Table):
+    date = Array(Date())
+    time = Array(Time())
+    timestamp = Array(Timestamp())
+    timestamptz = Array(Timestamptz())
+    date_nullable = Array(Date(), null=True)
+    time_nullable = Array(Time(), null=True)
+    timestamp_nullable = Array(Timestamp(), null=True)
+    timestamptz_nullable = Array(Timestamptz(), null=True)
+
+
+class TestDateTimeArray(TestCase):
+    """
+    Make sure that data can be stored and retrieved when using arrays of
+    date / time / timestamp.
+
+    We have to serialise / deserialise it in a special way in SQLite, hence
+    the tests.
+
+    """
+
+    def setUp(self):
+        DateTimeArrayTable.create_table().run_sync()
+
+    def tearDown(self):
+        DateTimeArrayTable.alter().drop_table().run_sync()
+
+    @engines_only("postgres", "sqlite")
+    def test_storage(self):
+        test_date = datetime.date(year=2024, month=1, day=1)
+        test_time = datetime.time(hour=12, minute=0)
+        test_timestamp = datetime.datetime(
+            year=2024, month=1, day=1, hour=12, minute=0
+        )
+        test_timestamptz = datetime.datetime(
+            year=2024,
+            month=1,
+            day=1,
+            hour=12,
+            minute=0,
+            tzinfo=datetime.timezone.utc,
+        )
+
+        DateTimeArrayTable(
+            {
+                DateTimeArrayTable.date: [test_date],
+                DateTimeArrayTable.time: [test_time],
+                DateTimeArrayTable.timestamp: [test_timestamp],
+                DateTimeArrayTable.timestamptz: [test_timestamptz],
+                DateTimeArrayTable.date_nullable: None,
+                DateTimeArrayTable.time_nullable: None,
+                DateTimeArrayTable.timestamp_nullable: None,
+                DateTimeArrayTable.timestamptz_nullable: None,
+            }
+        ).save().run_sync()
+
+        row = DateTimeArrayTable.objects().first().run_sync()
+        assert row is not None
+
+        self.assertListEqual(row.date, [test_date])
+        self.assertListEqual(row.time, [test_time])
+        self.assertListEqual(row.timestamp, [test_timestamp])
+        self.assertListEqual(row.timestamptz, [test_timestamptz])
+
+        self.assertIsNone(row.date_nullable)
+        self.assertIsNone(row.time_nullable)
+        self.assertIsNone(row.timestamp_nullable)
+        self.assertIsNone(row.timestamptz_nullable)
+
+
+###############################################################################
+# Nested arrays
+
+
 class NestedArrayTable(Table):
     value = Array(base_column=Array(base_column=BigInt()))
 

tests/query/test_functions.py

@@ -1,6 +1,7 @@
 from unittest import TestCase
 
-from piccolo.query.functions.string import Reverse, Upper
+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
@@ -16,7 +17,13 @@ class FunctionTest(TestCase):
         manager = Manager({Manager.name: "Guido"})
         manager.save().run_sync()
 
-        band = Band({Band.name: "Pythonistas", Band.manager: manager})
+        band = Band(
+            {
+                Band.name: "Pythonistas",
+                Band.manager: manager,
+                Band.popularity: 1000,
+            }
+        )
         band.save().run_sync()
 
     def tearDown(self) -> None:
@@ -100,3 +107,132 @@ class TestWhereClause(FunctionTest):
             .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}],
+        )