piccolo 1.10.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.10.0"
+__VERSION__ = "1.11.0"

piccolo/columns/column_types.py

@@ -86,47 +86,38 @@ class ConcatDelegate:
 
     def get_querystring(
         self,
-        column_name: str,
-        value: t.Union[str, Varchar, Text],
+        column: Column,
+        value: t.Union[str, Column, QueryString],
         reverse: bool = False,
     ) -> QueryString:
-        if isinstance(value, (Varchar, Text)):
-            column: Column = value
+        """
+        :param reverse:
+            By default the value is appended to the column's value. If
+            ``reverse=True`` then the value is prepended to the column's
+            value instead.
+
+        """
+        if isinstance(value, Column):
             if len(column._meta.call_chain) > 0:
                 raise ValueError(
                     "Adding values across joins isn't currently supported."
                 )
-            other_column_name = column._meta.db_column_name
-            if reverse:
-                return QueryString(
-                    Concat.template.format(
-                        value_1=other_column_name, value_2=column_name
-                    )
-                )
-            else:
-                return QueryString(
-                    Concat.template.format(
-                        value_1=column_name, value_2=other_column_name
-                    )
-                )
         elif isinstance(value, str):
-            if reverse:
-                value_1 = QueryString("CAST({} AS text)", value)
-                return QueryString(
-                    Concat.template.format(value_1="{}", value_2=column_name),
-                    value_1,
-                )
-            else:
-                value_2 = QueryString("CAST({} AS text)", value)
-                return QueryString(
-                    Concat.template.format(value_1=column_name, value_2="{}"),
-                    value_2,
-                )
-        else:
+            value = QueryString("CAST({} AS TEXT)", value)
+        elif not isinstance(value, QueryString):
             raise ValueError(
-                "Only str, Varchar columns, and Text columns can be added."
+                "Only str, Column and QueryString values can be added."
             )
 
