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

piccolo/query/functions/aggregate.py

@@ -0,0 +1,179 @@
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.querystring import QueryString
+
+from .base import Function
+
+
+class Avg(Function):
+    """
+    ``AVG()`` SQL function. Column type must be numeric to run the query.
+
+    .. code-block:: python
+
+        await Band.select(Avg(Band.popularity)).run()
+
+        # 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()
+
+    """
+
+    function_name = "AVG"
+
+
+class Count(QueryString):
+    """
+    Used in ``Select`` queries, usually in conjunction with the ``group_by``
+    clause::
+
+        >>> await Band.select(
+        ...     Band.manager.name.as_alias('manager_name'),
+        ...     Count(alias='band_count')
+        ... ).group_by(Band.manager)
+        [{'manager_name': 'Guido', 'count': 1}, ...]
+
+    It can also be used without the ``group_by`` clause (though you may prefer
+    to the :meth:`Table.count <piccolo.table.Table.count>` method instead, as
+    it's more convenient)::
+
+        >>> await Band.select(Count())
+        [{'count': 3}]
+
+    """
+
+    def __init__(
+        self,
+        column: t.Optional[Column] = None,
+        distinct: t.Optional[t.Sequence[Column]] = None,
+        alias: str = "count",
+    ):
+        """
+        :param column:
+            If specified, the count is for non-null values in that column.
+        :param distinct:
+            If specified, the count is for distinct values in those columns.
+        :param alias:
+            The name of the value in the response::
+
+                # These two are equivalent:
+
+                await Band.select(
+                    Band.name, Count(alias="total")
+                ).group_by(Band.name)
+
+                await Band.select(
+                    Band.name,
+                    Count().as_alias("total")
+                ).group_by(Band.name)
+
+        """
+        if distinct and column:
+            raise ValueError("Only specify `column` or `distinct`")
+
+        if distinct:
+            engine_type = distinct[0]._meta.engine_type
+            if engine_type == "sqlite":
+                # SQLite doesn't allow us to specify multiple columns, so
+                # instead we concatenate the values.
+                column_names = " || ".join("{}" for _ in distinct)
+            else:
+                column_names = ", ".join("{}" for _ in distinct)
+
+            return super().__init__(
+                f"COUNT(DISTINCT({column_names}))", *distinct, alias=alias
+            )
+        else:
+            if column:
+                return super().__init__("COUNT({})", column, alias=alias)
+            else:
+                return super().__init__("COUNT(*)", alias=alias)
+
+
+class Min(Function):
+    """
+    ``MIN()`` SQL function.
+
+    .. code-block:: python
+
+        await Band.select(Min(Band.popularity)).run()
+
+        # 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()
+
+    """
+
+    function_name = "MIN"
+
+
+class Max(Function):
+    """
+    ``MAX()`` SQL function.
+
+    .. code-block:: python
+
+        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()
+
+    """
+
+    function_name = "MAX"
+
+
+class Sum(Function):
+    """
+    ``SUM()`` SQL function. Column type must be numeric to run the query.
+
+    .. code-block:: python
+
+        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()
+
+    """
+
+    function_name = "SUM"
+
+
+__all__ = (
+    "Avg",
+    "Count",
+    "Min",
+    "Max",
+    "Sum",
+)

piccolo/query/functions/base.py

@@ -0,0 +1,21 @@
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.querystring import QueryString
+
+
+class Function(QueryString):
+    function_name: str
+
+    def __init__(
+        self,
+        identifier: t.Union[Column, QueryString, str],
+        alias: t.Optional[str] = None,
+    ):
+        alias = alias or self.__class__.__name__.lower()
+
+        super().__init__(
+            f"{self.function_name}({{}})",
+            identifier,
+            alias=alias,
+        )

piccolo/query/functions/string.py

@@ -0,0 +1,73 @@
+"""
+These functions mirror their counterparts in the Postgresql docs:
+
+https://www.postgresql.org/docs/current/functions-string.html
+
+"""
+
+from .base import Function
+
+
+class Length(Function):
+    """
+    Returns the number of characters in the string.
+    """
+
+    function_name = "LENGTH"
+
+
+class Lower(Function):
+    """
+    Converts the string to all lower case, according to the rules of the
+    database's locale.
+    """
+
+    function_name = "LOWER"
+
+
+class Ltrim(Function):
+    """
+    Removes the longest string containing only characters in characters (a
+    space by default) from the start of string.
+    """
+
+    function_name = "LTRIM"
+
+
+class Reverse(Function):
+    """
+    Return reversed string.
+
+    Not supported in SQLite.
+
+    """
+
+    function_name = "REVERSE"
+
+
+class Rtrim(Function):
+    """
+    Removes the longest string containing only characters in characters (a
+    space by default) from the end of string.
+    """
+
+    function_name = "RTRIM"
+
+
+class Upper(Function):
+    """
+    Converts the string to all upper case, according to the rules of the
+    database's locale.
+    """
+
+    function_name = "UPPER"
+
+
+__all__ = (
+    "Length",
+    "Lower",
+    "Ltrim",
+    "Reverse",
+    "Rtrim",
+    "Upper",
+)

