piccolo 1.18.0__py3-none-any.whl → 1.19.1__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.18.0"
+__VERSION__ = "1.19.1"

piccolo/apps/asgi/commands/new.py

@@ -12,10 +12,10 @@ TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates/app/")
 SERVERS = ["uvicorn", "Hypercorn", "granian"]
 ROUTER_DEPENDENCIES = {
     "starlette": ["starlette"],
-    "fastapi": ["fastapi>=0.112.1"],
+    "fastapi": ["fastapi"],
     "blacksheep": ["blacksheep"],
     "litestar": ["litestar"],
-    "esmerald": ["esmerald==3.3.0"],
+    "esmerald": ["esmerald"],
     "lilya": ["lilya"],
 }
 ROUTERS = list(ROUTER_DEPENDENCIES.keys())

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

@@ -1,20 +1,18 @@
 import typing as t
 
-from piccolo_admin.endpoints import create_admin
-from piccolo_api.crud.serializers import create_pydantic_model
-from piccolo.engine import engine_finder
-
 from blacksheep.server import Application
 from blacksheep.server.bindings import FromJSON
-from blacksheep.server.responses import json
 from blacksheep.server.openapi.v3 import OpenAPIHandler
+from blacksheep.server.responses import json
 from openapidocs.v3 import Info
+from piccolo.engine import engine_finder
+from piccolo_admin.endpoints import create_admin
+from piccolo_api.crud.serializers import create_pydantic_model
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
-
 app = Application()
 
 app.mount(
@@ -47,7 +45,7 @@ TaskModelPartial: t.Any = create_pydantic_model(
 
 @app.router.get("/tasks/")
 async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task.id)
+    return await Task.select().order_by(Task._meta.primary_key, ascending=False)
 
 
 @app.router.post("/tasks/")
@@ -58,10 +56,8 @@ async def create_task(task_model: FromJSON[TaskModelIn]) -> TaskModelOut:
 
 
 @app.router.put("/tasks/{task_id}/")
-async def put_task(
-    task_id: int, task_model: FromJSON[TaskModelIn]
-) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+async def put_task(task_id: int, task_model: FromJSON[TaskModelIn]) -> TaskModelOut:
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return json({}, status=404)
 
@@ -77,7 +73,7 @@ async def put_task(
 async def patch_task(
     task_id: int, task_model: FromJSON[TaskModelPartial]
 ) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return json({}, status=404)
 
@@ -92,7 +88,7 @@ async def patch_task(
 
 @app.router.delete("/tasks/{task_id}/")
 async def delete_task(task_id: int):
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         return json({}, status=404)
 

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

@@ -1,23 +1,21 @@
 import typing as t
-
 from pathlib import Path
 
-from piccolo.utils.pydantic import create_pydantic_model
-from piccolo.engine import engine_finder
-from piccolo_admin.endpoints import create_admin
-
 from esmerald import (
+    APIView,
     Esmerald,
-    Include,
     Gateway,
+    Include,
     JSONResponse,
-    APIView,
+    delete,
     get,
     post,
     put,
-    delete
 )
 from esmerald.config import StaticFilesConfig
+from piccolo.engine import engine_finder
+from piccolo.utils.pydantic import create_pydantic_model
+from piccolo_admin.endpoints import create_admin
 
 from home.endpoints import home
 from home.piccolo_app import APP_CONFIG
@@ -40,14 +38,9 @@ async def close_database_connection_pool():
         print("Unable to connect to the database")
 
 
-TaskModelIn: t.Any = create_pydantic_model(
-    table=Task,
-    model_name='TaskModelIn'
-)
+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'
+    table=Task, include_default_columns=True, model_name="TaskModelOut"
 )
 
 
@@ -57,19 +50,17 @@ class TaskAPIView(APIView):
 
     @get("/")
     async def tasks(self) -> t.List[TaskModelOut]:
-        return await Task.select().order_by(Task.id)
-
+        return await Task.select().order_by(Task._meta.primary_key, ascending=False)
 
-    @post('/')
+    @post("/")
     async def create_task(self, payload: TaskModelIn) -> TaskModelOut:
         task = Task(**payload.dict())
         await task.save()
         return task.to_dict()
 
-
-    @put('/{task_id}')
+    @put("/{task_id}")
     async def update_task(self, payload: TaskModelIn, task_id: int) -> TaskModelOut:
-        task = await Task.objects().get(Task.id == task_id)
+        task = await Task.objects().get(Task._meta.primary_key == task_id)
         if not task:
             return JSONResponse({}, status_code=404)
 
@@ -80,10 +71,9 @@ class TaskAPIView(APIView):
 
         return task.to_dict()
 
-
-    @delete('/{task_id}')
+    @delete("/{task_id}")
     async def delete_task(self, task_id: int) -> None:
-        task = await Task.objects().get(Task.id == task_id)
+        task = await Task.objects().get(Task._meta.primary_key == task_id)
         if not task:
             return JSONResponse({}, status_code=404)
 

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

@@ -1,15 +1,14 @@
-from piccolo_admin.endpoints import create_admin
-from piccolo_api.crud.endpoints import PiccoloCRUD
-from piccolo.engine import engine_finder
-from lilya.routing import Path, Include
 from lilya.apps import Lilya
+from lilya.routing import Include, Path
 from lilya.staticfiles import StaticFiles
+from piccolo.engine import engine_finder
+from piccolo_admin.endpoints import create_admin
+from piccolo_api.crud.endpoints import PiccoloCRUD
 
 from home.endpoints import HomeController
 from home.piccolo_app import APP_CONFIG
 from home.tables import Task
 
-
 app = Lilya(
     routes=[
         Path("/", HomeController),
@@ -19,10 +18,10 @@ app = Lilya(
                 tables=APP_CONFIG.table_classes,
                 # Required when running under HTTPS:
                 # allowed_hosts=['my_site.com']
-            )
+            ),
         ),
         Include("/static/", StaticFiles(directory="static")),
-        Include("/tasks/", PiccoloCRUD(table=Task))
+        Include("/tasks/", PiccoloCRUD(table=Task)),
     ],
 )
 

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

