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

piccolo/__init__.py

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

piccolo/apps/asgi/commands/new.py

@@ -12,7 +12,7 @@ TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates/app/")
 SERVERS = ["uvicorn", "Hypercorn"]
 ROUTERS = ["starlette", "fastapi", "blacksheep", "litestar"]
 ROUTER_DEPENDENCIES = {
-    "litestar": ["litestar>=2.0.0a3"],
+    "litestar": ["litestar==2.0.0a3"],
 }
 
 

piccolo/query/methods/insert.py

@@ -2,9 +2,16 @@ from __future__ import annotations
 
 import typing as t
 
-from piccolo.custom_types import TableInstance
+from typing_extensions import Literal
+
+from piccolo.custom_types import Combinable, TableInstance
 from piccolo.query.base import Query
-from piccolo.query.mixins import AddDelegate, ReturningDelegate
+from piccolo.query.mixins import (
+    AddDelegate,
+    OnConflictAction,
+    OnConflictDelegate,
+    ReturningDelegate,
+)
 from piccolo.querystring import QueryString
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -15,7 +22,7 @@ if t.TYPE_CHECKING:  # pragma: no cover
 class Insert(
     t.Generic[TableInstance], Query[TableInstance, t.List[t.Dict[str, t.Any]]]
 ):