piccolo/query/methods/__init__.py

@@ -9,6 +9,23 @@ from .insert import Insert
 from .objects import Objects
 from .raw import Raw
 from .refresh import Refresh
-from .select import Avg, Max, Min, Select, Sum
+from .select import Select
 from .table_exists import TableExists
 from .update import Update
+
+__all__ = (
+    "Alter",
+    "Count",
+    "Create",
+    "CreateIndex",
+    "Delete",
+    "DropIndex",
+    "Exists",
+    "Insert",
+    "Objects",
+    "Raw",
+    "Refresh",
+    "Select",
+    "TableExists",
+    "Update",
+)

piccolo/query/methods/count.py

@@ -4,7 +4,7 @@ import typing as t
 
 from piccolo.custom_types import Combinable
 from piccolo.query.base import Query
-from piccolo.query.methods.select import Count as SelectCount
+from piccolo.query.functions.aggregate import Count as CountFunction
 from piccolo.query.mixins import WhereDelegate
 from piccolo.querystring import QueryString
 
@@ -32,7 +32,7 @@ class Count(Query):
     ###########################################################################
     # Clauses
 
-    def where(self: Self, *where: Combinable) -> Self:
+    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 
@@ -50,7 +50,7 @@ class Count(Query):
         table: t.Type[Table] = self.table
 
         query = table.select(
-            SelectCount(column=self.column, distinct=self._distinct)
+            CountFunction(column=self.column, distinct=self._distinct)
         )
 
         query.where_delegate._where = self.where_delegate._where

piccolo/query/methods/delete.py

@@ -30,7 +30,7 @@ class Delete(Query):
         self.returning_delegate = ReturningDelegate()
         self.where_delegate = WhereDelegate()
 
-    def where(self: Self, *where: Combinable) -> Self:
+    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 

piccolo/query/methods/exists.py

@@ -16,7 +16,7 @@ class Exists(Query[TableInstance, bool]):
         super().__init__(table, **kwargs)
         self.where_delegate = WhereDelegate()
 
-    def where(self: Self, *where: Combinable) -> Self:
+    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 

piccolo/query/methods/objects.py