@@ -1,8 +1,5 @@
 import typing as t
 
-from home.endpoints import home
-from home.piccolo_app import APP_CONFIG
-from home.tables import Task
 from litestar import Litestar, asgi, delete, get, patch, post
 from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar.exceptions import NotFoundException
@@ -10,8 +7,19 @@ from litestar.static_files import StaticFilesConfig
 from litestar.template import TemplateConfig
 from litestar.types import Receive, Scope, Send
 from piccolo.engine import engine_finder
-from piccolo.utils.pydantic import create_pydantic_model
 from piccolo_admin.endpoints import create_admin
+from pydantic import BaseModel
+
+from home.endpoints import home
+from home.piccolo_app import APP_CONFIG
+from home.tables import Task
+
+"""
+NOTE: `create_pydantic_model` is not compatible with Litestar
+version higher than 2.11.0. If you are using Litestar<=2.11.0, 
+you can use `create_pydantic_model` as in other asgi templates
+
+from piccolo.utils.pydantic import create_pydantic_model
 
 TaskModelIn: t.Any = create_pydantic_model(
     table=Task,
@@ -22,6 +30,18 @@ TaskModelOut: t.Any = create_pydantic_model(
     include_default_columns=True,
     model_name="TaskModelOut",
 )
+"""
+
+
+class TaskModelIn(BaseModel):
+    name: str
+    completed: bool = False
+
+
+class TaskModelOut(BaseModel):
+    id: int
+    name: str
+    completed: bool = False
 
 
 # mounting Piccolo Admin
@@ -32,31 +52,32 @@ async def admin(scope: "Scope", receive: "Receive", send: "Send") -> None:
 
 @get("/tasks", tags=["Task"])
 async def tasks() -> t.List[TaskModelOut]:
-    return await Task.select().order_by(Task.id, ascending=False)
+    tasks = await Task.select().order_by(Task._meta.primary_key, ascending=False)
+    return [TaskModelOut(**task) for task in tasks]
 
 
 @post("/tasks", tags=["Task"])
 async def create_task(data: TaskModelIn) -> TaskModelOut:
-    task = Task(**data.dict())
+    task = Task(**data.model_dump())
     await task.save()
-    return task.to_dict()
+    return TaskModelOut(**task.to_dict())
 
 
 @patch("/tasks/{task_id:int}", tags=["Task"])
 async def update_task(task_id: int, data: TaskModelIn) -> TaskModelOut:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         raise NotFoundException("Task does not exist")