+        args = [value, column] if reverse else [column, value]
+
+        # We use the concat operator instead of the concat function, because
+        # this is what we historically used, and they treat null values
+        # differently.
+        return QueryString(
+            Concat.template.format(value_1="{}", value_2="{}"), *args
+        )
+
 
 class MathDelegate:
     """
@@ -340,12 +331,13 @@ class Varchar(Column):
 
     def __add__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name, value=value
+            column=self,
+            value=value,
         )
 
     def __radd__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name,
+            column=self,
             value=value,
             reverse=True,
         )
@@ -442,12 +434,13 @@ class Text(Column):
 
     def __add__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name, value=value
+            column=self,
+            value=value,
         )
 
     def __radd__(self, value: t.Union[str, Varchar, Text]) -> QueryString:
         return self.concat_delegate.get_querystring(
-            column_name=self._meta.db_column_name,
+            column=self,
             value=value,
             reverse=True,
         )

piccolo/query/functions/__init__.py

@@ -1,6 +1,7 @@
 from .aggregate import Avg, Count, Max, Min, Sum
+from .datetime import Day, Extract, Hour, Month, Second, Strftime, Year
 from .math import Abs, Ceil, Floor, Round
-from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
+from .string import Concat, Length, Lower, Ltrim, Reverse, Rtrim, Upper
 from .type_conversion import Cast
 
 __all__ = (
@@ -8,16 +9,25 @@ __all__ = (
     "Avg",
     "Cast",
     "Ceil",
+    "Concat",
     "Count",
+    "Day",
+    "Extract",
+    "Extract",
     "Floor",
+    "Hour",
     "Length",
     "Lower",
     "Ltrim",
     "Max",
     "Min",
+    "Month",
     "Reverse",
     "Round",
     "Rtrim",
+    "Second",
+    "Strftime",
     "Sum",
     "Upper",
+    "Year",
 )

piccolo/query/functions/datetime.py

@@ -0,0 +1,260 @@
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.columns.column_types import (
+    Date,
+    Integer,
+    Time,
+    Timestamp,
+    Timestamptz,
+)
+from piccolo.querystring import QueryString
+
+from .type_conversion import Cast
+
+###############################################################################
+# Postgres / Cockroach
+
+ExtractComponent = t.Literal[
+    "century",
+    "day",
+    "decade",
+    "dow",
+    "doy",
+    "epoch",
+    "hour",
+    "isodow",
+    "isoyear",
+    "julian",
+    "microseconds",
+    "millennium",
+    "milliseconds",
+    "minute",
+    "month",
+    "quarter",
+    "second",
+    "timezone",
+    "timezone_hour",
+    "timezone_minute",
+    "week",
+    "year",
+]
+
+
+class Extract(QueryString):
+    def __init__(
+        self,
+        identifier: t.Union[Date, Time, Timestamp, Timestamptz, QueryString],
+        datetime_component: ExtractComponent,
+        alias: t.Optional[str] = None,
+    ):
+        """
+        .. note:: This is for Postgres / Cockroach only.
+
+        Extract a date or time component from a ``Date`` / ``Time`` /
+        ``Timestamp`` / ``Timestamptz`` column. For example, getting the month
+        from a timestamp:
+
+        .. code-block:: python
+
+            >>> from piccolo.query.functions import Extract
+            >>> await Concert.select(
+            ...     Extract(Concert.starts, "month", alias="start_month")
+            ... )
+            [{"start_month": 12}]
+
+        :param identifier:
+            Identifies the column.
+        :param datetime_component:
+            The date or time component to extract from the column.
+
+        """
+        if datetime_component.lower() not in t.get_args(ExtractComponent):
+            raise ValueError("The date time component isn't recognised.")
+
+        super().__init__(
+            f"EXTRACT({datetime_component} FROM {{}})",
+            identifier,
+            alias=alias,
+        )
+
+
+###############################################################################
+# SQLite
+
+
+class Strftime(QueryString):
+    def __init__(
+        self,
+        identifier: t.Union[Date, Time, Timestamp, Timestamptz, QueryString],
+        datetime_format: str,
+        alias: t.Optional[str] = None,
+    ):
+        """
+        .. note:: This is for SQLite only.
+
+        Format a datetime value. For example:
+
+        .. code-block:: python
+
+            >>> from piccolo.query.functions import Strftime
+            >>> await Concert.select(
+            ...     Strftime(Concert.starts, "%Y", alias="start_year")
+            ... )
+            [{"start_month": "2024"}]
+
+        :param identifier:
+            Identifies the column.
+        :param datetime_format:
+            A string describing the output format (see SQLite's
+            `documentation <https://www.sqlite.org/lang_datefunc.html>`_
+            for more info).
+
+        """
+        super().__init__(
+            f"strftime('{datetime_format}', {{}})",
+            identifier,
+            alias=alias,
+        )
+
+
+###############################################################################
+# Database agnostic
+
+
+def _get_engine_type(identifier: t.Union[Column, QueryString]) -> str:
+    if isinstance(identifier, Column):
+        return identifier._meta.engine_type
+    elif isinstance(identifier, QueryString) and (
+        columns := identifier.columns
+    ):
+        return columns[0]._meta.engine_type
+    else:
+        raise ValueError("Unable to determine the engine type")
+
+
+def _extract_component(
+    identifier: t.Union[Date, Time, Timestamp, Timestamptz, QueryString],
+    sqlite_format: str,
+    postgres_format: ExtractComponent,
+    alias: t.Optional[str],
+) -> QueryString:
+    engine_type = _get_engine_type(identifier=identifier)
+
+    return Cast(
+        (
+            Strftime(
+                identifier=identifier,
+                datetime_format=sqlite_format,
+            )
+            if engine_type == "sqlite"
+            else Extract(
+                identifier=identifier,
+                datetime_component=postgres_format,
+            )
+        ),
+        Integer(),
+        alias=alias,
+    )
+
+
+def Year(
+    identifier: t.Union[Date, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the year as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%Y",
+        postgres_format="year",
+        alias=alias,
+    )
+
+
+def Month(
+    identifier: t.Union[Date, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the month as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%m",
+        postgres_format="month",
+        alias=alias,
+    )
+
+
+def Day(
+    identifier: t.Union[Date, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the day as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%d",
+        postgres_format="day",
+        alias=alias,
+    )
+
+
+def Hour(
+    identifier: t.Union[Time, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the hour as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%H",
+        postgres_format="hour",
+        alias=alias,
+    )
+
+
+def Minute(
+    identifier: t.Union[Time, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the minute as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%M",
+        postgres_format="minute",
+        alias=alias,
+    )
+
+
+def Second(
+    identifier: t.Union[Time, Timestamp, Timestamptz, QueryString],
+    alias: t.Optional[str] = None,
+) -> QueryString:
+    """
+    Extract the second as an integer.
+    """
+    return _extract_component(
+        identifier=identifier,
+        sqlite_format="%S",
+        postgres_format="second",
+        alias=alias,
+    )
+
+
+__all__ = (
+    "Extract",
+    "Strftime",
+    "Year",
+    "Month",
+    "Day",
+    "Hour",
+    "Minute",
+    "Second",
+)

piccolo/query/functions/string.py

@@ -5,6 +5,12 @@ https://www.postgresql.org/docs/current/functions-string.html
 
 """
 
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.columns.column_types import Text, Varchar
+from piccolo.querystring import QueryString
+
 from .base import Function
 
 
@@ -63,6 +69,44 @@ class Upper(Function):
     function_name = "UPPER"
 
 