@@ -262,7 +262,7 @@ class Objects(
         self.order_by_delegate.order_by(*_columns, ascending=ascending)
         return self
 
-    def where(self: Self, *where: Combinable) -> Self:
+    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 

piccolo/query/methods/select.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import decimal
 import itertools
 import typing as t
 from collections import OrderedDict
@@ -36,9 +35,8 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.custom_types import Combinable
     from piccolo.table import Table  # noqa
 
-
-def is_numeric_column(column: Column) -> bool:
-    return column.value_type in (int, decimal.Decimal, float)
+# Here to avoid breaking changes - will be removed in the future.
+from piccolo.query.functions.aggregate import Count  # noqa: F401
 
 
 class SelectRaw(Selectable):
@@ -59,224 +57,8 @@ class SelectRaw(Selectable):
 
     def get_select_string(
         self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        return self.querystring.__str__()
-
-
-class Avg(Selectable):
-    """
-    ``AVG()`` SQL function. Column type must be numeric to run the query.
-
-    .. code-block:: python
-
-        await Band.select(Avg(Band.popularity)).run()
-
-        # 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()
-
-    """
-
-    def __init__(self, column: Column, alias: str = "avg"):
-        if is_numeric_column(column):
-            self.column = column
-        else:
-            raise ValueError("Column type must be numeric to run the query.")
-        self._alias = alias
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        column_name = self.column._meta.get_full_name(with_alias=False)
-        return f'AVG({column_name}) AS "{self._alias}"'
-
-
-class Count(Selectable):
-    """
-    Used in ``Select`` queries, usually in conjunction with the ``group_by``
-    clause::
-
-        >>> await Band.select(
-        ...     Band.manager.name.as_alias('manager_name'),
-        ...     Count(alias='band_count')
-        ... ).group_by(Band.manager)
-        [{'manager_name': 'Guido', 'count': 1}, ...]
-
-    It can also be used without the ``group_by`` clause (though you may prefer
-    to the :meth:`Table.count <piccolo.table.Table.count>` method instead, as
-    it's more convenient)::
-
-        >>> await Band.select(Count())
-        [{'count': 3}]
-
-    """
-
-    def __init__(
-        self,
-        column: t.Optional[Column] = None,
-        distinct: t.Optional[t.Sequence[Column]] = None,
-        alias: str = "count",
-    ):
-        """
-        :param column:
-            If specified, the count is for non-null values in that column.
-        :param distinct:
-            If specified, the count is for distinct values in those columns.
-        :param alias:
-            The name of the value in the response::
-
-                # These two are equivalent:
-
-                await Band.select(
-                    Band.name, Count(alias="total")
-                ).group_by(Band.name)
-
-                await Band.select(
-                    Band.name,
-                    Count().as_alias("total")
-                ).group_by(Band.name)
-
-        """
-        if distinct and column:
-            raise ValueError("Only specify `column` or `distinct`")
-
-        self.column = column
-        self.distinct = distinct
-        self._alias = alias
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        expression: str
-
-        if self.distinct:
-            if engine_type == "sqlite":
-                # SQLite doesn't allow us to specify multiple columns, so
-                # instead we concatenate the values.
-                column_names = " || ".join(
-                    i._meta.get_full_name(with_alias=False)
-                    for i in self.distinct
-                )
-            else:
-                column_names = ", ".join(
-                    i._meta.get_full_name(with_alias=False)
-                    for i in self.distinct
-                )
-
-            expression = f"DISTINCT ({column_names})"
-        else:
-            if self.column:
-                expression = self.column._meta.get_full_name(with_alias=False)
-            else:
-                expression = "*"
-
-        return f'COUNT({expression}) AS "{self._alias}"'
-
-
-class Max(Selectable):
-    """
-    ``MAX()`` SQL function.
-
-    .. code-block:: python
-
-        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()
-
-    """
-
-    def __init__(self, column: Column, alias: str = "max"):
-        self.column = column
-        self._alias = alias
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        column_name = self.column._meta.get_full_name(with_alias=False)
-        return f'MAX({column_name}) AS "{self._alias}"'
-
-
-class Min(Selectable):
-    """
-    ``MIN()`` SQL function.
-
-    .. code-block:: python
-
-        await Band.select(Min(Band.popularity)).run()
-
-        # 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()
-
-    """
-
-    def __init__(self, column: Column, alias: str = "min"):
-        self.column = column
-        self._alias = alias
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        column_name = self.column._meta.get_full_name(with_alias=False)
-        return f'MIN({column_name}) AS "{self._alias}"'
-
-
-class Sum(Selectable):
-    """
-    ``SUM()`` SQL function. Column type must be numeric to run the query.
-
-    .. code-block:: python
-
-        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()
-
-    """
-
-    def __init__(self, column: Column, alias: str = "sum"):
-        if is_numeric_column(column):
-            self.column = column
-        else:
-            raise ValueError("Column type must be numeric to run the query.")
-        self._alias = alias
-
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        column_name = self.column._meta.get_full_name(with_alias=False)
-        return f'SUM({column_name}) AS "{self._alias}"'
+    ) -> QueryString:
+        return self.querystring
 
 
 OptionalDict = t.Optional[t.Dict[str, t.Any]]
@@ -645,7 +427,7 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         self.callback_delegate.callback(callbacks, on=on)
         return self
 
-    def where(self: Self, *where: Combinable) -> Self:
+    def where(self: Self, *where: t.Union[Combinable, QueryString]) -> Self:
         self.where_delegate.where(*where)
         return self
 
@@ -678,23 +460,25 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         for readable in readables:
             columns += readable.columns
 
+        querystrings: t.List[QueryString] = [
+            i for i in columns if isinstance(i, QueryString)
+        ]
+        for querystring in querystrings:
+            if querystring_columns := getattr(querystring, "columns", []):
+                columns += querystring_columns
+
         for column in columns:
             if not isinstance(column, Column):
                 continue
 
             _joins: t.List[str] = []
             for index, key in enumerate(column._meta.call_chain, 0):
-                table_alias = "$".join(
-                    f"{_key._meta.table._meta.tablename}${_key._meta.name}"
-                    for _key in column._meta.call_chain[: index + 1]
-                )
-
-                key._meta.table_alias = table_alias
+                table_alias = key.table_alias
 
                 if index > 0:
                     left_tablename = column._meta.call_chain[
                         index - 1
-                    ]._meta.table_alias
+                    ].table_alias
                 else:
                     left_tablename = (
                         key._meta.table._meta.get_formatted_tablename()
@@ -761,11 +545,10 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
 
         engine_type = self.table._meta.db.engine_type
 
-        select_strings: t.List[str] = [
+        select_strings: t.List[QueryString] = [
             c.get_select_string(engine_type=engine_type)
             for c in self.columns_delegate.selected_columns
         ]
-        columns_str = ", ".join(select_strings)
 
         #######################################################################
 
@@ -779,7 +562,9 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         query += "{}"
         args.append(distinct.querystring)
 
+        columns_str = ", ".join("{}" for i in select_strings)
         query += f" {columns_str} FROM {self.table._meta.get_formatted_tablename()}"  # noqa: E501
+        args.extend(select_strings)
 
         for join in joins:
             query += f" {join}"

piccolo/query/methods/update.py

@@ -50,7 +50,7 @@ class Update(Query[TableInstance, t.List[t.Any]]):
         self.values_delegate.values(values)
         return self
 
-    def where(self, *where: Combinable) -> Update:
+    def where(self, *where: t.Union[Combinable, QueryString]) -> Update:
         self.where_delegate.where(*where)
         return self