-    for key, value in data.dict().items():
+    for key, value in data.model_dump().items():
         setattr(task, key, value)
 
     await task.save()
-    return task.to_dict()
+    return TaskModelOut(**task.to_dict())
 
 
 @delete("/tasks/{task_id:int}", tags=["Task"])
 async def delete_task(task_id: int) -> None:
-    task = await Task.objects().get(Task.id == task_id)
+    task = await Task.objects().get(Task._meta.primary_key == task_id)
     if not task:
         raise NotFoundException("Task does not exist")
     await task.remove()

piccolo/columns/m2m.py

@@ -384,8 +384,12 @@ class M2MGetRelated:
             .output(as_list=True)
         )
 
-        results = await secondary_table.objects().where(
-            secondary_table._meta.primary_key.is_in(ids)
+        results = (
+            await secondary_table.objects().where(
+                secondary_table._meta.primary_key.is_in(ids)
+            )
+            if len(ids) > 0
+            else []
         )
 
         return results

piccolo/query/methods/objects.py

@@ -13,6 +13,8 @@ from piccolo.query.mixins import (
     CallbackDelegate,
     CallbackType,
     LimitDelegate,
+    LockRowsDelegate,
+    LockStrength,
     OffsetDelegate,
     OrderByDelegate,
     OrderByRaw,
@@ -250,6 +252,7 @@ class Objects(
         "callback_delegate",
         "prefetch_delegate",
         "where_delegate",
+        "lock_rows_delegate",
     )
 
     def __init__(
@@ -269,6 +272,7 @@ class Objects(
         self.prefetch_delegate = PrefetchDelegate()
         self.prefetch(*prefetch)
         self.where_delegate = WhereDelegate()
+        self.lock_rows_delegate = LockRowsDelegate()
 
     def output(self: Self, load_json: bool = False) -> Self:
         self.output_delegate.output(
@@ -328,6 +332,26 @@ class Objects(
         self.limit_delegate.limit(1)
         return First[TableInstance](query=self)
 
+    def lock_rows(
+        self: Self,
+        lock_strength: t.Union[
+            LockStrength,
+            t.Literal[
+                "UPDATE",
+                "NO KEY UPDATE",
+                "KEY SHARE",
+                "SHARE",
+            ],
+        ] = LockStrength.update,
+        nowait: bool = False,
+        skip_locked: bool = False,
+        of: t.Tuple[type[Table], ...] = (),
+    ) -> Self:
+        self.lock_rows_delegate.lock_rows(
+            lock_strength, nowait, skip_locked, of
+        )
+        return self
+
     def get(self, where: Combinable) -> Get[TableInstance]:
         self.where_delegate.where(where)
         self.limit_delegate.limit(1)
@@ -378,6 +402,7 @@ class Objects(
             "offset_delegate",
             "output_delegate",
             "order_by_delegate",
+            "lock_rows_delegate",
         ):
             setattr(select, attr, getattr(self, attr))
 

piccolo/query/methods/select.py

@@ -19,6 +19,8 @@ from piccolo.query.mixins import (
     DistinctDelegate,
     GroupByDelegate,
     LimitDelegate,
+    LockRowsDelegate,
+    LockStrength,
     OffsetDelegate,
     OrderByDelegate,
     OrderByRaw,
@@ -150,6 +152,7 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         "output_delegate",
         "callback_delegate",
         "where_delegate",
+        "lock_rows_delegate",
     )
 
     def __init__(
@@ -174,6 +177,7 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         self.output_delegate = OutputDelegate()
         self.callback_delegate = CallbackDelegate()
         self.where_delegate = WhereDelegate()
+        self.lock_rows_delegate = LockRowsDelegate()
 
         self.columns(*columns_list)
 
@@ -219,6 +223,26 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         self.offset_delegate.offset(number)
         return self
 
+    def lock_rows(
+        self: Self,
+        lock_strength: t.Union[
+            LockStrength,
+            t.Literal[
+                "UPDATE",
+                "NO KEY UPDATE",
+                "KEY SHARE",
+                "SHARE",
+            ],
+        ] = LockStrength.update,
+        nowait: bool = False,
+        skip_locked: bool = False,
+        of: t.Tuple[type[Table], ...] = (),
+    ) -> Self:
+        self.lock_rows_delegate.lock_rows(
+            lock_strength, nowait, skip_locked, of
+        )
+        return self
+
     async def _splice_m2m_rows(
         self,
         response: t.List[t.Dict[str, t.Any]],
@@ -618,6 +642,16 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
             query += "{}"
             args.append(self.offset_delegate._offset.querystring)
 
+        if self.lock_rows_delegate._lock_rows:
+            if engine_type == "sqlite":
+                raise NotImplementedError(
+                    "SQLite doesn't support row locking e.g. SELECT ... FOR "
+                    "UPDATE"
+                )
+
+            query += "{}"
+            args.append(self.lock_rows_delegate._lock_rows.querystring)
+
         querystring = QueryString(query, *args)
 
         return [querystring]

piccolo/query/mixins.py

@@ -784,3 +784,91 @@ class OnConflictDelegate:
                 target=target, action=action_, values=values, where=where
             )
         )
+
+
+class LockStrength(str, Enum):
+    """
+    Specify lock strength
+
+    https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE
+    """
+
+    update = "UPDATE"
+    no_key_update = "NO KEY UPDATE"
+    share = "SHARE"
+    key_share = "KEY SHARE"
+
+
+@dataclass
+class LockRows:
+    __slots__ = ("lock_strength", "nowait", "skip_locked", "of")
+
+    lock_strength: LockStrength
+    nowait: bool
+    skip_locked: bool
+    of: t.Tuple[t.Type[Table], ...]
+
+    def __post_init__(self):
+        if not isinstance(self.lock_strength, LockStrength):
+            raise TypeError("lock_strength must be a LockStrength")
+        if not isinstance(self.nowait, bool):
+            raise TypeError("nowait must be a bool")
+        if not isinstance(self.skip_locked, bool):
+            raise TypeError("skip_locked must be a bool")
+        if not isinstance(self.of, tuple) or not all(
+            hasattr(x, "_meta") for x in self.of
+        ):
+            raise TypeError("of must be a tuple of Table")
+        if self.nowait and self.skip_locked:
+            raise TypeError(
+                "The nowait option cannot be used with skip_locked"
+            )
+
+    @property
+    def querystring(self) -> QueryString:
+        sql = f" FOR {self.lock_strength.value}"
+        if self.of:
+            tables = ", ".join(
+                i._meta.get_formatted_tablename() for i in self.of
+            )
+            sql += " OF " + tables
+        if self.nowait:
+            sql += " NOWAIT"
+        if self.skip_locked:
+            sql += " SKIP LOCKED"
+
+        return QueryString(sql)
+
+    def __str__(self) -> str:
+        return self.querystring.__str__()
+
+
+@dataclass
+class LockRowsDelegate:
+
+    _lock_rows: t.Optional[LockRows] = None
+
+    def lock_rows(
+        self,
+        lock_strength: t.Union[
+            LockStrength,
+            t.Literal[
+                "UPDATE",
+                "NO KEY UPDATE",
+                "KEY SHARE",
+                "SHARE",
+            ],
+        ] = LockStrength.update,
+        nowait=False,
+        skip_locked=False,
+        of: t.Tuple[type[Table], ...] = (),
+    ):
+        lock_strength_: LockStrength
+        if isinstance(lock_strength, LockStrength):
+            lock_strength_ = lock_strength
+        elif isinstance(lock_strength, str):
+            lock_strength_ = LockStrength(lock_strength.upper())
+        else:
+            raise ValueError("Unrecognised `lock_strength` value.")
+
+        self._lock_rows = LockRows(lock_strength_, nowait, skip_locked, of)

{piccolo-1.18.0.dist-info → piccolo-1.19.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.18.0
+Version: 1.19.1
 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.18.0.dist-info → piccolo-1.19.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-piccolo/__init__.py,sha256=QE23QxQ71q70fSQ-ah5y_ldAqWh6zl7J9GsIUi8fHIk,23
+piccolo/__init__.py,sha256=JP09HcvsWvSb_xYAg-Jfrxz8qqh31rbqbIN3dcneflw,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,13 +17,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=Y9-uw9BdrL_wY_zJhKVTNuVHIE6hDa52YcDgBBA2yII,4248
+piccolo/apps/asgi/commands/new.py,sha256=xrN9RJ0Lnz54qY_rxqA9Z2SS4kC_0RXdYYW7tXmGgIo,4232
 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/_esmerald_app.py.jinja,sha256=S-oYY6OFhwJA8PEYnrklQUkqtot3aXTmd7QGrW8Ufn4,2670
+piccolo/apps/asgi/commands/templates/app/_blacksheep_app.py.jinja,sha256=IKOql1G5wrEKm5qErlizOmrwYKlnxkm-d8NY5uVg9KA,3186
+piccolo/apps/asgi/commands/templates/app/_esmerald_app.py.jinja,sha256=nTzXc5IJLl_al1FuzG5AnaA1vSn-ipMurpPK7BibmB8,2710
 piccolo/apps/asgi/commands/templates/app/_fastapi_app.py.jinja,sha256=mKnYfUOnYyWJA1jFoRLCUOGQlK6imaxx_1qaauGjeeQ,2627
-piccolo/apps/asgi/commands/templates/app/_lilya_app.py.jinja,sha256=8rV1p-POGHkFIqvHvlE5wWwWPZweuSnMJhwreLMgLo8,1259
-piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja,sha256=oMH5KXoEYhf9qgXNj2Kepc6prps1MQECufdUduaiwe4,2815
+piccolo/apps/asgi/commands/templates/app/_lilya_app.py.jinja,sha256=PUph5Jj_AXVpxXZmpUzzHXogUchU8vjKBL_7WvgrfCU,1260
+piccolo/apps/asgi/commands/templates/app/_litestar_app.py.jinja,sha256=VCY4FoA7YlEhtjWB09XWQqi8GgL36VQwGGBpSXUDO5o,3349
 piccolo/apps/asgi/commands/templates/app/_starlette_app.py.jinja,sha256=vHcAzsS9I3OevYoznwZp8zucI4OEyUjj-EOAtscmlSE,1443
 piccolo/apps/asgi/commands/templates/app/app.py.jinja,sha256=gROY-LbHl8NtHDM_ntkI7Rjcbtg2ypDZ1FunBvpdjE4,458
 piccolo/apps/asgi/commands/templates/app/conftest.py.jinja,sha256=ZG1pRVMv3LhIfOsO3_08c_fF3EV4_EApuDHiIFFPJdk,497
@@ -120,7 +120,7 @@ piccolo/columns/choices.py,sha256=-HNQuk9vMmVZIPZ5PMeXGTfr23o4nzKPSAkvcG1k0y8,72
 piccolo/columns/column_types.py,sha256=X_ZsA0C4WBNVonV2OsizRdt1osMshgtQ3Ob6JN-amfg,83485
 piccolo/columns/combination.py,sha256=vMXC2dfY7pvnCFhsT71XFVyb4gdQzfRsCMaiduu04Ss,6900
 piccolo/columns/indexes.py,sha256=NfNok3v_791jgDlN28KmhP9ZCjl6031BXmjxV3ovXJk,372
-piccolo/columns/m2m.py,sha256=17NY0wU7ta2rUTHYUkeA2HQhTDlJ_lyv9FxqvJiiUbY,14602
+piccolo/columns/m2m.py,sha256=QMeSOnm4DT2cG9U5jC6sOZ6z9DxCWwDyZMSqk0wR2q4,14682
 piccolo/columns/readable.py,sha256=hganxUPfIK5ZXn-qgteBxsOJfBJucgr9U0QLsLFYcuI,1562
 piccolo/columns/reference.py,sha256=n4SW5CGrUSwsRk2Pm7UbikmKdUHuJ2D5OobQ7Mea1vQ,3669
 piccolo/columns/defaults/__init__.py,sha256=7hpB13baEJgc1zbZjRKDFr-5hltxM2VGj8KnKfOiS8c,145
@@ -147,7 +147,7 @@ piccolo/engine/postgres.py,sha256=DekL3KafCdzSAEQ6_EgOiUB1ERXh2xpePYwI9QvmN-c,18
 piccolo/engine/sqlite.py,sha256=KwJc3UttBP_8qSREbLJshqEfROF17ENf0Ju9BwI5_so,25236
 piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
 piccolo/query/base.py,sha256=iI9Fv3oOw7T4ZWZvRKRwdtClvQtSaAepslH24vwxZVA,14616
-piccolo/query/mixins.py,sha256=EFEFb9It4y1mR6_JXLn139h5M9KgeP750STYy5M4MLs,21951
+piccolo/query/mixins.py,sha256=X9HEYnj6uOjgTkGr4vgqTwN_dokJPzVagwbFx385atQ,24468
 piccolo/query/proxy.py,sha256=Yq4jNc7IWJvdeO3u7_7iPyRy2WhVj8KsIUcIYHBIi9Q,1839
 piccolo/query/functions/__init__.py,sha256=pZkzOIh7Sg9HPNOeegOwAS46Oxt31ATlSVmwn-lxCbc,605
 piccolo/query/functions/aggregate.py,sha256=OdjDjr_zyD4S9UbrZ2C3V5mz4OT2sIfAFAdTGr4WL54,4248
@@ -166,10 +166,10 @@ piccolo/query/methods/drop_index.py,sha256=5x3vHpoOmQ1SMhj6L7snKXX6M9l9j1E1PFSO6
 piccolo/query/methods/exists.py,sha256=lTMjtrFPFygZmaPV3sfQKXc3K0sVqJ2S6PDc3fRK6YQ,1203
 piccolo/query/methods/indexes.py,sha256=J-QUqaBJwpgahskUH0Cu0Mq7zEKcfVAtDsUVIVX-C4c,943
 piccolo/query/methods/insert.py,sha256=ssLJ_wn08KnOwwr7t-VILyn1P4hrvM63CfPIcAJWT5k,4701
-piccolo/query/methods/objects.py,sha256=XE49RFeInx_RzRD40xzBA5IfmXPmDvKKC6Ql9FV8ntE,13223
+piccolo/query/methods/objects.py,sha256=kWHSgnXFVYe-x6tIHstbZvZic6mQCCGES-L_2Icbg-I,13910
 piccolo/query/methods/raw.py,sha256=wQWR8b-yA_Gr-5lqRMZe9BOAAMBAw8CqTx37qVYvM1A,987
 piccolo/query/methods/refresh.py,sha256=wg1zghKfwz-VmqK4uWa4GNMiDtK-skTqow591Hb3ONM,5854
-piccolo/query/methods/select.py,sha256=UH-y2g3Ub7bEowfLObrrhw0W-HepTXWCmuMPhk13roE,21406
+piccolo/query/methods/select.py,sha256=jNR7CsEPUarffYMsXytKm7iScrQ_nqpRX-5mTPrXfjg,22414
 piccolo/query/methods/table_exists.py,sha256=0yb3n6Jd2ovSBWlZ-gl00K4E7Jnbj7J8qAAX5d7hvNk,1259
 piccolo/query/methods/update.py,sha256=LfWqIXEl1aecc0rkVssTFmwyD6wXGhlKcTrUVhtlEsw,3705
 piccolo/testing/__init__.py,sha256=pRFSqRInfx95AakOq54atmvqoB-ue073q2aR8u8zR40,83
@@ -273,7 +273,7 @@ tests/columns/test_timestamptz.py,sha256=P7zblPC6Fjjdk6iOhVUGIKnFFzbbUPVNSY98qbu
 tests/columns/test_uuid.py,sha256=taFYNvRZjQztMPbTQHYtwQutvcLnKPt6_aUxsf2o04Q,372
 tests/columns/test_varchar.py,sha256=fbwBdimHoGaylfrqkFIgQ5m2q80umSoUNHIwofM6j_c,721
 tests/columns/m2m/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/columns/m2m/base.py,sha256=uH92ECQuY5AjpQXPySwrlruZPZzB4LH2V2FUSXmHRLQ,14563
+tests/columns/m2m/base.py,sha256=QOFeiTu7NPSsBju4ZW3up2utFr1dI5HMhhi2A1MG21o,15016
 tests/columns/m2m/test_m2m.py,sha256=0ObmIHUJF6CZoNBznc5xXVr5_BbGBqOmWwtpg8IcPt4,13055
 tests/columns/m2m/test_m2m_schema.py,sha256=oxu7eAjFFpDjnq9Eq-5OTNmlnsEIMFWx18OItfpVs-s,339
 tests/conf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -339,7 +339,7 @@ tests/table/test_raw.py,sha256=9PTvYngQi41nYd5lKzkJdTqsEcwrdOXcvZjq-W26CwQ,1683
 tests/table/test_ref.py,sha256=eYNRnYHzNMXuMbV3B1ca5EidpIg4500q6hr1ccuVaso,269
 tests/table/test_refresh.py,sha256=-BaLS6fZiR2RtQaFa7D9WGBjrbrss1-tt5xz1NE_m8E,9250
 tests/table/test_repr.py,sha256=uahz3_GffGQrf2mDE-4-Pu4AmSLBAyso6-9rbohCl58,446
-tests/table/test_select.py,sha256=jgeiahIlNFVijxYb3a54g1sJWVfH3llaYrsTBmdicrs,40390
+tests/table/test_select.py,sha256=PcLRtHGEZfYNB0Qm2b9P6NFJOH2lWvviRjsr1cEmsMQ,41503
 tests/table/test_str.py,sha256=eztWNULcjARR1fr9X5n4tojhDNgDfatVyNHwuYrzHAo,1731
 tests/table/test_table_exists.py,sha256=upv2e9UD32V2QZOShzmcw0reMqRbYiX_jxWx57p25jg,1082
 tests/table/test_update.py,sha256=Cqi0xX3kEuJ0k-x_emPGB3arXuGWZ9e3CJ3HPFnw9Zw,20505
@@ -368,9 +368,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.18.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
-piccolo-1.18.0.dist-info/METADATA,sha256=_lAgMQsJ-zW7SJkRvz-KQhmrog7hhhBxojwopzFTA_4,5178
-piccolo-1.18.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-piccolo-1.18.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.18.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.18.0.dist-info/RECORD,,
+piccolo-1.19.1.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.19.1.dist-info/METADATA,sha256=owDJXe8zA0Tiloy78LB-2NPyDCxfM7qfFWOeDnXGNO8,5178
+piccolo-1.19.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+piccolo-1.19.1.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.19.1.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.19.1.dist-info/RECORD,,

tests/columns/m2m/base.py

@@ -434,6 +434,22 @@ class M2MBase:
 
         self.assertEqual([i.name for i in genres], ["Rock", "Folk"])
 
+    def test_get_m2m_no_rows(self):
+        """
+        If there are no matching objects, then an empty list should be
+        returned.
+
+        https://github.com/piccolo-orm/piccolo/issues/1090
+
+        """
+        band = Band.objects().get(Band.name == "Pythonistas").run_sync()
+        assert band is not None
+
+        Genre.delete(force=True).run_sync()
+
+        genres = band.get_m2m(Band.genres).run_sync()
+        self.assertEqual(genres, [])
+
     def test_remove_m2m(self):
         """
         Make sure we can remove related items via the joining table.

tests/table/test_select.py

@@ -1028,6 +1028,40 @@ class TestSelect(DBTestCase):
             response, [{"name": "Pythonistas", "popularity_log": 3.0}]
         )
 
+    @pytest.mark.skipif(
+        is_running_sqlite(),
+        reason="SQLite doesn't support SELECT ... FOR UPDATE.",
+    )
+    def test_lock_rows(self):
+        """
+        Make sure the for_update clause works.
+        """
+        self.insert_rows()
+
+        query = Band.select()
+        self.assertNotIn("FOR UPDATE", query.__str__())
+
+        query = query.lock_rows()
+        self.assertTrue(query.__str__().endswith("FOR UPDATE"))
+
+        query = query.lock_rows(lock_strength="KEY SHARE")
+        self.assertTrue(query.__str__().endswith("FOR KEY SHARE"))
+
+        query = query.lock_rows(skip_locked=True)
+        self.assertTrue(query.__str__().endswith("FOR UPDATE SKIP LOCKED"))
+
+        query = query.lock_rows(nowait=True)
+        self.assertTrue(query.__str__().endswith("FOR UPDATE NOWAIT"))
+
+        query = query.lock_rows(of=(Band,))
+        self.assertTrue(query.__str__().endswith('FOR UPDATE OF "band"'))
+
+        with self.assertRaises(TypeError):
+            query = query.lock_rows(skip_locked=True, nowait=True)
+
+        response = query.run_sync()
+        assert response is not None
+
 
 class TestSelectSecret(TestCase):
     def setUp(self):