piccolo 0.108.0__py3-none-any.whl → 0.110.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "0.108.0"
+__VERSION__ = "0.110.0"

piccolo/apps/asgi/commands/new.py

@@ -10,10 +10,9 @@ from jinja2 import Environment, FileSystemLoader
 
 TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates/app/")
 SERVERS = ["uvicorn", "Hypercorn"]
-ROUTERS = ["starlette", "fastapi", "blacksheep", "xpresso", "starlite"]
+ROUTERS = ["starlette", "fastapi", "blacksheep", "litestar"]
 ROUTER_DEPENDENCIES = {
-    "starlite": ["starlite>=1.46.0"],
-    "xpresso": ["xpresso==0.43.0", "di==0.72.1"],
+    "litestar": ["litestar>=2.0.0a3"],
 }
 
 

piccolo/apps/asgi/commands/templates/app/{_starlite_app.py.jinja → _litestar_app.py.jinja}

@@ -2,13 +2,13 @@ import typing as t
 
 from piccolo.engine import engine_finder
 from piccolo_admin.endpoints import create_admin
-from starlite import Starlite, asgi, delete, get, patch, post
-from starlite.config.static_files import StaticFilesConfig
-from starlite.config.template import TemplateConfig
-from starlite.contrib.jinja import JinjaTemplateEngine
-from starlite.exceptions import NotFoundException
-from starlite.plugins.piccolo_orm import PiccoloORMPlugin
-from starlite.types import Receive, Scope, Send
+from litestar import Litestar, asgi, delete, get, patch, post
+from litestar.static_files import StaticFilesConfig
+from litestar.template import TemplateConfig
+from litestar.contrib.jinja import JinjaTemplateEngine
+from litestar.contrib.piccolo_orm import PiccoloORMPlugin
+from litestar.exceptions import NotFoundException
+from litestar.types import Receive, Scope, Send
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
@@ -71,7 +71,7 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
-app = Starlite(
+app = Litestar(
     route_handlers=[
         admin,
         home,

piccolo/apps/asgi/commands/templates/app/app.py.jinja

@@ -4,8 +4,6 @@
     {% include '_starlette_app.py.jinja' %}
 {% elif router == 'blacksheep' %}
     {% include '_blacksheep_app.py.jinja' %}
-{% elif router == 'xpresso' %}
-    {% include '_xpresso_app.py.jinja' %}
-{% elif router == 'starlite' %}
-    {% include '_starlite_app.py.jinja' %}
+{% elif router == 'litestar' %}
+    {% include '_litestar_app.py.jinja' %}
 {% endif %}

piccolo/apps/asgi/commands/templates/app/home/{_starlite_endpoints.py.jinja → _litestar_endpoints.py.jinja}

@@ -1,7 +1,7 @@
 import os
 
 import jinja2
-from starlite import MediaType, Request, Response, get
+from litestar import MediaType, Request, Response, get
 
 ENVIRONMENT = jinja2.Environment(
     loader=jinja2.FileSystemLoader(
@@ -19,3 +19,4 @@ def home(request: Request) -> Response:
         media_type=MediaType.HTML,
         status_code=200,
     )
+

piccolo/apps/asgi/commands/templates/app/home/endpoints.py.jinja

@@ -2,8 +2,6 @@
     {% include '_starlette_endpoints.py.jinja' %}
 {% elif router == 'blacksheep' %}
     {% include '_blacksheep_endpoints.py.jinja' %}
-{% elif router == 'xpresso' %}
-    {% include '_xpresso_endpoints.py.jinja' %}
-{% elif router == 'starlite' %}
-    {% include '_starlite_endpoints.py.jinja' %}
+{% elif router == 'litestar' %}
+    {% include '_litestar_endpoints.py.jinja' %}
 {% endif %}

piccolo/apps/asgi/commands/templates/app/home/templates/home.html.jinja_raw

@@ -51,12 +51,7 @@
                 <li><a href="/admin/">Admin</a></li>
                 <li><a href="/docs/">Swagger API</a></li>
             </ul>
-            <h3>Xpresso</h3>
-            <ul>
-                <li><a href="/admin/">Admin</a></li>
-                <li><a href="/docs/">Swagger API</a></li>
-            </ul>
-            <h3>Starlite</h3>
+            <h3>Litestar</h3>
             <ul>
                 <li><a href="/admin/">Admin</a></li>
                 <li><a href="/schema/swagger">Swagger API</a></li>

piccolo/apps/playground/commands/run.py

@@ -136,8 +136,7 @@ def populate():
     """
     for _table in reversed(TABLES):
         try:
-            if _table.table_exists().run_sync():
-                _table.alter().drop_table().run_sync()
+            _table.alter().drop_table(if_exists=True).run_sync()
         except Exception as e:
             print(e)
 
@@ -180,13 +179,30 @@ def populate():
     ticket = Ticket(concert=concert.id, price=Decimal("50.0"))
     ticket.save().run_sync()
 
-    discount_code = DiscountCode(code=uuid.uuid4())
-    discount_code.save().run_sync()
+    DiscountCode.insert(
+        *[DiscountCode({DiscountCode.code: uuid.uuid4()}) for _ in range(5)]
+    ).run_sync()
 
-    recording_studio = RecordingStudio(
-        name="Abbey Road", facilities={"restaurant": True, "mixing_desk": True}
-    )
-    recording_studio.save().run_sync()
+    RecordingStudio.insert(
+        RecordingStudio(
+            {
+                RecordingStudio.name: "Abbey Road",
+                RecordingStudio.facilities: {
+                    "restaurant": True,
+                    "mixing_desk": True,
+                },
+            }
+        ),
+        RecordingStudio(
+            {
+                RecordingStudio.name: "Electric Lady",
+                RecordingStudio.facilities: {
+                    "restaurant": False,
+                    "mixing_desk": True,
+                },
+            },
+        ),
+    ).run_sync()
 
 
 def run(

piccolo/columns/base.py

@@ -759,6 +759,51 @@ class Column(Selectable):
         column._alias = name
         return column
 
+    def join_on(self, column: Column) -> ForeignKey:
+        """
+        Joins are typically performed via foreign key columns. For example,
+        here we get the band's name and the manager's name::
+
+            class Manager(Table):
+                name = Varchar()
+
+            class Band(Table):
+                name = Varchar()
+                manager = ForeignKey(Manager)
+
+            >>> await Band.select(Band.name, Band.manager.name)
+
+        The ``join_on`` method lets you join tables even when foreign keys
+        don't exist, by joining on a column in another table.
+
+        For example, here we want to get the manager's email, but no foreign
+        key exists::
+
+            class Manager(Table):
+                name = Varchar(unique=True)
+                email = Varchar()
+
+            class Band(Table):
+                name = Varchar()
+                manager_name = Varchar()
+
+            >>> await Band.select(
+            ...     Band.name,
+            ...     Band.manager_name.join_on(Manager.name).email
+            ... )
+
+        """
+        from piccolo.columns.column_types import ForeignKey
+
+        virtual_foreign_key = ForeignKey(
+            references=column._meta.table, target_column=column
+        )
+        virtual_foreign_key._meta._name = self._meta.name
+        virtual_foreign_key._meta.call_chain = [*self._meta.call_chain]
+        virtual_foreign_key._meta._table = self._meta.table
+        virtual_foreign_key.set_proxy_columns()
+        return virtual_foreign_key
+
     def get_default_value(self) -> t.Any:
         """
         If the column has a default attribute, return it. If it's callable,

piccolo/columns/column_types.py

@@ -1784,7 +1784,7 @@ class ForeignKey(Column):
 
     :param on_update:
         Determines what the database should do when a row has it's primary key
-        updated. If set to ``OnDelete.cascade``, any rows referencing the
+        updated. If set to ``OnUpdate.cascade``, any rows referencing the
         updated row will have their references updated to point to the new
         primary key.
 
@@ -1800,7 +1800,7 @@ class ForeignKey(Column):
 
         .. code-block:: python
 
-            from piccolo.columns import OnDelete
+            from piccolo.columns import OnUpdate
 
             class Band(Table):
                 name = ForeignKey(

piccolo/query/methods/select.py

@@ -353,8 +353,18 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         self.columns_delegate.columns(*_columns)
         return self
 
-    def distinct(self: Self) -> Self:
-        self.distinct_delegate.distinct()
+    def distinct(
+        self: Self, *, on: t.Optional[t.Sequence[Column]] = None
+    ) -> Self:
+        if on is not None and self.engine_type not in (
+            "postgres",
+            "cockroach",
+        ):
+            raise ValueError(
+                "Only Postgres and Cockroach supports DISTINCT ON"
+            )
+
+        self.distinct_delegate.distinct(enabled=True, on=on)
         return self
 
     def group_by(self: Self, *columns: t.Union[Column, str]) -> Self:
@@ -722,17 +732,22 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
 
         #######################################################################
 
-        select = (
-            "SELECT DISTINCT" if self.distinct_delegate._distinct else "SELECT"
-        )
-        query = f"{select} {columns_str} FROM {self.table._meta.tablename}"
+        args: t.List[t.Any] = []
 
-        for join in joins:
-            query += f" {join}"
+        query = "SELECT"
 
-        #######################################################################
+        distinct = self.distinct_delegate._distinct
+        if distinct:
+            if distinct.on:
+                distinct.validate_on(self.order_by_delegate._order_by)
 
-        args: t.List[t.Any] = []
+            query += "{}"
+            args.append(distinct.querystring)
+
+        query += f" {columns_str} FROM {self.table._meta.tablename}"
+
+        for join in joins:
+            query += f" {join}"
 
         if self.as_of_delegate._as_of:
             query += "{}"

piccolo/query/mixins.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import collections.abc
 import itertools
 import typing as t
 from dataclasses import dataclass, field
@@ -18,6 +19,70 @@ if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.table import Table  # noqa
 
 
+class DistinctOnError(ValueError):
+    """
+    Raised when ``DISTINCT ON`` queries are malformed.
+    """
+
+    pass
+
+
+@dataclass
+class Distinct:
+    __slots__ = ("enabled", "on")
+
+    enabled: bool
+    on: t.Optional[t.Sequence[Column]]
+
+    @property
+    def querystring(self) -> QueryString:
+        if self.enabled:
+            if self.on:
+                column_names = ", ".join(
+                    i._meta.get_full_name(with_alias=False) for i in self.on
+                )
+                return QueryString(f" DISTINCT ON ({column_names})")
+            else:
+                return QueryString(" DISTINCT")
+        else:
+            return QueryString(" ALL")
+
+    def validate_on(self, order_by: OrderBy):
+        """
+        When using the `on` argument, the first column must match the first
+        order by column.
+
+        :raises DistinctOnError:
+            If the columns don't match.
+
+        """
+        validated = True
+
+        try:
+            first_order_column = order_by.order_by_items[0].columns[0]
+        except IndexError:
+            validated = False
+        else:
+            if not self.on:
+                validated = False
+            elif isinstance(first_order_column, Column) and not self.on[
+                0
+            ]._equals(first_order_column):
+                validated = False
+
+        if not validated:
+            raise DistinctOnError(
+                "The first `order_by` column must match the first column "
+                "passed to `on`."
+            )
+
+    def __str__(self) -> str:
+        return self.querystring.__str__()
+
+    def copy(self) -> Distinct:
+        return self.__class__(enabled=self.enabled, on=self.on)
+
+
 @dataclass
 class Limit:
     __slots__ = ("number",)
@@ -259,10 +324,19 @@ class AsOfDelegate:
 @dataclass
 class DistinctDelegate:
 
-    _distinct: bool = False
+    _distinct: Distinct = field(
+        default_factory=lambda: Distinct(enabled=False, on=None)
+    )
+
+    def distinct(
+        self, enabled: bool, on: t.Optional[t.Sequence[Column]] = None
+    ):
+        if on and not isinstance(on, collections.abc.Sequence):
+            # Check a sequence is passed in, otherwise the user will get some
+            # unuseful errors later on.
+            raise ValueError("`on` must be a sequence of `Column` instances")
 
-    def distinct(self):
-        self._distinct = True
+        self._distinct = Distinct(enabled=enabled, on=on)
 
 
 @dataclass

piccolo/testing/model_builder.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 import typing as t
 from datetime import date, datetime, time, timedelta
@@ -5,7 +7,7 @@ from decimal import Decimal
 from uuid import UUID
 
 from piccolo.columns import Array, Column
-from piccolo.table import Table
+from piccolo.custom_types import TableInstance
 from piccolo.testing.random_builder import RandomBuilder
 from piccolo.utils.sync import run_sync
 
@@ -27,11 +29,11 @@ class ModelBuilder:
     @classmethod
     async def build(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         persist: bool = True,
         minimal: bool = False,
-    ) -> Table:
+    ) -> TableInstance:
         """
         Build a ``Table`` instance with random data and save async.
         If the ``Table`` has any foreign keys, then the related rows are also
@@ -78,11 +80,11 @@ class ModelBuilder:
     @classmethod
     def build_sync(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         persist: bool = True,
         minimal: bool = False,
-    ) -> Table:
+    ) -> TableInstance:
         """
         A sync wrapper around :meth:`build`.
         """
@@ -98,11 +100,11 @@ class ModelBuilder:
     @classmethod
     async def _build(
         cls,
-        table_class: t.Type[Table],
+        table_class: t.Type[TableInstance],
         defaults: t.Dict[t.Union[Column, str], t.Any] = None,
         minimal: bool = False,
         persist: bool = True,
-    ) -> Table:
+    ) -> TableInstance:
         model = table_class(_ignore_missing=True)
         defaults = {} if not defaults else defaults
 

{piccolo-0.108.0.dist-info → piccolo-0.110.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.108.0
+Version: 0.110.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend
@@ -144,7 +144,7 @@ Let Piccolo scaffold you an ASGI web app, using Piccolo as the ORM:
 piccolo asgi new
 ```
 
-[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/), [Xpresso](https://xpresso-api.dev/) and [Starlite](https://starlite-api.github.io/starlite/) are currently supported.
+[Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [BlackSheep](https://www.neoteroi.dev/blacksheep/) and [Litestar](https://litestar.dev/) are currently supported.
 
 ## Are you a Django user?
 

{piccolo-0.108.0.dist-info → piccolo-0.110.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-piccolo/__init__.py,sha256=FZr7tEUlCrlSc29pMJbdtbg4OqH8TeTmy6jyhpAuJ4U,24
+piccolo/__init__.py,sha256=zz24Vmp-MN5KVpqbveNBFX2-Th4v1ySTLtZmXtwh1cY,24
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=2W2EXXEr-EN1PG8s8xHIWCvU7t7kT004fBChK9CZhzo,5024
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,14 +16,13 @@ piccolo/apps/app/commands/templates/tables.py.jinja,sha256=revzdrvDDwe78VedBKz0z
 piccolo/apps/asgi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/asgi/piccolo_app.py,sha256=7VUvqQJbB-ScO0A62S6MiJmQL9F5DS-SdlqlDLbAblE,217
 piccolo/apps/asgi/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/apps/asgi/commands/new.py,sha256=yuGOGy6bJtqyBlJeaegajWyUqtuN1A3mPXXQhSU6JfE,4160
+piccolo/apps/asgi/commands/new.py,sha256=bcK7xnbmCsP5yapjjvrpdZDBPOc9W_Itdz8ycUc0V4E,4100
 piccolo/apps/asgi/commands/templates/app/README.md.jinja,sha256=As3gNEZt9qcRmTVkjCzNtXJ8r4-3g0fCSe7Q-P39ezI,214
 piccolo/apps/asgi/commands/templates/app/_blacksheep_app.py.jinja,sha256=bgAGe0a9nWk0LAqK3VNDhPcKGqg0z8V-eIX2YmMoZLk,3117
 piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja,sha256=cCmRVAN8gw6zfHBcLI_NxapwN7LGM5QSXM7K94imDh8,2436
+piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja,sha256=e0784WBJSsrAPmDXjVuYfmrUJWLAkQyDxoSDl80ucWQ,2622
 piccolo/apps/asgi/commands/templates/app/_starlette_app.py.jinja,sha256=YvNUlJuTd4mj-pm3WQKbQq3w3x3VfDb_Wz6aQLUsORo,1271
-piccolo/apps/asgi/commands/templates/app/_starlite_app.py.jinja,sha256=RUtYfORvmV5gyKZVvBuR07R9Rf9Ai9fH1c85NYAAtgc,2636
-piccolo/apps/asgi/commands/templates/app/_xpresso_app.py.jinja,sha256=D3D3ScpItr0V4InaqBMFwy4BvnSMI2AM_6E6sKmUjJE,2855
-piccolo/apps/asgi/commands/templates/app/app.py.jinja,sha256=Hsoq3xsCc3yzNFHXV3zRBxrh42J9W04qyVc7FZ7Bg4Y,387
+piccolo/apps/asgi/commands/templates/app/app.py.jinja,sha256=NnpkkIFswR4SUsOrhB6x2rNrDfR_QOaGewRv_mP5zgQ,314
 piccolo/apps/asgi/commands/templates/app/conftest.py.jinja,sha256=ZG1pRVMv3LhIfOsO3_08c_fF3EV4_EApuDHiIFFPJdk,497
 piccolo/apps/asgi/commands/templates/app/main.py.jinja,sha256=azwXyWZGkrIbZv5bZF_4Tvbly7AXkw5yFWGCHYImGeo,421
 piccolo/apps/asgi/commands/templates/app/piccolo_conf.py.jinja,sha256=f9Nb08_yipi0_mDUYrUvVoGCz7MRRS5QjCdUGBHN760,379
@@ -31,15 +30,14 @@ piccolo/apps/asgi/commands/templates/app/piccolo_conf_test.py.jinja,sha256=ZB32I
 piccolo/apps/asgi/commands/templates/app/requirements.txt.jinja,sha256=gR_AvX3YH0bsjkAY28eXNy_D1YuJAvEnT1tGtVzMnnY,152
 piccolo/apps/asgi/commands/templates/app/home/__init__.py.jinja,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/asgi/commands/templates/app/home/_blacksheep_endpoints.py.jinja,sha256=Rri_xzDkl87G5ME74qTxY25cwKIKufuzgkRsy__mNts,510
+piccolo/apps/asgi/commands/templates/app/home/_litestar_endpoints.py.jinja,sha256=mk0LTygP-HOaiWYO4SDnJ3C-WZxLxRFYxUrIYwatAyc,531
 piccolo/apps/asgi/commands/templates/app/home/_starlette_endpoints.py.jinja,sha256=KEjNEUKiZNBIWYAt9EgPHe4yCbkKLtlhaCBce9YI-RQ,498
-piccolo/apps/asgi/commands/templates/app/home/_starlite_endpoints.py.jinja,sha256=D8dT3-hSGYcmCdxIRi-F-YJVa3EQdcbuDo6NZZjbySI,530
-piccolo/apps/asgi/commands/templates/app/home/_xpresso_endpoints.py.jinja,sha256=JO9SCIL2jDAkoop8zPhdTeUt_oP-Zent2KqIt6NAPy4,402
-piccolo/apps/asgi/commands/templates/app/home/endpoints.py.jinja,sha256=dgpHlA8mjmYCnNs5RiToUj3S3u6mZObOVC1VU-jbRCc,351
+piccolo/apps/asgi/commands/templates/app/home/endpoints.py.jinja,sha256=OeRMBHjjxVyGIXAuSLQzl6qsWOmD7-pZcToA3V5gWx4,272
 piccolo/apps/asgi/commands/templates/app/home/piccolo_app.py.jinja,sha256=4gETiW9ukTNsomeJOvrRkqPbToZ_FU0b3LsNIaEYyP8,505
 piccolo/apps/asgi/commands/templates/app/home/tables.py.jinja,sha256=wk34RAsuoFn5iJ4OHlQzUqgatq6QB2G9tFE0BYkaers,197
 piccolo/apps/asgi/commands/templates/app/home/piccolo_migrations/README.md,sha256=ji6UOtHvzHX-eS_qhhKTN36ZXNZ7QwtjwjdE4Qgm35A,59
 piccolo/apps/asgi/commands/templates/app/home/templates/base.html.jinja_raw,sha256=3RqiNuyAap_P-xNK3uhNaQQ6rC365VzPmRqmmXSLO8o,451
-piccolo/apps/asgi/commands/templates/app/home/templates/home.html.jinja_raw,sha256=G7M_jt0ueeW0W-zkt35pFL55tpNtHOaeIuZKHBaD61A,2453
+piccolo/apps/asgi/commands/templates/app/home/templates/home.html.jinja_raw,sha256=u_oXpGzR3o_eCufFPRpjD6iL1SdiixvrmOOeWp7WF10,2278
 piccolo/apps/asgi/commands/templates/app/static/favicon.ico,sha256=IvcgeJHObd9kj2mNIXkJdXYxMU8OaOymyYQWnWfbtHo,7406
 piccolo/apps/asgi/commands/templates/app/static/main.css,sha256=vudarPLglQ6NOgJiNeU2x0yQl0DiWScqb09QZv2wAzM,1056
 piccolo/apps/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -74,7 +72,7 @@ piccolo/apps/migrations/commands/templates/migration.py.jinja,sha256=wMC8RTIcQj3
 piccolo/apps/playground/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/playground/piccolo_app.py,sha256=zs6nGxt-lgUF8nEwI0uDTNZDKQqjZaNDH8le5RqrMNE,222
 piccolo/apps/playground/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-piccolo/apps/playground/commands/run.py,sha256=ee0pbj_panKndmQjyzy_1P1Gp850IITdEcm2nFpk8Nk,6949
+piccolo/apps/playground/commands/run.py,sha256=PaY3ls4C0j0TnVSTY85abv6e2SuTsII0H33HlkXlZzc,7350
 piccolo/apps/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/project/piccolo_app.py,sha256=mT3O0m3QcCfS0oOr3jt0QZ9TX6gUavGPjJeNn2C_fdM,220
 piccolo/apps/project/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,9 +109,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=NbeIeugpr22dgldMEgEav6VNjLlVCubvIKRgu5DzP0E,29838
+piccolo/columns/base.py,sha256=lD3fzhpHCVlfieME2q9gCiHdpJqKNo2Te67HrjUX2c0,31355
 piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,723
-piccolo/columns/column_types.py,sha256=P1zPKkDoXWfI-Qsc7CiAcYF6jB-SbqRPPe7kK5EVsq0,77278
+piccolo/columns/column_types.py,sha256=X0nTvlc8epfcu8Q8uuIBlnHv_R_GTJ58dehC343vNgA,77278
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
 piccolo/columns/indexes.py,sha256=NfNok3v_791jgDlN28KmhP9ZCjl6031BXmjxV3ovXJk,372
 piccolo/columns/m2m.py,sha256=C7IKMg7ik2yE3143Gwdbx3YNB3VrZbltJAlX0XxQwAI,14067
@@ -143,7 +141,7 @@ piccolo/engine/postgres.py,sha256=UvGihQeUgg2MniTN5mABlSMPkBgtQQSmx9QE32uv9SA,18
 piccolo/engine/sqlite.py,sha256=io3fBdXxXjOoSzLgP-HYGKgTDgHIRpmFa7mU6ifbqn8,21915
 piccolo/query/__init__.py,sha256=WkG78nTz4Ww3rE9Pu5tZI130JMVfGnwyghhu97XFk0w,617
 piccolo/query/base.py,sha256=BsrzbeuJo7k-KJn4YlRUibxITw_J7xslbgJg0eVFB8s,15124
-piccolo/query/mixins.py,sha256=_JcvWZ-IQCvIyLsW40VGDItSOH48BRcm-Zd-r1Un71Q,14442
+piccolo/query/mixins.py,sha256=zD13SqgKq613BAcqjSTblT0u9fMyctv_AGS03E7xR0c,16585
 piccolo/query/proxy.py,sha256=Hg5S6tp1EiKD899eYdDKHscFYucHdKtL3YC2GTcL2Jk,1833
 piccolo/query/methods/__init__.py,sha256=_PfGUdOd6AsKq1sqXeZUHhESHE-e1cNpwFr8Lyz7QoY,421
 piccolo/query/methods/alter.py,sha256=gyx4kVF4EiN4sSFjIqcKykxcKB808j1ioa2lKrLdP4Y,14935
@@ -158,11 +156,11 @@ piccolo/query/methods/insert.py,sha256=qmwvPysnrANjubF-F41TtBYKVdy2dHfw_lgD3C_T9
 piccolo/query/methods/objects.py,sha256=CAsZjTzOtD6elMqc2nIK_Ra1GKu7sxHBgcDRh9NAes8,11556
 piccolo/query/methods/raw.py,sha256=VhYpCB52mZk4zqFTsqK5CHKTDGskUjISXTBV7UjohmA,600
 piccolo/query/methods/refresh.py,sha256=P1Eo_HYU_L7kcGM_cvDDgyLi1boCXY7Pc4tv_eDAzvc,2769
-piccolo/query/methods/select.py,sha256=xlHjDnTMsccpQKM6jdDJiVv6rv8o0-R8t4FCG__3-gA,24997
+piccolo/query/methods/select.py,sha256=e7BuECHITRwYJ902NvC5ZHG8tirCljeVoGWzpQYxRts,25379
 piccolo/query/methods/table_exists.py,sha256=rPY20QNdJI9TvKjGyTPVvGGEuD3bDnQim8K1ZurthmU,1211
 piccolo/query/methods/update.py,sha256=0hURc7PQU9NX7QQFJ1XgFJvw3nXYIrWUjE-D_7W5JV4,3625
 piccolo/testing/__init__.py,sha256=pRFSqRInfx95AakOq54atmvqoB-ue073q2aR8u8zR40,83
-piccolo/testing/model_builder.py,sha256=6-s4rzLKj6f0NldrV2L2JQlbqC7mJMn-5mNoAtUwU34,5635
+piccolo/testing/model_builder.py,sha256=_tss3L-n-hwIaygNJ3dVmWvZxXE035h2QdDaLYJhH7c,5734
 piccolo/testing/random_builder.py,sha256=o3Ebzak1AG_3nG1iIYN2ZNn5NKQTRECha4ZEubAl9yQ,2005
 piccolo/utils/__init__.py,sha256=SDFFraauI9Op8dCRkreQv1dwUcab8Mi1eC-n0EwlTy8,36
 piccolo/utils/dictionary.py,sha256=8vRPxgaXadDVhqihP1UxL7nUBgM6Gpe_Eu3xJq7zzGM,1886
@@ -307,6 +305,7 @@ tests/table/test_indexes.py,sha256=GdlPfLmvM0s2fe-4-2XSqQLYYjwsBu5dzf6o7ZvlPj4,1
 tests/table/test_inheritance.py,sha256=s5JIo8hZN7xqOPlZ9EDkkNLo5_kWirsfCJAqaXSHn88,3034
 tests/table/test_insert.py,sha256=8G7TvgZIKqKNDJR0-Ck5gTtzQa0c89OeFNaWf9wPpBk,2274
 tests/table/test_join.py,sha256=tk2r5OUaay9-4U37aj2-qul1XybchBG3xr-k7K_IQh0,14705
+tests/table/test_join_on.py,sha256=NhJRg_7_YQ0o2ox5mF330ZaIvmtq09Xl2lfDTwKtUng,2719
 tests/table/test_metaclass.py,sha256=liJuKArpco1qb3lshSQTwRsqXXZZNgzmFoMDP9r2uHw,2637
 tests/table/test_objects.py,sha256=aEv-y0xkg6UMrWo8rd098ahCI7m177AL3dwU3JNMKRY,7895
 tests/table/test_output.py,sha256=BvALFil1VlWKPmlRiqlrhhiAVXcuj3E-Bg85JMqGNlQ,2984
@@ -314,7 +313,7 @@ tests/table/test_raw.py,sha256=AxT6qB0bEjVbOz6lmGQ9_IiDuEoVmh5c72gzyiatBwo,1683
 tests/table/test_ref.py,sha256=eYNRnYHzNMXuMbV3B1ca5EidpIg4500q6hr1ccuVaso,269
 tests/table/test_refresh.py,sha256=tZktBoUQth3S2_vou5NcKiwOJDFrhF6CIuC7YZ2janw,2694
 tests/table/test_repr.py,sha256=dKdM0HRygvqjmSPz-l95SJQXQ-O18MHUGrcIzzYKrsQ,411
-tests/table/test_select.py,sha256=Dcw-4hbLDv2OvQJ12qFibKJ5CmslUdfQNWds_VuPFhc,34824
+tests/table/test_select.py,sha256=0BdI_gVHIt2eyjWWojFfoLuwL9h5LzCpUAJQzvPl-Zs,39683
 tests/table/test_str.py,sha256=eztWNULcjARR1fr9X5n4tojhDNgDfatVyNHwuYrzHAo,1731
 tests/table/test_table_exists.py,sha256=9Qqwbg6Q3OfasSH4FUqD3z99ExvJqpHSu0pYu7aa998,375
 tests/table/test_update.py,sha256=ZEkIDgQ9PHcAn58dlN4WIHRJm0RENi6AVDsmgLX9Qlw,20342
@@ -341,9 +340,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-0.108.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-0.108.0.dist-info/METADATA,sha256=BcZonQ5WzvdOAcV7m-WHNdwaNRw4ZS5HVsnl_U7o57I,5169
-piccolo-0.108.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
-piccolo-0.108.0.dist-info/entry_points.txt,sha256=zYhu-YNtMlh2N_8wptCS8YWKOgc81UPL3Ji5gly8ouc,47
-piccolo-0.108.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-0.108.0.dist-info/RECORD,,
+piccolo-0.110.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-0.110.0.dist-info/METADATA,sha256=zYj2Bfz5piDmp3d4zRoKWGva_r4JNZ7dPVLAEpGWvfw,5113
+piccolo-0.110.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
+piccolo-0.110.0.dist-info/entry_points.txt,sha256=zYhu-YNtMlh2N_8wptCS8YWKOgc81UPL3Ji5gly8ouc,47
+piccolo-0.110.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-0.110.0.dist-info/RECORD,,

tests/table/test_join_on.py

@@ -0,0 +1,107 @@
+from unittest import TestCase
+
+from piccolo.columns import Varchar
+from piccolo.table import Table
+
+
+class Manager(Table):
+    name = Varchar(unique=True)
+    email = Varchar(unique=True)
+
+
+class Band(Table):
+    name = Varchar(unique=True)
+    manager_name = Varchar()
+
+
+class Concert(Table):
+    title = Varchar()
+    band_name = Varchar()
+
+
+class TestJoinOn(TestCase):
+
+    tables = [Manager, Band, Concert]
+
+    def setUp(self):
+        for table in self.tables:
+            table.create_table().run_sync()
+
+        Manager.insert(
+            Manager(name="Guido", email="guido@example.com"),
+            Manager(name="Maz", email="maz@example.com"),
+            Manager(name="Graydon", email="graydon@example.com"),
+        ).run_sync()
+
+        Band.insert(
+            Band(name="Pythonistas", manager_name="Guido"),
+            Band(name="Rustaceans", manager_name="Graydon"),
+        ).run_sync()
+
+        Concert.insert(
+            Concert(
+                title="Rockfest",
+                band_name="Pythonistas",
+            ),
+        ).run_sync()
+
+    def tearDown(self):
+        for table in self.tables:
+            table.alter().drop_table().run_sync()
+
+    def test_join_on(self):
+        """
+        Do a simple join between two tables.
+        """
+        query = Band.select(
+            Band.name,
+            Band.manager_name,
+            Band.manager_name.join_on(Manager.name).email.as_alias(
+                "manager_email"
+            ),
+        ).order_by(Band.id)
+
+        response = query.run_sync()
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "name": "Pythonistas",
+                    "manager_name": "Guido",
+                    "manager_email": "guido@example.com",
+                },
+                {
+                    "name": "Rustaceans",
+                    "manager_name": "Graydon",
+                    "manager_email": "graydon@example.com",
+                },
+            ],
+        )
+
+    def test_deeper_join(self):
+        """
+        Do a join between three tables.
+        """
+        response = (
+            Concert.select(
+                Concert.title,
+                Concert.band_name,
+                Concert.band_name.join_on(Band.name)
+                .manager_name.join_on(Manager.name)
+                .email.as_alias("manager_email"),
+            )
+            .order_by(Concert.id)
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "title": "Rockfest",
+                    "band_name": "Pythonistas",
+                    "manager_email": "guido@example.com",
+                }
+            ],
+        )

tests/table/test_select.py

@@ -1,12 +1,15 @@
+import datetime
 from unittest import TestCase
 
 import pytest
 
 from piccolo.apps.user.tables import BaseUser
+from piccolo.columns import Date, Varchar
 from piccolo.columns.combination import WhereRaw
 from piccolo.query import OrderByRaw
 from piccolo.query.methods.select import Avg, Count, Max, Min, SelectRaw, Sum
-from piccolo.table import create_db_tables_sync, drop_db_tables_sync
+from piccolo.query.mixins import DistinctOnError
+from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
 from tests.base import (
     DBTestCase,
     engine_is,
@@ -521,6 +524,27 @@ class TestSelect(DBTestCase):
         response = query.run_sync()
         self.assertEqual(response, [{"name": "Pythonistas"}])
 
+    def test_distinct_on(self):
+        """
+        Make sure the distinct clause works, with the ``on`` param.
+        """
+        self.insert_rows()
+        self.insert_rows()
+
+        query = Band.select(Band.name).where(Band.name == "Pythonistas")
+        self.assertNotIn("DISTINCT", query.__str__())
+
+        response = query.run_sync()
+        self.assertEqual(
+            response, [{"name": "Pythonistas"}, {"name": "Pythonistas"}]
+        )
+
+        query = query.distinct()
+        self.assertIn("DISTINCT", query.__str__())
+
+        response = query.run_sync()
+        self.assertEqual(response, [{"name": "Pythonistas"}])
+
     def test_count_group_by(self):
         """
         Test grouping and counting all rows.
@@ -1237,3 +1261,138 @@ class TestSelectOrderBy(TestCase):
                 {"name": "Rustaceans"},
             ],
         )
+
+
+class Album(Table):
+    band = Varchar()
+    title = Varchar()
+    release_date = Date()
+
+
+class TestDistinctOn(TestCase):
+    def setUp(self):
+        Album.create_table().run_sync()
+
+    def tearDown(self):
+        Album.alter().drop_table().run_sync()
+
+    @engines_only("postgres", "cockroach")
+    def test_distinct_on(self):
+        """
+        Make sure the ``distinct`` method can be used to create a
+        ``DISTINCT ON`` clause.
+        """
+        Album.insert(
+            Album(
+                {
+                    Album.band: "Pythonistas",
+                    Album.title: "P1",
+                    Album.release_date: datetime.date(
+                        year=2022, month=1, day=1
+                    ),
+                }
+            ),
+            Album(
+                {
+                    Album.band: "Pythonistas",
+                    Album.title: "P2",
+                    Album.release_date: datetime.date(
+                        year=2023, month=1, day=1
+                    ),
+                }
+            ),
+            Album(
+                {
+                    Album.band: "Rustaceans",
+                    Album.title: "R1",
+                    Album.release_date: datetime.date(
+                        year=2022, month=1, day=1
+                    ),
+                }
+            ),
+            Album(
+                {
+                    Album.band: "Rustaceans",
+                    Album.title: "R2",
+                    Album.release_date: datetime.date(
+                        year=2023, month=1, day=1
+                    ),
+                }
+            ),
+            Album(
+                {
+                    Album.band: "C-Sharps",
+                    Album.title: "C1",
+                    Album.release_date: datetime.date(
+                        year=2022, month=1, day=1
+                    ),
+                }
+            ),
+            Album(
+                {
+                    Album.band: "C-Sharps",
+                    Album.title: "C2",
+                    Album.release_date: datetime.date(
+                        year=2023, month=1, day=1
+                    ),
+                }
+            ),
+        ).run_sync()
+
+        # Get the most recent album for each band.
+        query = (
+            Album.select(Album.band, Album.title)
+            .distinct(on=[Album.band])
+            .order_by(Album.band)
+            .order_by(Album.release_date, ascending=False)
+        )
+        self.assertIn("DISTINCT ON", query.__str__())
+        response = query.run_sync()
+
+        self.assertEqual(
+            response,
+            [
+                {"band": "C-Sharps", "title": "C2"},
+                {"band": "Pythonistas", "title": "P2"},
+                {"band": "Rustaceans", "title": "R2"},
+            ],
+        )
+
+    @engines_only("sqlite")
+    def test_distinct_on_sqlite(self):
+        """
+        SQLite doesn't support ``DISTINCT ON``, so a ``ValueError`` should be
+        raised.
+        """
+        with self.assertRaises(ValueError) as manager:
+            Album.select().distinct(on=[Album.band])
+
+        self.assertEqual(
+            manager.exception.__str__(),
+            "Only Postgres and Cockroach supports DISTINCT ON",
+        )
+
+    @engines_only("postgres", "cockroach")
+    def test_distinct_on_error(self):
+        """
+        If we pass in something other than a sequence of columns, it should
+        raise a ValueError.
+        """
+        with self.assertRaises(ValueError) as manager:
+            Album.select().distinct(on=Album.band)
+
+        self.assertEqual(
+            manager.exception.__str__(),
+            "`on` must be a sequence of `Column` instances",
+        )
+
+    @engines_only("postgres", "cockroach")
+    def test_distinct_on_order_by_error(self):
+        """
+        The first column passed to `order_by` must match the first column
+        passed to `on`, otherwise an exception is raised.
+        """
+        with self.assertRaises(DistinctOnError):
+            Album.select().distinct(on=[Album.band]).order_by(
+                Album.release_date
+            ).run_sync()

piccolo/apps/asgi/commands/templates/app/_xpresso_app.py.jinja

@@ -1,113 +0,0 @@
-import typing as t
-from contextlib import asynccontextmanager
-
-from piccolo.engine import engine_finder
-from piccolo.utils.pydantic import create_pydantic_model
-from piccolo_admin.endpoints import create_admin
-from starlette.staticfiles import StaticFiles
-from xpresso import App, FromJson, FromPath, HTTPException, Operation, Path
-from xpresso.routing.mount import Mount
-
-from home.endpoints import home
-from home.piccolo_app import APP_CONFIG
-from home.tables import Task
-
-TaskModelIn: t.Any = create_pydantic_model(table=Task, model_name="TaskModelIn")
-TaskModelOut: t.Any = create_pydantic_model(
-    table=Task, include_default_columns=True, model_name="TaskModelOut"
-)
-
-
-async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task.id)
-
-
-async def create_task(task_model: FromJson[TaskModelIn]) -> TaskModelOut:
-    task = Task(**task_model.dict())
-    await task.save()
-    return task.to_dict()
-
-
-async def update_task(
-    task_id: FromPath[int], task_model: FromJson[TaskModelIn]
-) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
-    if not task:
-        raise HTTPException(status_code=404)
-
-    for key, value in task_model.dict().items():
-        setattr(task, key, value)
-
-    await task.save()
-
-    return task.to_dict()
-
-
-async def delete_task(task_id: FromPath[int]):
-    task = await Task.objects().get(Task.id == task_id)
-    if not task:
-        raise HTTPException(status_code=404)
-
-    await task.remove()
-
-    return {}
-
-
-@asynccontextmanager
-async def lifespan():
-    await open_database_connection_pool()
-    try:
-        yield
-    finally:
-        await close_database_connection_pool()
-
-
-app = App(
-    routes=[
-        Path(
-            "/",
-            get=Operation(
-                home,
-                include_in_schema=False,
-            ),
-        ),
-        Mount(
-            "/admin/",
-            create_admin(
-                tables=APP_CONFIG.table_classes,
-                # Required when running under HTTPS:
-                # allowed_hosts=['my_site.com']
-            ),
-        ),
-        Path(
-            "/tasks/",
-            get=tasks,
-            post=create_task,
-            tags=["Task"],
-        ),
-        Path(
-            "/tasks/{task_id}/",
-            put=update_task,
-            delete=delete_task,
-            tags=["Task"],
-        ),
-        Mount("/static/", StaticFiles(directory="static")),
-    ],
-    lifespan=lifespan,
-)
-
-
-async def open_database_connection_pool():
-    try:
-        engine = engine_finder()
-        await engine.start_connection_pool()
-    except Exception:
-        print("Unable to connect to the database")
-
-
-async def close_database_connection_pool():
-    try:
-        engine = engine_finder()
-        await engine.close_connection_pool()
-    except Exception:
-        print("Unable to connect to the database")

piccolo/apps/asgi/commands/templates/app/home/_xpresso_endpoints.py.jinja

@@ -1,20 +0,0 @@
-import os
-
-import jinja2
-from xpresso.responses import HTMLResponse
-
-ENVIRONMENT = jinja2.Environment(
-    loader=jinja2.FileSystemLoader(
-        searchpath=os.path.join(os.path.dirname(__file__), "templates")
-    )
-)
-
-
-async def home():
-    template = ENVIRONMENT.get_template("home.html.jinja")
-
-    content = template.render(
-        title="Piccolo + ASGI",
-    )
-
-    return HTMLResponse(content)