+class Concat(QueryString):
+    def __init__(
+        self,
+        *args: t.Union[Column, QueryString, str],
+        alias: t.Optional[str] = None,
+    ):
+        """
+        Concatenate multiple values into a single string.
+
+        .. note::
+            Null values are ignored, so ``null + '!!!'`` returns ``!!!``,
+            not ``null``.
+
+        .. warning::
+            For SQLite, this is only available in version 3.44.0 and above.
+
+        """
+        if len(args) < 2:
+            raise ValueError("At least two values must be passed in.")
+
+        placeholders = ", ".join("{}" for _ in args)
+
+        processed_args: t.List[t.Union[QueryString, Column]] = []
+
+        for arg in args:
+            if isinstance(arg, str) or (
+                isinstance(arg, Column)
+                and not isinstance(arg, (Varchar, Text))
+            ):
+                processed_args.append(QueryString("CAST({} AS TEXT)", arg))
+            else:
+                processed_args.append(arg)
+
+        super().__init__(
+            f"CONCAT({placeholders})", *processed_args, alias=alias
+        )
+
+
 __all__ = (
     "Length",
     "Lower",
@@ -70,4 +114,5 @@ __all__ = (
     "Reverse",
     "Rtrim",
     "Upper",
+    "Concat",
 )

{piccolo-1.10.0.dist-info → piccolo-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.10.0
+Version: 1.11.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.10.0.dist-info → piccolo-1.11.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-piccolo/__init__.py,sha256=PUFn6Nk_mmFhCKTk02g04j8puY3N7KoIIwdxhzTnVRU,23
+piccolo/__init__.py,sha256=-4wiKExnJa5IxSz9dOFdTv99ibuBl-uX3D-HM6f-_V8,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -117,7 +117,7 @@ piccolo/apps/user/piccolo_migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 piccolo/columns/__init__.py,sha256=OYhO_n9anMiU9nL-K6ATq9FhAtm8RyMpqYQ7fTVbhxI,1120
 piccolo/columns/base.py,sha256=sgMiBvq-xLW6_W86g6XZTMc_3cskyeoMF6yIvIlnXsA,32487
 piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,723
-piccolo/columns/column_types.py,sha256=YmltgnWhGLpmuMRimPPVQFmzF5hRDB7K1LaAjcI4Lmc,82364
+piccolo/columns/column_types.py,sha256=gwd93EWIULo5pGcuo7wHZdwvFEfFwtBy660pDBVqixw,81921
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
 piccolo/columns/indexes.py,sha256=NfNok3v_791jgDlN28KmhP9ZCjl6031BXmjxV3ovXJk,372
 piccolo/columns/m2m.py,sha256=17NY0wU7ta2rUTHYUkeA2HQhTDlJ_lyv9FxqvJiiUbY,14602
@@ -149,11 +149,12 @@ piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
 piccolo/query/base.py,sha256=G8Mwz0GcHY4Xs5Co9ubCNMI-3orfOsDdRDOnFRws7TU,15212
 piccolo/query/mixins.py,sha256=EFEFb9It4y1mR6_JXLn139h5M9KgeP750STYy5M4MLs,21951
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
-piccolo/query/functions/__init__.py,sha256=e-BEHlGR3JhE2efWG_rmXdURKL4Fa8tjdGmPsvH4kWo,403
+piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
 piccolo/query/functions/aggregate.py,sha256=OdjDjr_zyD4S9UbrZ2C3V5mz4OT2sIfAFAdTGr4WL54,4248
 piccolo/query/functions/base.py,sha256=Go2bg2r7GaVoyyX-wTb80WEQmtiU4OFYWQlq9eQ6Zcc,478
+piccolo/query/functions/datetime.py,sha256=6YSpc_MiZK_019KUhCo01Ss_1AjXJ31M61R9-zKmoZs,6251
 piccolo/query/functions/math.py,sha256=2Wapq0lpXZh77z0uzXUhnOfmUkbkM0xjQ4tiyuCsbiE,661
-piccolo/query/functions/string.py,sha256=srxsQJFS6L4gPvFjvuAFQj7QtnCF7X6YoJNKARR2XP0,1236
+piccolo/query/functions/string.py,sha256=X3g_4qomJJCkYOcKcK-zZEqC6qJBrS4VTogPp9Xw4Cs,2506
 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
@@ -303,9 +304,10 @@ tests/query/test_querystring.py,sha256=QrqyjwUlFlf5LrsJ7DgjCruq811I0UvrDFPud6rfZ
 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_datetime.py,sha256=8GG5ERLq6GM8NqA3J6mycNPfCUMOEICGccyZifiwEqw,2987
 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_string.py,sha256=RMojkBUzw1Ikrb3nTa7VjJ4FsKfrjpuHUyxQDA-F5Cs,1800
 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
@@ -363,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.10.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.10.0.dist-info/METADATA,sha256=iOzLZbrVstdxKNx_ifn_M7voMrX0KkQsBcPB39vw0VE,5178
-piccolo-1.10.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
-piccolo-1.10.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.10.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.10.0.dist-info/RECORD,,
+piccolo-1.11.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.11.0.dist-info/METADATA,sha256=th4damYz6EsRNzUVjj7Rkn5Eu3jv1LDiCHAHV-N_piE,5178
+piccolo-1.11.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
+piccolo-1.11.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.11.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.11.0.dist-info/RECORD,,

tests/query/functions/test_datetime.py

@@ -0,0 +1,114 @@
+import datetime
+
+from piccolo.columns import Timestamp
+from piccolo.query.functions.datetime import (
+    Day,
+    Extract,
+    Hour,
+    Minute,
+    Month,
+    Second,
+    Strftime,
+    Year,
+)
+from piccolo.table import Table
+from tests.base import engines_only, sqlite_only
+
+from .base import FunctionTest
+
+
+class Concert(Table):
+    starts = Timestamp()
+
+
+class DatetimeTest(FunctionTest):
+    tables = [Concert]
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.concert = Concert(
+            {
+                Concert.starts: datetime.datetime(
+                    year=2024, month=6, day=14, hour=23, minute=46, second=10
+                )
+            }
+        )
+        self.concert.save().run_sync()
+
+
+@engines_only("postgres", "cockroach")
+class TestExtract(DatetimeTest):
+    def test_extract(self):
+        self.assertEqual(
+            Concert.select(
+                Extract(Concert.starts, "year", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_invalid_format(self):
+        with self.assertRaises(ValueError):
+            Extract(
+                Concert.starts,
+                "abc123",  # type: ignore
+                alias="starts_year",
+            )
+
+
+@sqlite_only
+class TestStrftime(DatetimeTest):
+    def test_strftime(self):
+        self.assertEqual(
+            Concert.select(
+                Strftime(Concert.starts, "%Y", alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": str(self.concert.starts.year)}],
+        )
+
+
+class TestDatabaseAgnostic(DatetimeTest):
+    def test_year(self):
+        self.assertEqual(
+            Concert.select(
+                Year(Concert.starts, alias="starts_year")
+            ).run_sync(),
+            [{"starts_year": self.concert.starts.year}],
+        )
+
+    def test_month(self):
+        self.assertEqual(
+            Concert.select(
+                Month(Concert.starts, alias="starts_month")
+            ).run_sync(),
+            [{"starts_month": self.concert.starts.month}],
+        )
+
+    def test_day(self):
+        self.assertEqual(
+            Concert.select(Day(Concert.starts, alias="starts_day")).run_sync(),
+            [{"starts_day": self.concert.starts.day}],
+        )
+
+    def test_hour(self):
+        self.assertEqual(
+            Concert.select(
+                Hour(Concert.starts, alias="starts_hour")
+            ).run_sync(),
+            [{"starts_hour": self.concert.starts.hour}],
+        )
+
+    def test_minute(self):
+        self.assertEqual(
+            Concert.select(
+                Minute(Concert.starts, alias="starts_minute")
+            ).run_sync(),
+            [{"starts_minute": self.concert.starts.minute}],
+        )
+
+    def test_second(self):
+        self.assertEqual(
+            Concert.select(
+                Second(Concert.starts, alias="starts_second")
+            ).run_sync(),
+            [{"starts_second": self.concert.starts.second}],
+        )

tests/query/functions/test_string.py

@@ -1,10 +1,13 @@
-from piccolo.query.functions.string import Upper
+import pytest
+
+from piccolo.query.functions.string import Concat, Upper
+from tests.base import engine_version_lt, is_running_sqlite
 from tests.example_apps.music.tables import Band
 
 from .base import BandTest
 
 
-class TestUpperFunction(BandTest):
+class TestUpper(BandTest):
 
     def test_column(self):
         """
@@ -23,3 +26,32 @@ class TestUpperFunction(BandTest):
         """
         response = Band.select(Upper(Band.manager._.name)).run_sync()
         self.assertListEqual(response, [{"upper": "GUIDO"}])
+
+
+@pytest.mark.skipif(
+    is_running_sqlite() and engine_version_lt(3.44),
+    reason="SQLite version not supported",
+)
+class TestConcat(BandTest):
+
+    def test_column_and_string(self):
+        response = Band.select(
+            Concat(Band.name, "!!!", alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas!!!"}])
+
+    def test_column_and_column(self):
+        response = Band.select(
+            Concat(Band.name, Band.popularity, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas1000"}])
+
+    def test_join(self):
+        response = Band.select(
+            Concat(Band.name, "-", Band.manager._.name, alias="name")
+        ).run_sync()
+        self.assertListEqual(response, [{"name": "Pythonistas-Guido"}])
+
+    def test_min_args(self):
+        with self.assertRaises(ValueError):
+            Concat()