piccolo 1.5.2__tar.gz → 1.6.0__tar.gz

{piccolo-1.5.2 → piccolo-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.5.2
+Version: 1.6.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/piccolo/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "1.6.0"

{piccolo-1.5.2 → piccolo-1.6.0}/piccolo/columns/base.py

@@ -6,7 +6,6 @@ import decimal
 import inspect
 import typing as t
 import uuid
-from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass, field, fields
 from enum import Enum
 
@@ -32,6 +31,7 @@ from piccolo.columns.operators.comparison import (
     NotLike,
 )
 from piccolo.columns.reference import LazyTableReference
+from piccolo.querystring import QueryString, Selectable
 from piccolo.utils.warnings import colored_warning
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -205,7 +205,6 @@ class ColumnMeta:
 
     # Used by Foreign Keys:
     call_chain: t.List["ForeignKey"] = field(default_factory=list)
-    table_alias: t.Optional[str] = None
 
     ###########################################################################
 
@@ -260,7 +259,7 @@ class ColumnMeta:
         column_name = self.db_column_name
 
         if self.call_chain:
-            table_alias = self.call_chain[-1]._meta.table_alias
+            table_alias = self.call_chain[-1].table_alias
             if include_quotes:
                 return f'"{table_alias}"."{column_name}"'
             else:
@@ -272,7 +271,9 @@ class ColumnMeta:
                 return f"{self.table._meta.tablename}.{column_name}"
 
     def get_full_name(
-        self, with_alias: bool = True, include_quotes: bool = True
+        self,
+        with_alias: bool = True,
+        include_quotes: bool = True,
     ) -> str:
         """
         Returns the full column name, taking into account joins.
@@ -302,11 +303,10 @@ class ColumnMeta:
                 >>> column._meta.get_full_name(include_quotes=False)
                 'my_table_name.my_column_name'
 
-
         """
         full_name = self._get_path(include_quotes=include_quotes)
 
-        if with_alias and self.call_chain:
+        if with_alias:
             alias = self.get_default_alias()
             if include_quotes:
                 full_name += f' AS "{alias}"'
@@ -346,32 +346,6 @@ class ColumnMeta:
         return self.copy()
 
 
-class Selectable(metaclass=ABCMeta):
-    """
-    Anything which inherits from this can be used in a select query.
-    """
-
-    _alias: t.Optional[str]
-
-    @abstractmethod
-    def get_select_string(
-        self, engine_type: str, with_alias: bool = True
-    ) -> str:
-        """
-        In a query, what to output after the select statement - could be a
-        column name, a sub query, a function etc. For a column it will be the
-        column name.
-        """
-        raise NotImplementedError()
-
-    def as_alias(self, alias: str) -> Selectable:
-        """
-        Allows column names to be changed in the result of a select.
-        """
-        self._alias = alias
-        return self
-
-
 class Column(Selectable):
     """
     All other columns inherit from ``Column``. Don't use it directly.
@@ -822,25 +796,32 @@ class Column(Selectable):
 
     def get_select_string(
         self, engine_type: str, with_alias: bool = True
-    ) -> str:
+    ) -> QueryString:
         """
         How to refer to this column in a SQL query, taking account of any joins
         and aliases.
         """
+
         if with_alias:
             if self._alias:
                 original_name = self._meta.get_full_name(
                     with_alias=False,
                 )
-                return f'{original_name} AS "{self._alias}"'
+                return QueryString(f'{original_name} AS "{self._alias}"')
             else:
-                return self._meta.get_full_name(
-                    with_alias=True,
+                return QueryString(
+                    self._meta.get_full_name(
+                        with_alias=True,
+                    )
                 )
 
-        return self._meta.get_full_name(with_alias=False)
+        return QueryString(
+            self._meta.get_full_name(
+                with_alias=False,
+            )
+        )
 
-    def get_where_string(self, engine_type: str) -> str:
+    def get_where_string(self, engine_type: str) -> QueryString:
         return self.get_select_string(
             engine_type=engine_type, with_alias=False
         )
@@ -902,6 +883,13 @@ class Column(Selectable):
     def column_type(self):
         return self.__class__.__name__.upper()
 
+    @property
+    def table_alias(self) -> str:
+        return "$".join(
+            f"{_key._meta.table._meta.tablename}${_key._meta.name}"
+            for _key in [*self._meta.call_chain, self]
+        )
+
     @property
     def ddl(self) -> str:
         """
@@ -945,8 +933,8 @@ class Column(Selectable):
 
         return query
 
-    def copy(self) -> Column:
-        column: Column = copy.copy(self)
+    def copy(self: Self) -> Self:
+        column = copy.copy(self)
         column._meta = self._meta.copy()
         return column
 
@@ -971,3 +959,6 @@ class Column(Selectable):
             f"{table_class_name}.{self._meta.name} - "
             f"{self.__class__.__name__}"
         )
