piccolo 1.25.0__py3-none-any.whl → 1.26.0__py3-none-any.whl

piccolo/__init__.py

@@ -1 +1 @@
-__VERSION__ = "1.25.0"
+__VERSION__ = "1.26.0"

piccolo/apps/migrations/auto/migration_manager.py

@@ -19,6 +19,7 @@ from piccolo.columns.column_types import ForeignKey, Serial
 from piccolo.engine import engine_finder
 from piccolo.query import Query
 from piccolo.query.base import DDL
+from piccolo.query.constraints import get_fk_constraint_name
 from piccolo.schema import SchemaDDLBase
 from piccolo.table import Table, create_table_class, sort_table_classes
 from piccolo.utils.warnings import colored_warning
@@ -423,8 +424,8 @@ class MigrationManager:
 
     async def _run_query(self, query: t.Union[DDL, Query, SchemaDDLBase]):
         """
-        If MigrationManager is not in the preview mode,
-         executes the queries. else, prints the query.
+        If MigrationManager is in preview mode then it just print the query
+        instead of executing it.
         """
         if self.preview:
             await self._print_query(query)
@@ -534,6 +535,39 @@ class MigrationManager:
 
                 ###############################################################
 
+                on_delete = params.get("on_delete")
+                on_update = params.get("on_update")
+                if on_delete is not None or on_update is not None:
+                    existing_table = await self.get_table_from_snapshot(
+                        table_class_name=table_class_name,
+                        app_name=self.app_name,
+                    )
+
+                    fk_column = existing_table._meta.get_column_by_name(
+                        alter_column.column_name
+                    )
+
+                    assert isinstance(fk_column, ForeignKey)
+
+                    # First drop the existing foreign key constraint
+                    constraint_name = await get_fk_constraint_name(
+                        column=fk_column
+                    )
+                    await self._run_query(
+                        _Table.alter().drop_constraint(
+                            constraint_name=constraint_name
+                        )
+                    )
+
+                    # Then add a new foreign key constraint
+                    await self._run_query(
+                        _Table.alter().add_foreign_key_constraint(
+                            column=fk_column,
+                            on_delete=on_delete,
+                            on_update=on_update,
+                        )
+                    )
+
                 null = params.get("null")
                 if null is not None:
                     await self._run_query(

piccolo/apps/schema/commands/generate.py

@@ -501,6 +501,8 @@ async def get_fk_triggers(
         Any Table subclass - just used to execute raw queries on the database.
 
     """
+    # TODO - Move this query to `piccolo.query.constraints` or use:
+    # `piccolo.query.constraints.referential_constraints`
     triggers = await table_class.raw(
         (
             "SELECT tc.constraint_name, "
@@ -537,23 +539,6 @@ async def get_fk_triggers(
     )
 
 
-ONDELETE_MAP = {
-    "NO ACTION": OnDelete.no_action,
-    "RESTRICT": OnDelete.restrict,
-    "CASCADE": OnDelete.cascade,
-    "SET NULL": OnDelete.set_null,
-    "SET DEFAULT": OnDelete.set_default,
-}
-
-ONUPDATE_MAP = {
-    "NO ACTION": OnUpdate.no_action,
-    "RESTRICT": OnUpdate.restrict,
-    "CASCADE": OnUpdate.cascade,
-    "SET NULL": OnUpdate.set_null,
-    "SET DEFAULT": OnUpdate.set_default,
-}
-
-
 async def get_constraints(
     table_class: t.Type[Table], tablename: str, schema_name: str = "public"
 ) -> TableConstraints:
@@ -765,8 +750,8 @@ async def create_table_class_from_db(
                     column_name, constraint_table.name
                 )
                 if trigger:
-                    kwargs["on_update"] = ONUPDATE_MAP[trigger.on_update]
-                    kwargs["on_delete"] = ONDELETE_MAP[trigger.on_delete]
+                    kwargs["on_update"] = OnUpdate(trigger.on_update)
+                    kwargs["on_delete"] = OnDelete(trigger.on_delete)
                 else:
                     output_schema.trigger_warnings.append(
                         f"{tablename}.{column_name}"

piccolo/query/constraints.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+
+from piccolo.columns import ForeignKey
+from piccolo.columns.base import OnDelete, OnUpdate
+
+
+async def get_fk_constraint_name(column: ForeignKey) -> str:
+    """
+    Checks what the foreign key constraint is called in the database.
+    """
+
+    table = column._meta.table
+
+    if table._meta.db.engine_type == "sqlite":
+        # TODO - add the query for SQLite
+        raise ValueError("SQLite isn't currently supported.")
+
+    schema = table._meta.schema or "public"
+    table_name = table._meta.tablename
+    column_name = column._meta.db_column_name
+
+    constraints = await table.raw(
+        """
+        SELECT
+            kcu.constraint_name AS fk_constraint_name
+        FROM
+            information_schema.referential_constraints AS rc
+        INNER JOIN
+            information_schema.key_column_usage AS kcu
+            ON kcu.constraint_catalog = rc.constraint_catalog
+            AND kcu.constraint_schema = rc.constraint_schema
+            AND kcu.constraint_name = rc.constraint_name
+        WHERE
+            kcu.table_schema = {} AND
+            kcu.table_name = {} AND
+            kcu.column_name = {}
+        """,
+        schema,
+        table_name,
+        column_name,
+    )
+
+    return constraints[0]["fk_constraint_name"]
+
+
+@dataclass
+class ConstraintRules:
+    on_delete: OnDelete
+    on_update: OnUpdate
+
+
+async def get_fk_constraint_rules(column: ForeignKey) -> ConstraintRules:
+    """
+    Checks the constraint rules for this foreign key in the database.
+    """
+    table = column._meta.table
+
+    if table._meta.db.engine_type == "sqlite":
+        # TODO - add the query for SQLite
+        raise ValueError("SQLite isn't currently supported.")
+
+    schema = table._meta.schema or "public"
+    table_name = table._meta.tablename
+    column_name = column._meta.db_column_name
+
+    constraints = await table.raw(
+        """
+        SELECT
+            kcu.constraint_name,
+            kcu.table_name,
+            kcu.column_name,
+            rc.update_rule,
+            rc.delete_rule
+        FROM
+            information_schema.key_column_usage AS kcu
+        INNER JOIN
+            information_schema.referential_constraints AS rc
+            ON kcu.constraint_name = rc.constraint_name
+        WHERE
+            kcu.table_schema = {} AND
+            kcu.table_name = {} AND
+            kcu.column_name = {}
+        """,
+        schema,
+        table_name,
+        column_name,
+    )
+
+    return ConstraintRules(
+        on_delete=OnDelete(constraints[0]["delete_rule"]),
+        on_update=OnUpdate(constraints[0]["update_rule"]),
+    )

piccolo/query/methods/alter.py

@@ -36,6 +36,18 @@ class RenameTable(AlterStatement):
         return f"RENAME TO {self.new_name}"
 
 
+@dataclass
+class RenameConstraint(AlterStatement):
+    __slots__ = ("old_name", "new_name")
+
+    old_name: str
+    new_name: str
+
+    @property
+    def ddl(self) -> str:
+        return f"RENAME CONSTRAINT {self.old_name} TO {self.new_name}"
+
+
 @dataclass
 class AlterColumnStatement(AlterStatement):
     __slots__ = ("column",)
@@ -194,6 +206,7 @@ class AddForeignKeyConstraint(AlterStatement):
         "constraint_name",
         "foreign_key_column_name",
         "referenced_table_name",
+        "referenced_column_name",
         "on_delete",
         "on_update",
     )
@@ -201,9 +214,9 @@ class AddForeignKeyConstraint(AlterStatement):
     constraint_name: str
     foreign_key_column_name: str
     referenced_table_name: str
+    referenced_column_name: str
     on_delete: t.Optional[OnDelete]
     on_update: t.Optional[OnUpdate]
-    referenced_column_name: str = "id"
 
     @property
     def ddl(self) -> str:
@@ -273,8 +286,8 @@ class DropTable:
 
 class Alter(DDL):
     __slots__ = (
-        "_add_foreign_key_constraint",
         "_add",
+        "_add_foreign_key_constraint",
         "_drop_constraint",
         "_drop_default",
         "_drop_table",
@@ -288,6 +301,7 @@ class Alter(DDL):
         "_set_null",
         "_set_schema",
         "_set_unique",
+        "_rename_constraint",
     )
 
     def __init__(self, table: t.Type[Table], **kwargs):
@@ -307,6 +321,7 @@ class Alter(DDL):
         self._set_null: t.List[SetNull] = []
         self._set_schema: t.List[SetSchema] = []
         self._set_unique: t.List[SetUnique] = []
+        self._rename_constraint: t.List[RenameConstraint] = []
 
     def add_column(self: Self, name: str, column: Column) -> Self:
         """
@@ -372,6 +387,24 @@ class Alter(DDL):
         self._rename_table = [RenameTable(new_name=new_name)]
         return self
 
+    def rename_constraint(self, old_name: str, new_name: str) -> Alter:
+        """
+        Rename a constraint on the table::
+
+            >>> await Band.alter().rename_constraint(
+            ...     'old_constraint_name',
+            ...     'new_constraint_name',
+            ... )
+
+        """
+        self._rename_constraint = [
+            RenameConstraint(
+                old_name=old_name,
+                new_name=new_name,
+            )
+        ]
+        return self
+
     def rename_column(
         self, column: t.Union[str, Column], new_name: str
     ) -> Alter:
@@ -488,7 +521,7 @@ class Alter(DDL):
     def _get_constraint_name(self, column: t.Union[str, ForeignKey]) -> str:
         column_name = AlterColumnStatement(column=column).column_name
         tablename = self.table._meta.tablename
-        return f"{tablename}_{column_name}_fk"
+        return f"{tablename}_{column_name}_fkey"
 
     def drop_constraint(self, constraint_name: str) -> Alter:
         self._drop_constraint.append(
@@ -500,37 +533,58 @@ class Alter(DDL):
         self, column: t.Union[str, ForeignKey]
     ) -> Alter:
         constraint_name = self._get_constraint_name(column=column)
-        return self.drop_constraint(constraint_name=constraint_name)
+        self._drop_constraint.append(
+            DropConstraint(constraint_name=constraint_name)
+        )
+        return self
 
     def add_foreign_key_constraint(
         self,
         column: t.Union[str, ForeignKey],
-        referenced_table_name: str,
+        referenced_table_name: t.Optional[str] = None,
+        referenced_column_name: t.Optional[str] = None,
+        constraint_name: t.Optional[str] = None,
         on_delete: t.Optional[OnDelete] = None,
         on_update: t.Optional[OnUpdate] = None,
-        referenced_column_name: str = "id",
     ) -> Alter:
         """
         Add a new foreign key constraint::
 
             >>> await Band.alter().add_foreign_key_constraint(
             ...     Band.manager,
-            ...     referenced_table_name='manager',
             ...     on_delete=OnDelete.cascade
             ... )
 
         """
-        constraint_name = self._get_constraint_name(column=column)
+        constraint_name = constraint_name or self._get_constraint_name(
+            column=column
+        )
         column_name = AlterColumnStatement(column=column).column_name
 
+        if referenced_column_name is None:
+            if isinstance(column, ForeignKey):
+                referenced_column_name = (
+                    column._foreign_key_meta.resolved_target_column._meta.db_column_name  # noqa: E501
+                )
+            else:
+                raise ValueError("Please pass in `referenced_column_name`.")
+
+        if referenced_table_name is None:
+            if isinstance(column, ForeignKey):
+                referenced_table_name = (
+                    column._foreign_key_meta.resolved_references._meta.tablename  # noqa: E501
+                )
+            else:
+                raise ValueError("Please pass in `referenced_table_name`.")
+
         self._add_foreign_key_constraint.append(
             AddForeignKeyConstraint(
                 constraint_name=constraint_name,
                 foreign_key_column_name=column_name,
                 referenced_table_name=referenced_table_name,
+                referenced_column_name=referenced_column_name,
                 on_delete=on_delete,
                 on_update=on_update,
-                referenced_column_name=referenced_column_name,
             )
         )
         return self
@@ -579,9 +633,12 @@ class Alter(DDL):
             i.ddl
             for i in itertools.chain(
                 self._add,
+                self._add_foreign_key_constraint,
                 self._rename_columns,
                 self._rename_table,
+                self._rename_constraint,
                 self._drop,
+                self._drop_constraint,
                 self._drop_default,
                 self._set_column_type,
                 self._set_unique,

piccolo/utils/sync.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import typing as t
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import Future, ThreadPoolExecutor
 
+ReturnType = t.TypeVar("ReturnType")
 
-def run_sync(coroutine: t.Coroutine):
+
+def run_sync(
+    coroutine: t.Coroutine[t.Any, t.Any, ReturnType],
+) -> ReturnType:
     """
     Run the coroutine synchronously - trying to accommodate as many edge cases
     as possible.
@@ -20,5 +24,5 @@ def run_sync(coroutine: t.Coroutine):
     except RuntimeError:
         # An event loop already exists.
         with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(asyncio.run, coroutine)
+            future: Future = executor.submit(asyncio.run, coroutine)
             return future.result()

{piccolo-1.25.0.dist-info → piccolo-1.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: piccolo
-Version: 1.25.0
+Version: 1.26.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

{piccolo-1.25.0.dist-info → piccolo-1.26.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-piccolo/__init__.py,sha256=BvmUclKrZZEa9RXkZ0XNwqYKihj1aFvSDrl7jJkQmPc,23
+piccolo/__init__.py,sha256=ZVRfjDuz3xhQA4e78KxBcezkGjqcWBkBGlP0bm-NFD8,23
 piccolo/custom_types.py,sha256=7HMQAze-5mieNLfbQ5QgbRQgR2abR7ol0qehv2SqROY,604
 piccolo/main.py,sha256=1VsFV67FWTUikPTysp64Fmgd9QBVa_9wcwKfwj2UCEA,5117
 piccolo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -66,7 +66,7 @@ piccolo/apps/migrations/piccolo_app.py,sha256=1EcS2ComBPCaMCC2C3WaPR_GqLwt3XiIJN
 piccolo/apps/migrations/tables.py,sha256=jqBnK-Rk545v1Eu6GaLHTVz7-uwBTUnz2m58OA-mxTc,799
 piccolo/apps/migrations/auto/__init__.py,sha256=eYb1rZQaalumv_bhbcEe6x3dUglmpFtw7Egg6k7597U,316
 piccolo/apps/migrations/auto/diffable_table.py,sha256=1HdqGeWFUYVJ2cJg6DZWOCh67SbgCxFVc554uD7N71A,7405
-piccolo/apps/migrations/auto/migration_manager.py,sha256=tyAE1Xk6Xb58igbuHw3FGHhKkVjv_Vr5qBH4AbvVb8k,35856
+piccolo/apps/migrations/auto/migration_manager.py,sha256=5M2_01_FsZj6zIGXLEwkyEAPF2e-ICNB2_ZcBWwifCQ,37267
 piccolo/apps/migrations/auto/operations.py,sha256=169IrCLR3FtTRxHsEHNg6dTG45lcEM7Aoyy3SwgX_hU,1329
 piccolo/apps/migrations/auto/schema_differ.py,sha256=VA1rK-_wNSdyZZgfA3ZOlpVGJCcvLyouKtT9k2YKhiA,26266
 piccolo/apps/migrations/auto/schema_snapshot.py,sha256=ZqUg4NpChOeoACKF2gkhqsz1BW3wOWFnzJCccq-CNNQ,4719
@@ -93,7 +93,7 @@ piccolo/apps/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 piccolo/apps/schema/piccolo_app.py,sha256=De9eujzB6zWsP6J1gHYUk_f5_DpjvTZVXJsQ3eXBgnA,432
 piccolo/apps/schema/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 piccolo/apps/schema/commands/exceptions.py,sha256=ZOGL3iV-xtWbWsImXObrXNaKtNPY_Qk1OmaOMOV6Ps0,236
-piccolo/apps/schema/commands/generate.py,sha256=_niW_UxZ-x29-xjDIVdjHdDyKAaXn4HUDVtVjsXgBD0,30700
+piccolo/apps/schema/commands/generate.py,sha256=xYRz9P4cdahSHzAIiXhXBzg6eUqV0WB2THSRZH7uPhU,30415
 piccolo/apps/schema/commands/graph.py,sha256=FuQUPavUXpr-Y_11XRr11DbVLsgK8uG0IN8uBZIe5G4,3190
 piccolo/apps/schema/commands/templates/graphviz.dot.jinja,sha256=-legygtsueOC70aboX35ZJpbCAXcv3E8RXXvFDQTeIY,1443
 piccolo/apps/shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -153,6 +153,7 @@ piccolo/engine/postgres.py,sha256=DekL3KafCdzSAEQ6_EgOiUB1ERXh2xpePYwI9QvmN-c,18
 piccolo/engine/sqlite.py,sha256=Oe0GBrIUSUkutvk5LoXGWC6HFQzKeusfql5-NMssH_s,25735
 piccolo/query/__init__.py,sha256=bcsMV4813rMRAIqGv4DxI4eyO4FmpXkDv9dfTk5pt3A,699
 piccolo/query/base.py,sha256=sO5VyicbWjgYaQukr6jqUqUUrOctL6QJ1MjcsgDKHXM,14912
+piccolo/query/constraints.py,sha256=menFcqLKSM4697OSvMRZPsTgxHfR9GTvZZMrGDk2PrA,2601
 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
@@ -163,7 +164,7 @@ piccolo/query/functions/math.py,sha256=2Wapq0lpXZh77z0uzXUhnOfmUkbkM0xjQ4tiyuCsb
 piccolo/query/functions/string.py,sha256=X3g_4qomJJCkYOcKcK-zZEqC6qJBrS4VTogPp9Xw4Cs,2506
 piccolo/query/functions/type_conversion.py,sha256=OYbZc6TEk6b5yTwCMw2rmZ-UiQiUiWZOyxwMLzUjXwE,2583
 piccolo/query/methods/__init__.py,sha256=tm4gLeV_obDqpgnouVjFbGubbaoJcqm_cbNd4LPo48Q,622
-piccolo/query/methods/alter.py,sha256=AI9YkJeip2EitrWJN_TDExXhA8HGAG3XuDz1NR-KirQ,16728
+piccolo/query/methods/alter.py,sha256=tL8IIuEldBwegQOZM5N4IaoO2fH0tYLk8R7ra6PLD3s,18519
 piccolo/query/methods/count.py,sha256=Vxn_7Ry-rleC6OGRxh-cLbuEMsy1DNjAZJThGED-_do,1748
 piccolo/query/methods/create.py,sha256=hJ-6VVsWczzKDH6fQRN1WmYhcitixuXJ-eNOuCo_JgM,2742
 piccolo/query/methods/create_index.py,sha256=gip_cRXZkLfpJqCL7KHk2l_7HLptoa-Ae8qu6I5d5c8,2224
@@ -195,11 +196,11 @@ piccolo/utils/printing.py,sha256=5VWNSfOrIGPh1VM-7fd4K18RGCYk0FQ5o-D4aLhzXZE,174
 piccolo/utils/pydantic.py,sha256=RhoQZ7ddmFmepVcslHXMqmynbSVch7XLKUSgJkLuQS0,12327
 piccolo/utils/repr.py,sha256=K3w-TAP9WPx8tbAIB2XDab_C4PHsPrB9TzwWfOHa4cc,787
 piccolo/utils/sql_values.py,sha256=pGXmVTw6pWr8q7QA4xs7NiKSwjBzhN--3HXVjQv2SQQ,1749
-piccolo/utils/sync.py,sha256=j9Abkxn5HHS6HyvfpMzb1zV_teTkFHVhaIxu9rrSwSU,819
+piccolo/utils/sync.py,sha256=irmdTsYtURZNEBmIP6i2v2PyjgE-gK4t6VSxnBZ75Qo,920
 piccolo/utils/warnings.py,sha256=ONrurw3HVCClUuHnpenMjg45dcFesrXqMgG9ifgP4_8,1247
 piccolo/utils/graphlib/__init__.py,sha256=SUJ5Yh7LiRun3nkBuLUSVmGNHF6fANrxSoYan0mtYB0,200
 piccolo/utils/graphlib/_graphlib.py,sha256=9FNGDSmTIEAk86FktniCe_J2yXjSE_sRZHDBAJJAUOw,9677
-piccolo-1.25.0.dist-info/licenses/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
+piccolo-1.26.0.dist-info/licenses/LICENSE,sha256=zFIpi-16uIJ420UMIG75NU0JbDBykvrdnXcj5U_EYBI,1059
 profiling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 profiling/run_profile.py,sha256=264qsSFu93NTpExePnKQ9GkcN5fiuRBQ72WOSt0ZHck,829
 tests/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -221,7 +222,7 @@ tests/apps/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 tests/apps/migrations/test_migration.py,sha256=JmPLtf2BCWX3Yofe0GQe40m8I_yWa_-3vk1lDfFDfIo,308
 tests/apps/migrations/auto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/apps/migrations/auto/test_diffable_table.py,sha256=p0cKDkfhmu96-rB9bonOlg5bmfQ7U9S2kRppOt4YxyU,3338
-tests/apps/migrations/auto/test_migration_manager.py,sha256=L2raSuhZybRyK-BEh-G-nDndAgl4sLynekHQFqyrteY,35719
+tests/apps/migrations/auto/test_migration_manager.py,sha256=qzYHC8nKm4pRtsgIyPDSZdXEWLOl2UDgTv6Mv8QO49k,37362
 tests/apps/migrations/auto/test_schema_differ.py,sha256=UdsaZisA02j15wr1bXkXD6Cqu3p0A23NwFQLXsJdQL4,19391
 tests/apps/migrations/auto/test_schema_snapshot.py,sha256=ZyvGZqn3N3cwd-3S-FME5AJ8buDSHesw7yPIvY6mE5k,6196
 tests/apps/migrations/auto/test_serialisation.py,sha256=EFkhES1w9h51UCamWrhxs3mf4I718ggeP7Yl5J_UID4,13548
@@ -380,8 +381,8 @@ 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.25.0.dist-info/METADATA,sha256=zdbTbYmUa-EhWuXfpt53Hr1RBENaNyiXBk80Ii_bFK8,5531
-piccolo-1.25.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-piccolo-1.25.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
-piccolo-1.25.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
-piccolo-1.25.0.dist-info/RECORD,,
+piccolo-1.26.0.dist-info/METADATA,sha256=UE7oErMiVueu8PQJLKAzHWoVIaXJtA2r9d1VZsOzwbU,5531
+piccolo-1.26.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+piccolo-1.26.0.dist-info/entry_points.txt,sha256=SJPHET4Fi1bN5F3WqcKkv9SClK3_F1I7m4eQjk6AFh0,46
+piccolo-1.26.0.dist-info/top_level.txt,sha256=-SR74VGbk43VoPy1HH-mHm97yoGukLK87HE5kdBW6qM,24
+piccolo-1.26.0.dist-info/RECORD,,

{piccolo-1.25.0.dist-info → piccolo-1.26.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/apps/migrations/auto/test_migration_manager.py

@@ -12,8 +12,10 @@ from piccolo.columns.base import OnDelete, OnUpdate
 from piccolo.columns.column_types import ForeignKey
 from piccolo.conf.apps import AppConfig
 from piccolo.engine import engine_finder
+from piccolo.query.constraints import get_fk_constraint_rules
 from piccolo.table import Table, sort_table_classes
 from piccolo.utils.lazy_loader import LazyLoader
+from piccolo.utils.sync import run_sync
 from tests.base import AsyncMock, DBTestCase, engine_is, engines_only
 from tests.example_apps.music.tables import Band, Concert, Manager, Venue
 
@@ -618,6 +620,54 @@ class TestMigrationManager(DBTestCase):
             response = self.run_sync("SELECT * FROM manager;")
             self.assertEqual(response, [{"id": id[0]["id"], "name": "Dave"}])
 
+    @engines_only("postgres", "cockroach")
+    def test_alter_fk_on_delete_on_update(self):
+        """
+        Test altering OnDelete and OnUpdate with MigrationManager.
+        """
+        # before performing migrations - OnDelete.no_action
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.no_action,
+        )
+
+        manager = MigrationManager(app_name="music")
+        manager.alter_column(
+            table_class_name="Band",
+            tablename="band",
+            column_name="manager",
+            db_column_name="manager",
+            params={
+                "on_delete": OnDelete.set_null,
+                "on_update": OnUpdate.set_null,
+            },
+            old_params={
+                "on_delete": OnDelete.no_action,
+                "on_update": OnUpdate.no_action,
+            },
+            column_class=ForeignKey,
+            old_column_class=ForeignKey,
+            schema=None,
+        )
+
+        asyncio.run(manager.run())
+
+        # after performing migrations - OnDelete.set_null
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.set_null,
+        )
+
+        # Reverse
+        asyncio.run(manager.run(backwards=True))
+
+        # after performing reverse migrations we have
+        # OnDelete.no_action again
+        self.assertEqual(
+            run_sync(get_fk_constraint_rules(column=Band.manager)).on_delete,
+            OnDelete.no_action,
+        )
+
     @engines_only("postgres")
     def test_alter_column_unique(self):
         """