-    __slots__ = ("add_delegate", "returning_delegate")
+    __slots__ = ("add_delegate", "on_conflict_delegate", "returning_delegate")
 
     def __init__(
         self, table: t.Type[TableInstance], *instances: TableInstance, **kwargs
@@ -23,6 +30,7 @@ class Insert(
         super().__init__(table, **kwargs)
         self.add_delegate = AddDelegate()
         self.returning_delegate = ReturningDelegate()
+        self.on_conflict_delegate = OnConflictDelegate()
         self.add(*instances)
 
     ###########################################################################
@@ -36,6 +44,43 @@ class Insert(
         self.returning_delegate.returning(columns)
         return self
 
+    def on_conflict(
+        self: Self,
+        target: t.Optional[t.Union[str, Column, t.Tuple[Column, ...]]] = None,
+        action: t.Union[
+            OnConflictAction, Literal["DO NOTHING", "DO UPDATE"]
+        ] = OnConflictAction.do_nothing,
+        values: t.Optional[
+            t.Sequence[t.Union[Column, t.Tuple[Column, t.Any]]]
+        ] = None,
+        where: t.Optional[Combinable] = None,
+    ) -> Self:
+        if (
+            self.engine_type == "sqlite"
+            and self.table._meta.db.get_version_sync() < 3.24
+        ):
+            raise NotImplementedError(
+                "SQLite versions lower than 3.24 don't support ON CONFLICT"
+            )
+
+        if (
+            self.engine_type in ("postgres", "cockroach")
+            and len(self.on_conflict_delegate._on_conflict.on_conflict_items)
+            == 1
+        ):
+            raise NotImplementedError(
+                "Postgres and Cockroach only support a single ON CONFLICT "
+                "clause."
+            )
+
+        self.on_conflict_delegate.on_conflict(
+            target=target,
+            action=action,
+            values=values,
+            where=where,
+        )
+        return self
+
     ###########################################################################
 
     def _raw_response_callback(self, results):
@@ -70,16 +115,27 @@ class Insert(
 
         engine_type = self.engine_type
 
+        on_conflict = self.on_conflict_delegate._on_conflict
+        if on_conflict.on_conflict_items:
+            querystring = QueryString(
+                "{}{}",
+                querystring,
+                on_conflict.querystring,
+                query_type="insert",
+                table=self.table,
+            )
+
         if engine_type in ("postgres", "cockroach") or (
             engine_type == "sqlite"
             and self.table._meta.db.get_version_sync() >= 3.35
         ):
-            if self.returning_delegate._returning:
+            returning = self.returning_delegate._returning
+            if returning:
                 return [
                     QueryString(
                         "{}{}",
                         querystring,
-                        self.returning_delegate._returning.querystring,
+                        returning.querystring,
                         query_type="insert",
                         table=self.table,
                     )

piccolo/query/methods/objects.py

@@ -230,6 +230,8 @@ class Objects(
         return self
 
     def as_of(self, interval: str = "-1s") -> Objects:
+        if self.engine_type != "cockroach":
+            raise NotImplementedError("Only CockroachDB supports AS OF")
         self.as_of_delegate.as_of(interval)
         return self
 

piccolo/query/methods/select.py

@@ -356,13 +356,8 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
     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"
-            )
+        if on is not None and self.engine_type == "sqlite":
+            raise NotImplementedError("SQLite doesn't support DISTINCT ON")
 
         self.distinct_delegate.distinct(enabled=True, on=on)
         return self
@@ -377,6 +372,9 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         return self
 
     def as_of(self: Self, interval: str = "-1s") -> Self:
+        if self.engine_type != "cockroach":
+            raise NotImplementedError("Only CockroachDB supports AS OF")
+
         self.as_of_delegate.as_of(interval)
         return self
 

piccolo/query/mixins.py

@@ -7,6 +7,8 @@ import typing as t
 from dataclasses import dataclass, field
 from enum import Enum, auto
 
+from typing_extensions import Literal
+
 from piccolo.columns import And, Column, Or, Where
 from piccolo.columns.column_types import ForeignKey
 from piccolo.custom_types import Combinable
@@ -581,9 +583,10 @@ class OffsetDelegate:
 
     Typically used in conjunction with order_by and limit.
 
-    Example usage:
+    Example usage::
+
+        .offset(100)
 
-    .offset(100)
     """
 
     _offset: t.Optional[Offset] = None
@@ -613,12 +616,173 @@ class GroupBy:
 @dataclass
 class GroupByDelegate:
     """
-    Used to group results - needed when doing aggregation.
+    Used to group results - needed when doing aggregation::
+
+        .group_by(Band.name)
 
-    .group_by(Band.name)
     """
 
     _group_by: t.Optional[GroupBy] = None
 
     def group_by(self, *columns: Column):
         self._group_by = GroupBy(columns=columns)
+
+
+class OnConflictAction(str, Enum):
+    """
+    Specify which action to take on conflict.
+    """
+
+    do_nothing = "DO NOTHING"
+    do_update = "DO UPDATE"
+
+
+@dataclass
+class OnConflictItem:
+    target: t.Optional[t.Union[str, Column, t.Tuple[Column, ...]]] = None
+    action: t.Optional[OnConflictAction] = None
+    values: t.Optional[
+        t.Sequence[t.Union[Column, t.Tuple[Column, t.Any]]]
+    ] = None
+    where: t.Optional[Combinable] = None
+
+    @property
+    def target_string(self) -> str:
+        target = self.target
+        assert target
+
+        def to_string(value) -> str:
+            if isinstance(value, Column):
+                return f'"{value._meta.db_column_name}"'
+            else:
+                raise ValueError("OnConflict.target isn't a valid type")
+
+        if isinstance(target, str):
+            return f'ON CONSTRAINT "{target}"'
+        elif isinstance(target, Column):
+            return f"({to_string(target)})"
+        elif isinstance(target, tuple):
+            columns_str = ", ".join([to_string(i) for i in target])
+            return f"({columns_str})"
+        else:
+            raise ValueError("OnConflict.target isn't a valid type")
+
+    @property
+    def action_string(self) -> QueryString:
+        action = self.action
+        if isinstance(action, OnConflictAction):
+            if action == OnConflictAction.do_nothing:
+                return QueryString(OnConflictAction.do_nothing.value)
+            elif action == OnConflictAction.do_update:
+                values = []
+                query = f"{OnConflictAction.do_update.value} SET"
+
+                if not self.values:
+                    raise ValueError("No values specified for `on conflict`")
+
+                for value in self.values:
+                    if isinstance(value, Column):
+                        column_name = value._meta.db_column_name
+                        query += f' "{column_name}"=EXCLUDED."{column_name}",'
+                    elif isinstance(value, tuple):
+                        column = value[0]
+                        value_ = value[1]
+                        if isinstance(column, Column):
+                            column_name = column._meta.db_column_name
+                        else:
+                            raise ValueError("Unsupported column type")
+
+                        query += f' "{column_name}"={{}},'
+                        values.append(value_)
+
+                return QueryString(query.rstrip(","), *values)
+
+        raise ValueError("OnConflict.action isn't a valid type")
+
+    @property
+    def querystring(self) -> QueryString:
+        query = " ON CONFLICT"
+        values = []
+
+        if self.target:
+            query += f" {self.target_string}"
+
+        if self.action:
+            query += " {}"
+            values.append(self.action_string)
+
+        if self.where:
+            query += " WHERE {}"
+            values.append(self.where.querystring)
+
+        return QueryString(query, *values)
+
+    def __str__(self) -> str:
+        return self.querystring.__str__()
+
+
+@dataclass
+class OnConflict:
+    """
+    Multiple `ON CONFLICT` statements are allowed - which is why we have this
+    parent class.
+    """
+
+    on_conflict_items: t.List[OnConflictItem] = field(default_factory=list)
+
+    @property
+    def querystring(self) -> QueryString:
+        query = "".join("{}" for i in self.on_conflict_items)
+        return QueryString(
+            query, *[i.querystring for i in self.on_conflict_items]
+        )
+
+    def __str__(self) -> str:
+        return self.querystring.__str__()
+
+
+@dataclass
+class OnConflictDelegate:
+    """
+    Used with insert queries to specify what to do when a query fails due to
+    a constraint::
+
+        .on_conflict(action='DO NOTHING')
+
+        .on_conflict(action='DO UPDATE', values=[Band.popularity])
+
+        .on_conflict(action='DO UPDATE', values=[(Band.popularity, 1)])
+
+    """
+
+    _on_conflict: OnConflict = field(default_factory=OnConflict)
+
+    def on_conflict(
+        self,
+        target: t.Optional[t.Union[str, Column, t.Tuple[Column, ...]]] = None,
+        action: t.Union[
+            OnConflictAction, Literal["DO NOTHING", "DO UPDATE"]
+        ] = OnConflictAction.do_nothing,
+        values: t.Optional[
+            t.Sequence[t.Union[Column, t.Tuple[Column, t.Any]]]
+        ] = None,
+        where: t.Optional[Combinable] = None,
+    ):
+        action_: OnConflictAction
+        if isinstance(action, OnConflictAction):
+            action_ = action
+        elif isinstance(action, str):
+            action_ = OnConflictAction(action.upper())
+        else:
+            raise ValueError("Unrecognised `on conflict` action.")
+
+        if where and action_ == OnConflictAction.do_nothing:
+            raise ValueError(
+                "The `where` option can only be used with DO NOTHING."
+            )
+
+        self._on_conflict.on_conflict_items.append(
+            OnConflictItem(
+                target=target, action=action_, values=values, where=where
+            )
+        )

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

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

@@ -1,4 +1,4 @@
-piccolo/__init__.py,sha256=zz24Vmp-MN5KVpqbveNBFX2-Th4v1ySTLtZmXtwh1cY,24
+piccolo/__init__.py,sha256=FD-yuKtGvNyh8GH2WGzOJQnF7v7XuGXevze_b_yuJ4g,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,7 +16,7 @@ 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=bcK7xnbmCsP5yapjjvrpdZDBPOc9W_Itdz8ycUc0V4E,4100
+piccolo/apps/asgi/commands/new.py,sha256=P64IwftHM3uHkUObl6tVXmBfsTaFon7im6LEgDFwg10,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
@@ -141,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=zD13SqgKq613BAcqjSTblT0u9fMyctv_AGS03E7xR0c,16585
+piccolo/query/mixins.py,sha256=N6HAN_A4kd-PC07q3OIzwrkRy3ZwGMtB2xLueYefBSM,21649
 piccolo/query/proxy.py,sha256=Hg5S6tp1EiKD899eYdDKHscFYucHdKtL3YC2GTcL2Jk,1833
 piccolo/query/methods/__init__.py,sha256=_PfGUdOd6AsKq1sqXeZUHhESHE-e1cNpwFr8Lyz7QoY,421
 piccolo/query/methods/alter.py,sha256=gyx4kVF4EiN4sSFjIqcKykxcKB808j1ioa2lKrLdP4Y,14935
@@ -152,11 +152,11 @@ piccolo/query/methods/delete.py,sha256=JkDMkee3LVKtZdAS2AQnNFkDbxcus3xq7kbDAu6Fk
 piccolo/query/methods/drop_index.py,sha256=SOX5wfm-Tbb5TrN6kaLRVHUWdEhyrmCQwF33JfWdtwE,1043
 piccolo/query/methods/exists.py,sha256=LAeWpGKEMYZJeNGEcxbucxWDxAjn84jduNz2ZjzukPc,1181
 piccolo/query/methods/indexes.py,sha256=_Io7vy_yIjPYHIw1ILGhAiWQAEOIe-Lwn3mEELw8mOc,1083
-piccolo/query/methods/insert.py,sha256=qmwvPysnrANjubF-F41TtBYKVdy2dHfw_lgD3C_T9Kw,2998
-piccolo/query/methods/objects.py,sha256=CAsZjTzOtD6elMqc2nIK_Ra1GKu7sxHBgcDRh9NAes8,11556
+piccolo/query/methods/insert.py,sha256=BwIJb1g0PFqMws060Wn0uSAK1ybLbkK9mKUfOOmzroc,4716
+piccolo/query/methods/objects.py,sha256=i71GHPJZJcRpgM6e69Vk7vVcCuAFokOsMnR5EXbZq1w,11673
 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=e7BuECHITRwYJ902NvC5ZHG8tirCljeVoGWzpQYxRts,25379
+piccolo/query/methods/select.py,sha256=6LVVNJEIooB0cQItI77rxwURsA88ifTOm1dj-wFlHRY,25406
 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
@@ -303,7 +303,7 @@ tests/table/test_exists.py,sha256=AHvhodkRof7PVd4IDdGQ2nyOj_1Cag1Rpg1H84s4jU0,28
 tests/table/test_from_dict.py,sha256=I4PMxuzgkgi3-adaw9Gr3u5tQHexc31Vrq7RSPcPcJs,840
 tests/table/test_indexes.py,sha256=GdlPfLmvM0s2fe-4-2XSqQLYYjwsBu5dzf6o7ZvlPj4,1990
 tests/table/test_inheritance.py,sha256=s5JIo8hZN7xqOPlZ9EDkkNLo5_kWirsfCJAqaXSHn88,3034
-tests/table/test_insert.py,sha256=8G7TvgZIKqKNDJR0-Ck5gTtzQa0c89OeFNaWf9wPpBk,2274
+tests/table/test_insert.py,sha256=LeYNvApZ2T-PZ9fseINLZ6hnrY5F1Axe3QHqidwzbAQ,13668
 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
@@ -313,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=0BdI_gVHIt2eyjWWojFfoLuwL9h5LzCpUAJQzvPl-Zs,39683
+tests/table/test_select.py,sha256=sjSzJfHaYG8Zrg2jXbp7eNprqXilMzDHDxpM3k0BCFg,39678
 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
@@ -340,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.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,,
+piccolo-0.111.0.dist-info/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-0.111.0.dist-info/METADATA,sha256=mtWcL-RTGmGGTTQuSJT8wm_KPoQerNk1MHE_8It-4Mo,5113
+piccolo-0.111.0.dist-info/WHEEL,sha256=00yskusixUoUt5ob_CiUp6LsnN5lqzTJpoqOFg_FVIc,92
+piccolo-0.111.0.dist-info/entry_points.txt,sha256=zYhu-YNtMlh2N_8wptCS8YWKOgc81UPL3Ji5gly8ouc,47
+piccolo-0.111.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-0.111.0.dist-info/RECORD,,

tests/table/test_insert.py

@@ -1,8 +1,22 @@
+import sqlite3
+from unittest import TestCase
+
 import pytest
 
-from tests.base import DBTestCase, engine_version_lt, is_running_sqlite
+from piccolo.columns import Integer, Varchar
+from piccolo.query.methods.insert import OnConflictAction
+from piccolo.table import Table
+from piccolo.utils.lazy_loader import LazyLoader
+from tests.base import (
+    DBTestCase,
+    engine_version_lt,
+    engines_only,
+    is_running_sqlite,
+)
 from tests.example_apps.music.tables import Band, Manager
 
+asyncpg = LazyLoader("asyncpg", globals(), "asyncpg")
+
 
 class TestInsert(DBTestCase):
     def test_insert(self):
@@ -76,3 +90,385 @@ class TestInsert(DBTestCase):
         )
 
         self.assertListEqual(response, [{"manager_name": "Maz"}])
+
+
+@pytest.mark.skipif(
+    is_running_sqlite() and engine_version_lt(3.24),
+    reason="SQLite version not supported",
+)
+class TestOnConflict(TestCase):
+    class Band(Table):
+        name = Varchar(unique=True)
+        popularity = Integer()
+
+    def setUp(self) -> None:
+        Band = self.Band
+        Band.create_table().run_sync()
+        self.band = Band({Band.name: "Pythonistas", Band.popularity: 1000})
+        self.band.save().run_sync()
+
+    def tearDown(self) -> None:
+        Band = self.Band
+        Band.alter().drop_table().run_sync()
+
+    def test_do_update(self):
+        """
+        Make sure that `DO UPDATE` works.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        Band.insert(
+            Band(name=self.band.name, popularity=new_popularity)
+        ).on_conflict(
+            target=Band.name,
+            action="DO UPDATE",
+            values=[Band.popularity],
+        ).run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": self.band.name,
+                    "popularity": new_popularity,  # changed
+                }
+            ],
+        )
+
+    def test_do_update_tuple_values(self):
+        """
+        Make sure we can use tuples in ``values``.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+        new_name = "Rustaceans"
+
+        Band.insert(
+            Band(
+                id=self.band.id,
+                name=new_name,
+                popularity=new_popularity,
+            )
+        ).on_conflict(
+            action="DO UPDATE",
+            target=Band.id,
+            values=[
+                (Band.name, new_name),
+                (Band.popularity, new_popularity + 2000),
+            ],
+        ).run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": new_name,
+                    "popularity": new_popularity + 2000,
+                }
+            ],
+        )
+
+    def test_do_update_no_values(self):
+        """
+        Make sure that `DO UPDATE` with no `values` raises an exception.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        with self.assertRaises(ValueError) as manager:
+            Band.insert(
+                Band(name=self.band.name, popularity=new_popularity)
+            ).on_conflict(
+                target=Band.name,
+                action="DO UPDATE",
+            ).run_sync()
+
+        self.assertEqual(
+            manager.exception.__str__(),
+            "No values specified for `on conflict`",
+        )
+
+    @engines_only("postgres", "cockroach")
+    def test_target_tuple(self):
+        """
+        Make sure that a composite unique constraint can be used as a target.
+
+        We only run it on Postgres and Cockroach because we use ALTER TABLE
+        to add a contraint, which SQLite doesn't support.
+        """
+        Band = self.Band
+
+        # Add a composite unique constraint:
+        Band.raw(
+            "ALTER TABLE band ADD CONSTRAINT id_name_unique UNIQUE (id, name)"
+        ).run_sync()
+
+        Band.insert(
+            Band(
+                id=self.band.id,
+                name=self.band.name,
+                popularity=self.band.popularity,
+            )
+        ).on_conflict(
+            target=(Band.id, Band.name),
+            action="DO NOTHING",
+        ).run_sync()
+
+    @engines_only("postgres", "cockroach")
+    def test_target_string(self):
+        """
+        Make sure we can explicitly specify the name of target constraint using
+        a string.
+
+        We just test this on Postgres for now, as we have to get the constraint
+        name from the database.
+        """
+        Band = self.Band
+
+        constraint_name = Band.raw(
+            """
+            SELECT constraint_name
+            FROM information_schema.constraint_column_usage
+            WHERE column_name = 'name'
+                AND table_name = 'band';
+            """
+        ).run_sync()[0]["constraint_name"]
+
+        query = Band.insert(Band(name=self.band.name)).on_conflict(
+            target=constraint_name,
+            action="DO NOTHING",
+        )
+        self.assertIn(f'ON CONSTRAINT "{constraint_name}"', query.__str__())
+        query.run_sync()
+
+    def test_violate_non_target(self):
+        """
+        Make sure that if we specify a target constraint, but violate a
+        different constraint, then we still get the error.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        with self.assertRaises(Exception) as manager:
+            Band.insert(
+                Band(name=self.band.name, popularity=new_popularity)
+            ).on_conflict(
+                target=Band.id,  # Target the primary key instead.
+                action="DO UPDATE",
+                values=[Band.popularity],
+            ).run_sync()
+
+        if self.Band._meta.db.engine_type in ("postgres", "cockroach"):
+            self.assertIsInstance(
+                manager.exception, asyncpg.exceptions.UniqueViolationError
+            )
+        elif self.Band._meta.db.engine_type == "sqlite":
+            self.assertIsInstance(manager.exception, sqlite3.IntegrityError)
+
+    def test_where(self):
+        """
+        Make sure we can pass in a `where` argument.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        query = Band.insert(
+            Band(name=self.band.name, popularity=new_popularity)
+        ).on_conflict(
+            target=Band.name,
+            action="DO UPDATE",
+            values=[Band.popularity],
+            where=Band.popularity < self.band.popularity,
+        )
+
+        self.assertIn(
+            f'WHERE "band"."popularity" < {self.band.popularity}',
+            query.__str__(),
+        )
+
+        query.run_sync()
+
+    def test_do_nothing_where(self):
+        """
+        Make sure an error is raised if `where` is used with `DO NOTHING`.
+        """
+        Band = self.Band
+
+        with self.assertRaises(ValueError) as manager:
+            Band.insert(Band()).on_conflict(
+                action="DO NOTHING",
+                where=Band.popularity < self.band.popularity,
+            )
+
+        self.assertEqual(
+            manager.exception.__str__(),
+            "The `where` option can only be used with DO NOTHING.",
+        )
+
+    def test_do_nothing(self):
+        """
+        Make sure that `DO NOTHING` works.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        Band.insert(
+            Band(name="Pythonistas", popularity=new_popularity)
+        ).on_conflict(action="DO NOTHING").run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": self.band.name,
+                    "popularity": self.band.popularity,
+                }
+            ],
+        )
+
+    @engines_only("sqlite")
+    def test_multiple_do_update(self):
+        """
+        Make sure multiple `ON CONFLICT` clauses work for SQLite.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        # Conflicting with name - should update.
+        Band.insert(
+            Band(name="Pythonistas", popularity=new_popularity)
+        ).on_conflict(action="DO NOTHING", target=Band.id).on_conflict(
+            action="DO UPDATE", target=Band.name, values=[Band.popularity]
+        ).run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": self.band.name,
+                    "popularity": new_popularity,  # changed
+                }
+            ],
+        )
+
+    @engines_only("sqlite")
+    def test_multiple_do_nothing(self):
+        """
+        Make sure multiple `ON CONFLICT` clauses work for SQLite.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+
+        # Conflicting with ID - should be ignored.
+        Band.insert(
+            Band(
+                id=self.band.id,
+                name="Pythonistas",
+                popularity=new_popularity,
+            )
+        ).on_conflict(action="DO NOTHING", target=Band.id).on_conflict(
+            action="DO UPDATE",
+            target=Band.name,
+            values=[Band.popularity],
+        ).run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": self.band.name,
+                    "popularity": self.band.popularity,
+                }
+            ],
+        )
+
+    @engines_only("postgres", "cockroach")
+    def test_mutiple_error(self):
+        """
+        Postgres and Cockroach don't support multiple `ON CONFLICT` clauses.
+        """
+        with self.assertRaises(NotImplementedError) as manager:
+            Band = self.Band
+
+            Band.insert(Band()).on_conflict(action="DO NOTHING").on_conflict(
+                action="DO UPDATE",
+            ).run_sync()
+
+        assert manager.exception.__str__() == (
+            "Postgres and Cockroach only support a single ON CONFLICT clause."
+        )
+
+    def test_all_columns(self):
+        """
+        We can use ``all_columns`` instead of specifying the ``values``
+        manually.
+        """
+        Band = self.Band
+
+        new_popularity = self.band.popularity + 1000
+        new_name = "Rustaceans"
+
+        # Conflicting with ID - should be ignored.
+        q = Band.insert(
+            Band(
+                id=self.band.id,
+                name=new_name,
+                popularity=new_popularity,
+            )
+        ).on_conflict(
+            action="DO UPDATE",
+            target=Band.id,
+            values=Band.all_columns(),
+        )
+        q.run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": new_name,
+                    "popularity": new_popularity,
+                }
+            ],
+        )
+
+    def test_enum(self):
+        """
+        A string literal can be passed in, or an enum, to determine the action.
+        Make sure that the enum works.
+        """
+        Band = self.Band
+
+        Band.insert(
+            Band(
+                id=self.band.id,
+                name=self.band.name,
+                popularity=self.band.popularity,
+            )
+        ).on_conflict(action=OnConflictAction.do_nothing).run_sync()
+
+        self.assertListEqual(
+            Band.select().run_sync(),
+            [
+                {
+                    "id": self.band.id,
+                    "name": self.band.name,
+                    "popularity": self.band.popularity,
+                }
+            ],
+        )

tests/table/test_select.py

@@ -1364,12 +1364,12 @@ class TestDistinctOn(TestCase):
         SQLite doesn't support ``DISTINCT ON``, so a ``ValueError`` should be
         raised.
         """
-        with self.assertRaises(ValueError) as manager:
+        with self.assertRaises(NotImplementedError) as manager:
             Album.select().distinct(on=[Album.band])
 
         self.assertEqual(
             manager.exception.__str__(),
-            "Only Postgres and Cockroach supports DISTINCT ON",
+            "SQLite doesn't support DISTINCT ON",
         )
 
     @engines_only("postgres", "cockroach")