+
+
+Self = t.TypeVar("Self", bound=Column)

{piccolo-1.5.2 → piccolo-1.6.0}/piccolo/columns/column_types.py

@@ -60,7 +60,7 @@ from piccolo.columns.defaults.uuid import UUID4, UUIDArg
 from piccolo.columns.operators.comparison import ArrayAll, ArrayAny
 from piccolo.columns.operators.string import Concat
 from piccolo.columns.reference import LazyTableReference
-from piccolo.querystring import QueryString, Unquoted
+from piccolo.querystring import QueryString
 from piccolo.utils.encoding import dump_json
 from piccolo.utils.warnings import colored_warning
 
@@ -752,8 +752,8 @@ class SmallInt(Integer):
 ###############################################################################
 
 
-DEFAULT = Unquoted("DEFAULT")
-NULL = Unquoted("null")
+DEFAULT = QueryString("DEFAULT")
+NULL = QueryString("null")
 
 
 class Serial(Column):
@@ -778,7 +778,7 @@ class Serial(Column):
         if engine_type == "postgres":
             return DEFAULT
         elif engine_type == "cockroach":
-            return Unquoted("unique_rowid()")
+            return QueryString("unique_rowid()")
         elif engine_type == "sqlite":
             return NULL
         raise Exception("Unrecognized engine type")
@@ -2194,6 +2194,7 @@ class ForeignKey(Column, t.Generic[ReferencedTable]):
             column_meta: ColumnMeta = object.__getattribute__(self, "_meta")
 
             new_column._meta.call_chain = column_meta.call_chain.copy()
+
             new_column._meta.call_chain.append(self)
             return new_column
         else:
@@ -2311,7 +2312,7 @@ class JSONB(JSON):
 
     def get_select_string(
         self, engine_type: str, with_alias: bool = True
-    ) -> str:
+    ) -> QueryString:
         select_string = self._meta.get_full_name(with_alias=False)
 
         if self.json_operator is not None:
@@ -2321,7 +2322,7 @@ class JSONB(JSON):
             alias = self._alias or self._meta.get_default_alias()
             select_string += f' AS "{alias}"'
 
-        return select_string
+        return QueryString(select_string)
 
     def eq(self, value) -> Where:
         """
@@ -2616,7 +2617,9 @@ class Array(Column):
         else:
             raise ValueError("Only integers can be used for indexing.")
 
-    def get_select_string(self, engine_type: str, with_alias=True) -> str:
+    def get_select_string(
+        self, engine_type: str, with_alias=True
+    ) -> QueryString:
         select_string = self._meta.get_full_name(with_alias=False)
 
         if isinstance(self.index, int):
@@ -2626,7 +2629,7 @@ class Array(Column):
             alias = self._alias or self._meta.get_default_alias()
             select_string += f' AS "{alias}"'
 
-        return select_string
+        return QueryString(select_string)
 
     def any(self, value: t.Any) -> Where:
         """

{piccolo-1.5.2 → piccolo-1.6.0}/piccolo/columns/m2m.py

@@ -4,7 +4,6 @@ import inspect
 import typing as t
 from dataclasses import dataclass
 
-from piccolo.columns.base import Selectable
 from piccolo.columns.column_types import (
     JSON,
     JSONB,
@@ -12,6 +11,7 @@ from piccolo.columns.column_types import (
     ForeignKey,
     LazyTableReference,
 )
+from piccolo.querystring import QueryString, Selectable
 from piccolo.utils.list import flatten
 from piccolo.utils.sync import run_sync
 
@@ -56,7 +56,9 @@ class M2MSelect(Selectable):
             for column in columns
         )
 
-    def get_select_string(self, engine_type: str, with_alias=True) -> str:
+    def get_select_string(
+        self, engine_type: str, with_alias=True
+    ) -> QueryString:
         m2m_table_name_with_schema = (
             self.m2m._meta.resolved_joining_table._meta.get_formatted_tablename()  # noqa: E501
         )  # noqa: E501
@@ -90,28 +92,33 @@ class M2MSelect(Selectable):
         if engine_type in ("postgres", "cockroach"):
             if self.as_list:
                 column_name = self.columns[0]._meta.db_column_name
-                return f"""
+                return QueryString(
+                    f"""
                     ARRAY(
                         SELECT
                             "inner_{table_2_name}"."{column_name}"
                         FROM {inner_select}
                     ) AS "{m2m_relationship_name}"
                 """
+                )
             elif not self.serialisation_safe:
                 column_name = table_2_pk_name
-                return f"""
+                return QueryString(
+                    f"""
                     ARRAY(
                         SELECT
                             "inner_{table_2_name}"."{column_name}"
                         FROM {inner_select}
                     ) AS "{m2m_relationship_name}"
                 """
+                )
             else:
                 column_names = ", ".join(
                     f'"inner_{table_2_name}"."{column._meta.db_column_name}"'
                     for column in self.columns
                 )
-                return f"""
+                return QueryString(
+                    f"""
                     (
                         SELECT JSON_AGG({m2m_relationship_name}_results)
                         FROM (
@@ -119,13 +126,15 @@ class M2MSelect(Selectable):
                         ) AS "{m2m_relationship_name}_results"
                     ) AS "{m2m_relationship_name}"
                 """
+                )
         elif engine_type == "sqlite":
             if len(self.columns) > 1 or not self.serialisation_safe:
                 column_name = table_2_pk_name
             else:
                 column_name = self.columns[0]._meta.db_column_name
 
-            return f"""
+            return QueryString(
+                f"""
                 (
                     SELECT group_concat(
                         "inner_{table_2_name}"."{column_name}"
@@ -134,6 +143,7 @@ class M2MSelect(Selectable):
                 )
                 AS "{m2m_relationship_name} [M2M]"
             """
+            )
         else:
             raise ValueError(f"{engine_type} is an unrecognised engine type")
 

{piccolo-1.5.2 → piccolo-1.6.0}/piccolo/columns/readable.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import typing as t
 from dataclasses import dataclass
 
-from piccolo.columns.base import Selectable
+from piccolo.querystring import QueryString, Selectable
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.columns.base import Column
@@ -27,25 +27,27 @@ class Readable(Selectable):
             i._meta.get_full_name(with_alias=False) for i in self.columns
         )
 
-    def _get_string(self, operator: str) -> str:
-        return (
+    def _get_string(self, operator: str) -> QueryString:
+        return QueryString(
             f"{operator}('{self.template}', {self._columns_string}) AS "
             f"{self.output_name}"
         )
 
     @property
-    def sqlite_string(self) -> str:
+    def sqlite_string(self) -> QueryString:
         return self._get_string(operator="PRINTF")
 
     @property
-    def postgres_string(self) -> str:
+    def postgres_string(self) -> QueryString:
         return self._get_string(operator="FORMAT")
 
     @property
-    def cockroach_string(self) -> str:
+    def cockroach_string(self) -> QueryString:
         return self._get_string(operator="FORMAT")
 
-    def get_select_string(self, engine_type: str, with_alias=True) -> str:
+    def get_select_string(
+        self, engine_type: str, with_alias=True
+    ) -> QueryString:
         try:
             return getattr(self, f"{engine_type}_string")
         except AttributeError as e:

{piccolo-1.5.2 → piccolo-1.6.0}/piccolo/query/__init__.py

@@ -1,9 +1,9 @@
 from piccolo.columns.combination import WhereRaw
 
 from .base import Query
+from .functions.aggregate import Avg, Max, Min, Sum
 from .methods import (
     Alter,
-    Avg,
     Count,
     Create,
     CreateIndex,
@@ -11,12 +11,9 @@ from .methods import (
     DropIndex,
     Exists,
     Insert,
-    Max,
-    Min,
     Objects,
     Raw,
     Select,
-    Sum,
     TableExists,
     Update,
 )

piccolo-1.6.0/piccolo/query/functions/__init__.py

@@ -0,0 +1,16 @@
+from .aggregate import Avg, Count, Max, Min, Sum
+from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
+
+__all__ = (
+    "Avg",
+    "Count",
+    "Length",
+    "Lower",
+    "Ltrim",
+    "Max",
+    "Min",
+    "Reverse",
+    "Rtrim",
+    "Sum",
+    "Upper",
+)

piccolo-1.6.0/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-1.6.0/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-1.6.0/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",
+)