hare-orm 0.9.0__py3-none-any.whl

hare/dialects/postgresql/schema/postgresql_schema_editor.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import cast
+
+from hare.ddl.indexes.index import Index
+from hare.dialects.base.schema.base_schema_editor import BaseSchemaEditor
+from hare.dialects.postgresql.partitioning.partitioning import Partitioning
+from hare.dialects.postgresql.postgresql_table_options import PostgresqlTableOptions
+from hare.dialects.postgresql.schema.columns.postgresql_column_backfill import PostgresqlColumnBackfill
+from hare.dialects.postgresql.schema.columns.postgresql_column_narrowing_check import PostgresqlColumnNarrowingCheck
+from hare.dialects.postgresql.schema.columns.postgresql_column_type_changes import PostgresqlColumnTypeChanges
+from hare.dialects.postgresql.schema.constants import (
+    POSTGRESQL_COLUMN_COMMENT_TEMPLATE,
+    POSTGRESQL_CONCURRENT_INDEX_CREATE_PATTERN,
+    POSTGRESQL_EXCLUSION_CONSTRAINT_CREATE_TEMPLATE,
+    POSTGRESQL_FUNCTION_DROP_IF_EXISTS_TEMPLATE,
+    POSTGRESQL_GENERATED_PK_TEMPLATE,
+    POSTGRESQL_MATERIALIZED_VIEW_DROP_IF_EXISTS_TEMPLATE,
+    POSTGRESQL_ROLE_KEYWORDS,
+    POSTGRESQL_SAFE_ADD_CONSTRAINT_TEMPLATE,
+    POSTGRESQL_SEQUENCE_DROP_IF_EXISTS_TEMPLATE,
+    POSTGRESQL_TABLE_COMMENT_TEMPLATE,
+    POSTGRESQL_VIEW_DROP_IF_EXISTS_TEMPLATE,
+)
+from hare.dialects.postgresql.schema.constraints.postgresql_constraint_statements import PostgresqlConstraintStatements
+from hare.dialects.postgresql.schema.indexes.postgresql_index_statements import PostgresqlIndexStatements
+from hare.dialects.postgresql.schema.relations.postgresql_foreign_key_rebuild import PostgresqlForeignKeyRebuild
+from hare.dialects.postgresql.schema.runtime_statements.postgresql_table_clearing import PostgresqlTableClearing
+from hare.dialects.postgresql.schema.runtime_statements.postgresql_table_locks import PostgresqlTableLocks
+from hare.dialects.postgresql.schema.runtime_statements.postgresql_tenant_conditions import PostgresqlTenantConditions
+from hare.dialects.postgresql.schema.schema_objects.postgresql_database_functions import PostgresqlDatabaseFunctions
+from hare.dialects.postgresql.schema.schema_objects.postgresql_enum_types import PostgresqlEnumTypes
+from hare.dialects.postgresql.schema.schema_objects.postgresql_extensions import PostgresqlExtensions
+from hare.dialects.postgresql.schema.schema_objects.postgresql_grants import PostgresqlGrants
+from hare.dialects.postgresql.schema.schema_objects.postgresql_materialized_views import PostgresqlMaterializedViews
+from hare.dialects.postgresql.schema.schema_objects.postgresql_row_level_security_policies import (
+    PostgresqlRowLevelSecurityPolicies,
+)
+from hare.dialects.postgresql.schema.schema_objects.postgresql_schemas import PostgresqlSchemas
+from hare.dialects.postgresql.schema.schema_objects.postgresql_sequences import PostgresqlSequences
+from hare.dialects.postgresql.schema.schema_objects.postgresql_views import PostgresqlViews
+from hare.dialects.postgresql.schema.tables.postgresql_table_comments import PostgresqlTableComments
+from hare.dialects.postgresql.schema.tables.postgresql_table_partitions import PostgresqlTablePartitions
+from hare.dialects.postgresql.schema.tables.postgresql_table_rebuild import PostgresqlTableRebuild
+from hare.dialects.postgresql.schema.triggers.postgresql_trigger_statements import PostgresqlTriggerStatements
+from hare.exceptions import ConfigurationError
+from hare.models import Model
+from hare.sql.identifiers import Identifiers
+
+
+class PostgresqlSchemaEditor(BaseSchemaEditor):
+    """The schema editor of PostgreSQL - the DDL of its tables, columns, indexes, constraints, partitions and
+    schema objects."""
+
+    column_type_changes_class = PostgresqlColumnTypeChanges
+    column_backfill_class = PostgresqlColumnBackfill
+    column_narrowing_check_class = PostgresqlColumnNarrowingCheck
+    table_comments_class = PostgresqlTableComments
+    table_partitions_class = PostgresqlTablePartitions
+    table_rebuild_class = PostgresqlTableRebuild
+    foreign_key_rebuild_class = PostgresqlForeignKeyRebuild
+    foreign_key_rebuild: PostgresqlForeignKeyRebuild
+    index_statements_class = PostgresqlIndexStatements
+    constraint_statements_class = PostgresqlConstraintStatements
+    trigger_statements_class = PostgresqlTriggerStatements
+    views_class = PostgresqlViews
+    materialized_views_class = PostgresqlMaterializedViews
+    database_functions_class = PostgresqlDatabaseFunctions
+    sequences_class = PostgresqlSequences
+    row_level_security_policies_class = PostgresqlRowLevelSecurityPolicies
+    grants_class = PostgresqlGrants
+    enum_types_class = PostgresqlEnumTypes
+    extensions_class = PostgresqlExtensions
+    schemas_class = PostgresqlSchemas
+    schemas: PostgresqlSchemas
+    table_locks_class = PostgresqlTableLocks
+    table_clearing_class = PostgresqlTableClearing
+    tenant_conditions_class = PostgresqlTenantConditions
+
+    INDEX_CREATE_TEMPLATE = "CREATE INDEX {exists}{index_name} ON {table_name} {index_type}({fields}){extra};"
+    SAFE_ADD_CONSTRAINT_TEMPLATE = POSTGRESQL_SAFE_ADD_CONSTRAINT_TEMPLATE
+    UNIQUE_INDEX_CREATE_TEMPLATE = INDEX_CREATE_TEMPLATE.replace("INDEX", "UNIQUE INDEX")
+    EXCLUSION_CONSTRAINT_CREATE_TEMPLATE = POSTGRESQL_EXCLUSION_CONSTRAINT_CREATE_TEMPLATE
+    TABLE_COMMENT_TEMPLATE = POSTGRESQL_TABLE_COMMENT_TEMPLATE
+    COLUMN_COMMENT_TEMPLATE = POSTGRESQL_COLUMN_COMMENT_TEMPLATE
+    GENERATED_PK_TEMPLATE = POSTGRESQL_GENERATED_PK_TEMPLATE
+    # USING casts explicitly - without it only a type with an implicit cast is accepted.
+    ALTER_FIELD_TYPE_TEMPLATE = "ALTER COLUMN {column} TYPE {sql_type} USING {column}::{sql_type}"
+    DROPS_DEFAULT_BEFORE_TYPE_CHANGE = True
+    RENAME_INDEX_TEMPLATE: str | None = "ALTER INDEX {old_name} RENAME TO {new_name}"
+    RENAME_INDEX_IF_EXISTS_TEMPLATE: str | None = "ALTER INDEX IF EXISTS {old_name} RENAME TO {new_name}"
+    TRIGGER_FUNCTION_CREATE_TEMPLATE = (
+        "CREATE FUNCTION {function_name}() RETURNS TRIGGER AS $trigger$\nBEGIN\n{body}\nEND;\n"
+        "$trigger$ LANGUAGE {language};"
+    )
+    TRIGGER_FUNCTION_CREATE_OR_REPLACE_TEMPLATE = TRIGGER_FUNCTION_CREATE_TEMPLATE.replace(
+        "CREATE FUNCTION", "CREATE OR REPLACE FUNCTION", 1
+    )
+    TRIGGER_FUNCTION_DROP_TEMPLATE = "DROP FUNCTION {function_name}()"
+    # {trigger_name}/{old_name}/{new_name} are passed already quoted.
+    TRIGGER_CREATE_TEMPLATE = (
+        "CREATE TRIGGER {trigger_name} {timing} {on} ON {table}\n"
+        "    FOR EACH {for_each}{when_clause}\n"
+        "    EXECUTE FUNCTION {function_name}();"
+    )
+    #: For Trigger.deferrable=True - a constraint trigger, always AFTER and FOR EACH ROW.
+    TRIGGER_CONSTRAINT_CREATE_TEMPLATE = (
+        "CREATE CONSTRAINT TRIGGER {trigger_name} {timing} {on} ON {table}\n"
+        "    DEFERRABLE INITIALLY {initially}\n"
+        "    FOR EACH {for_each}{when_clause}\n"
+        "    EXECUTE FUNCTION {function_name}();"
+    )
+    TRIGGER_DROP_TEMPLATE = "DROP TRIGGER {trigger_name} ON {table}"
+    TRIGGER_DROP_IF_EXISTS_TEMPLATE = "DROP TRIGGER IF EXISTS {trigger_name} ON {table};"
+    RENAME_TRIGGER_TEMPLATE: str | None = "ALTER TRIGGER {old_name} ON {table} RENAME TO {new_name}"
+    RENAME_TRIGGER_FUNCTION_TEMPLATE: str | None = "ALTER FUNCTION {function_name}() RENAME TO {new_function_name}"
+
+    def get_partitioned_options(self, model: type[Model]) -> PostgresqlTableOptions | None:
+        """The table options of a model whose table is partitioned.
+
+        Args:
+            model: The model.
+
+        Returns:
+            The options, None for a plain table.
+        """
+        options = cast("PostgresqlTableOptions | None", model._meta.get_table_options(self.client.dialect))
+        return options if options is not None and options.partitioning is not None else None
+
+    async def rename_table(self, model: type[Model], old_name: str, new_name: str) -> None:
+        """Renames a table and, for a partitioned one, its partitions - named after it.
+
+        Args:
+            model: The model.
+            old_name: The table's name.
+            new_name: Its new name.
+        """
+        await super().rename_table(model, old_name, new_name)
+        options = self.get_partitioned_options(model)
+        if options is None or old_name == new_name:
+            return
+        for partition_name in cast("Partitioning", options.partitioning).get_partition_names():
+            old_partition = Partitioning.get_partition_table_name(old_name, partition_name)
+            new_partition = Partitioning.get_partition_table_name(new_name, partition_name)
+            await self.run_sql(
+                self.RENAME_TABLE_TEMPLATE.format(
+                    old_table=self.qualify_table_name(old_partition, model._meta.schema),
+                    new_table=self.quote(new_partition),
+                )
+            )
+
+    async def add_index(self, model: type[Model], index: Index, concurrently: bool = False) -> None:
+        """Creates an index. PostgreSQL can't build one concurrently on a partitioned table as a
+        whole: the index is created on the table alone, built concurrently on each partition and
+        attached, which makes the table's index valid once every partition has its own.
+
+        Args:
+            model: The indexed model.
+            index: The index.
+            concurrently: Build it without blocking writes.
+        """
+        if not concurrently:
+            await super().add_index(model, index)
+            return
+        options = self.get_partitioned_options(model)
+        if options is None:
+            await self.run_sql(
+                self._get_concurrent_index_create_sql(self.index_statements.get_index_create_sql(model, index))
+            )
+            return
+        schema = model._meta.schema
+        index_name = self.index_statements.index_name_for_model(model, index)
+        qualified_table = self.qualify_table_name(model._meta.db_table, schema)
+        await self.run_sql(
+            self.index_statements.get_index_create_sql(model, index, indexed_table_sql=f"ONLY {qualified_table}")
+        )
+        for partition_name in cast("Partitioning", options.partitioning).get_partition_names():
+            partition_table = Partitioning.get_partition_table_name(model._meta.db_table, partition_name)
+            partition_index_name = Identifiers.get_within_limit(f"{partition_table}_{index_name}")
+            partition_index_sql = self.index_statements.get_index_create_sql(
+                model, index, partition_index_name, self.qualify_table_name(partition_table, schema)
+            )
+            await self.run_sql(self._get_concurrent_index_create_sql(partition_index_sql))
+            await self.run_sql(
+                f"ALTER INDEX {self.qualify_table_name(index_name, schema)} "
+                f"ATTACH PARTITION {self.qualify_table_name(partition_index_name, schema)}"
+            )
+
+    async def remove_index(self, model: type[Model], index: Index, concurrently: bool = False) -> None:
+        """Drops an index - the plain way on a partitioned table, whose index PostgreSQL can't
+        drop concurrently.
+
+        Args:
+            model: The indexed model.
+            index: The index.
+            concurrently: Drop it without blocking reads and writes.
+        """
+        drop_sql = self.index_statements.get_index_drop_sql(model, index)
+        if concurrently and self.get_partitioned_options(model) is None:
+            drop_sql = drop_sql.replace("DROP INDEX ", "DROP INDEX CONCURRENTLY ", 1)
+        await self.run_sql(drop_sql)
+
+    @staticmethod
+    def _get_concurrent_index_create_sql(index_sql: str) -> str:
+        """Returns a ``CREATE INDEX`` statement building the index without blocking writes.
+
+        Args:
+            index_sql: The plain statement.
+
+        Returns:
+            The statement.
+        """
+        return POSTGRESQL_CONCURRENT_INDEX_CREATE_PATTERN.sub(r"\1CONCURRENTLY ", index_sql, count=1)
+
+    async def delete_model(self, model: type[Model]) -> None:
+        """Drops the model's views first - they read the table - then the table, then its triggers'
+        functions, its own functions and its sequences: neither is owned by the table, so each
+        outlives DROP TABLE unless dropped too (a sequence owned by a column already went with it)."""
+        await self.drop_views_of_table(model)
+        await super().delete_model(model)
+        for trigger in model._meta.triggers:
+            qualified_function = self.qualify_table_name(trigger.function_name, model._meta.schema)
+            await self.run_sql(self.TRIGGER_FUNCTION_DROP_TEMPLATE.format(function_name=qualified_function))
+        for function in reversed(model._meta.functions):
+            await self.run_sql(
+                POSTGRESQL_FUNCTION_DROP_IF_EXISTS_TEMPLATE.format(
+                    function=self.qualify_object_name(model, function.name), arguments=", ".join(function.arguments)
+                )
+            )
+        for sequence in reversed(model._meta.sequences):
+            await self.run_sql(
+                POSTGRESQL_SEQUENCE_DROP_IF_EXISTS_TEMPLATE.format(
+                    sequence=self.qualify_object_name(model, sequence.name)
+                )
+            )
+
+    async def drop_views_of_table(self, model: type[Model]) -> None:
+        """Drops the views and materialized views a model declares, if they exist - before its
+        table is dropped."""
+        for materialized_view in reversed(model._meta.materialized_views):
+            await self.run_sql(
+                POSTGRESQL_MATERIALIZED_VIEW_DROP_IF_EXISTS_TEMPLATE.format(
+                    view=self.qualify_object_name(model, materialized_view.name)
+                )
+            )
+        for view in reversed(model._meta.views):
+            await self.run_sql(
+                POSTGRESQL_VIEW_DROP_IF_EXISTS_TEMPLATE.format(view=self.qualify_object_name(model, view.name))
+            )
+
+    def get_model_table_sql(self, model: type[Model]) -> str:
+        """The model's quoted table name, in its schema."""
+        return self.qualify_table_name(model._meta.db_table, model._meta.schema)
+
+    @staticmethod
+    def get_column_name(model: type[Model], field_name: str, owner: str) -> str:
+        """The column of a field a declared object names.
+
+        Args:
+            model: The model.
+            field_name: The field's name.
+            owner: What names it - for the message.
+
+        Raises:
+            ConfigurationError: The model has no field of a column of that name.
+        """
+        column = model._meta.fields_db_projection.get(field_name)
+        if column is None:
+            raise ConfigurationError(f"{owner} names {field_name!r}, which is no column field of {model.__name__}")
+        return column
+
+    def get_roles_sql(self, roles: Sequence[str]) -> str:
+        """The roles of a policy or grant - a special role as its keyword, any other quoted; every
+        role (``PUBLIC``) for none."""
+        if not roles:
+            return "PUBLIC"
+        return ", ".join(
+            role.upper() if role.upper() in POSTGRESQL_ROLE_KEYWORDS else self.quote(role) for role in roles
+        )

hare/dialects/postgresql/schema/relations/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

hare/dialects/postgresql/schema/relations/postgresql_foreign_key_rebuild.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, cast
+
+from hare.ddl.constraints.foreign_key_constraint import ForeignKeyConstraint
+from hare.ddl.generated_names import GeneratedNames
+from hare.dialects.base.schema.relations.foreign_key_rebuild import ForeignKeyRebuild
+from hare.fields.enums import OnDelete
+from hare.fields.field import Field
+from hare.fields.relations.fields.foreign_key_field_instance import ForeignKeyFieldInstance
+from hare.fields.relations.fields.many_to_many_field_instance import ManyToManyFieldInstance
+from hare.models import Model
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from hare.dialects.postgresql.schema.postgresql_schema_editor import PostgresqlSchemaEditor
+
+
+class PostgresqlForeignKeyRebuild(ForeignKeyRebuild):
+    """ForeignKeyRebuild as PostgreSQL writes it - a constraint is dropped and added in place, by the name
+    its key columns give it; whether one exists is the relation's own declaration, never the catalog's."""
+
+    __slots__ = ()
+
+    editor: PostgresqlSchemaEditor
+
+    async def drop_foreign_key(self, table_name: str, column_names: Sequence[str], schema: str | None) -> None:
+        """Drops the foreign key over exactly ``column_names`` of a table.
+
+        Args:
+            table_name: The table owning the constraint.
+            column_names: The constraint's own columns, in order.
+            schema: The table's schema.
+        """
+        await self.editor.run_sql(
+            self.editor.DELETE_CONSTRAINT_TEMPLATE.format(
+                table=self.editor.qualify_table_name(table_name, schema),
+                name=self.editor.quote(GeneratedNames.get_foreign_key_name(table_name, column_names)),
+            )
+        )
+
+    async def drop_relation_foreign_keys(self, model: type[Model], relation_field: Field[Any]) -> None:
+        if not self.creates_foreign_key(relation_field):
+            return
+        if isinstance(relation_field, ManyToManyFieldInstance):
+            if relation_field._generated or relation_field.through_model is not None:
+                return
+            for side_keys in (relation_field.backward_keys, relation_field.forward_keys):
+                await self.drop_foreign_key(relation_field.through, side_keys, model._meta.schema)
+            return
+        if isinstance(relation_field, ForeignKeyFieldInstance):
+            columns = [
+                model._meta.fields_db_projection[key_field_name] for key_field_name in relation_field.source_fields
+            ]
+            await self.drop_foreign_key(model._meta.db_table, columns, model._meta.schema)
+
+    async def add_relation_foreign_key(
+        self, model: type[Model], foreign_key_field: ForeignKeyFieldInstance[Model]
+    ) -> None:
+        """Adds a FK/O2O field's constraint - nothing for one declared without it.
+
+        Args:
+            model: The model owning the relation.
+            foreign_key_field: The relation.
+        """
+        if not self.creates_foreign_key(foreign_key_field):
+            return
+        if len(foreign_key_field.source_fields) > 1:
+            constraint = self.editor.table_creation.get_composite_foreign_key_constraint(model, foreign_key_field)
+        else:
+            constraint = self.editor.table_creation.get_single_column_foreign_key_constraint(
+                model, foreign_key_field.source_fields[0]
+            )
+        await self.editor.run_sql(self.editor.table_creation.get_add_foreign_key_sql(model, constraint, safe=False))
+
+    async def alter_foreign_key_on_delete(
+        self,
+        model: type[Model],
+        db_field: str,
+        old_foreign_key_field: ForeignKeyFieldInstance[Model],
+        new_foreign_key_field: ForeignKeyFieldInstance[Model],
+    ) -> None:
+        await self.drop_relation_foreign_keys(model, old_foreign_key_field)
+        await self.add_relation_foreign_key(model, new_foreign_key_field)
+
+    async def rebuild_foreign_key_constraints(
+        self, model: type[Model], foreign_key_field: ForeignKeyFieldInstance[Model]
+    ) -> None:
+        """Adds back a FK/O2O field's constraint dropped for a change of its key columns."""
+        await self.add_relation_foreign_key(model, foreign_key_field)
+
+    async def rebuild_many_to_many_through_foreign_keys(
+        self,
+        model: type[Model],
+        field: ManyToManyFieldInstance[Model],
+        old_field: ManyToManyFieldInstance[Model] | None = None,
+    ) -> None:
+        """Replaces the FK constraints of an auto-managed through table with the field's current ON
+        DELETE action - the old field's dropped first - and aligns the key columns' nullability with it
+        (only ON DELETE SET NULL needs nullable columns)."""
+        from hare.query.key_columns import KeyColumns
+
+        if old_field is not None:
+            await self.drop_relation_foreign_keys(model, old_field)
+        schema = model._meta.schema
+        through_table = field.through
+        qualified_through = self.editor.qualify_table_name(through_table, schema)
+        nullability_template = (
+            self.editor.ALTER_FIELD_NULL_TEMPLATE
+            if field.db_on_delete == OnDelete.SET_NULL
+            else self.editor.ALTER_FIELD_NOT_NULL_TEMPLATE
+        )
+        sides = ((field.backward_keys, model._meta), (field.forward_keys, field.related_model._meta))
+        for side_keys, target_meta in sides:
+            for key in side_keys:
+                await self.editor.run_sql(
+                    self.editor.ALTER_FIELD_TEMPLATE.format(
+                        table=qualified_through, changes=nullability_template.format(column=self.editor.quote(key))
+                    )
+                )
+            if not self.creates_foreign_key(field):
+                continue
+            pk_columns = KeyColumns.get_source_columns(target_meta)
+            constraint_sql = self.editor.FOREIGN_KEY_CONSTRAINT_CREATE_TEMPLATE.format(
+                name=self.editor.quote(GeneratedNames.get_foreign_key_name(through_table, side_keys)),
+                fields=", ".join(self.editor.quote(key) for key in side_keys),
+                table=self.editor.qualify_table_name(target_meta.db_table, target_meta.schema),
+                to_fields=", ".join(self.editor.quote(column) for column in pk_columns),
+                on_delete=field.db_on_delete,
+            )
+            await self.editor.run_sql(
+                self.editor.ADD_CONSTRAINT_TEMPLATE.format(table=qualified_through, constraint=constraint_sql)
+            )
+
+    def get_incoming_relations(
+        self, model: type[Model]
+    ) -> list[tuple[type[Model], Field[Any], tuple[str, ...] | None]]:
+        """The relations of other tables with a FOREIGN KEY to a model's table - read from the models the
+        state links to it, never from the catalog.
+
+        Args:
+            model: The model rendered from the state.
+
+        Returns:
+            (the model declaring the relation, the relation, the keys of the through table side
+            referencing the table - None for a FK/O2O) per relation.
+        """
+        meta = model._meta
+        candidate_models: dict[tuple[str | None, str], type[Model]] = {}
+        relation_fields = [*meta.fields_map.values(), *meta.hidden_backward_relations.values()]
+        for relation_field in relation_fields:
+            related_model = getattr(relation_field, "related_model", None)
+            if related_model is not None:
+                candidate_models[(related_model._meta.app, related_model.__name__)] = related_model
+        candidate_models[(meta.app, model.__name__)] = model
+        incoming: list[tuple[type[Model], Field[Any], tuple[str, ...] | None]] = []
+        for candidate_model in candidate_models.values():
+            for relation_field in candidate_model._meta.fields_map.values():
+                if not self.creates_foreign_key(relation_field):
+                    continue
+                if isinstance(relation_field, ForeignKeyFieldInstance):
+                    # A relation of the table to itself goes with the table.
+                    if self.is_same_model(relation_field.related_model, model) and not self.is_same_model(
+                        candidate_model, model
+                    ):
+                        incoming.append((candidate_model, relation_field, None))
+                elif (
+                    isinstance(relation_field, ManyToManyFieldInstance)
+                    and not relation_field._generated
+                    and relation_field.through_model is None
+                ):
+                    if self.is_same_model(candidate_model, model):
+                        incoming.append((candidate_model, relation_field, tuple(relation_field.backward_keys)))
+                    if self.is_same_model(relation_field.related_model, model):
+                        incoming.append((candidate_model, relation_field, tuple(relation_field.forward_keys)))
+        return incoming
+
+    async def drop_incoming_foreign_keys(self, model: type[Model]) -> None:
+        """Drops the foreign keys of other tables referencing a model's table.
+
+        Args:
+            model: The model rendered from the state.
+        """
+        for referencing_model, relation_field, side_keys in self.get_incoming_relations(model):
+            if side_keys is None:
+                await self.drop_relation_foreign_keys(referencing_model, relation_field)
+            else:
+                through_field = cast("ManyToManyFieldInstance[Model]", relation_field)
+                await self.drop_foreign_key(through_field.through, side_keys, referencing_model._meta.schema)
+
+    async def add_incoming_foreign_keys(self, model: type[Model]) -> None:
+        """Adds back the foreign keys of other tables referencing a model's table.
+
+        Args:
+            model: The model rendered from the state.
+        """
+        from hare.query.key_columns import KeyColumns
+
+        for referencing_model, relation_field, side_keys in self.get_incoming_relations(model):
+            if side_keys is None:
+                await self.add_relation_foreign_key(
+                    referencing_model, cast("ForeignKeyFieldInstance[Model]", relation_field)
+                )
+                continue
+            through_field = cast("ManyToManyFieldInstance[Model]", relation_field)
+            constraint_sql = self.editor.FOREIGN_KEY_CONSTRAINT_CREATE_TEMPLATE.format(
+                name=self.editor.quote(GeneratedNames.get_foreign_key_name(through_field.through, side_keys)),
+                fields=", ".join(self.editor.quote(key) for key in side_keys),
+                table=self.editor.qualify_table_name(model._meta.db_table, model._meta.schema),
+                to_fields=", ".join(
+                    self.editor.quote(column) for column in KeyColumns.get_source_columns(model._meta)
+                ),
+                on_delete=through_field.db_on_delete,
+            )
+            await self.editor.run_sql(
+                self.editor.ADD_CONSTRAINT_TEMPLATE.format(
+                    table=self.editor.qualify_table_name(through_field.through, referencing_model._meta.schema),
+                    constraint=constraint_sql,
+                )
+            )
+
+    async def add_foreign_key_constraint_not_valid(self, model: type[Model], constraint: ForeignKeyConstraint) -> None:
+        await self.editor.run_sql(
+            self.editor.ADD_CONSTRAINT_TEMPLATE.format(
+                table=self.editor.qualify_table_name(model._meta.db_table, model._meta.schema),
+                constraint=f"{self.editor.table_creation.get_foreign_key_constraint_clause(constraint)} NOT VALID",
+            )
+        )

hare/dialects/postgresql/schema/runtime_statements/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

hare/dialects/postgresql/schema/runtime_statements/postgresql_foreign_key_deferral.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager, suppress
+from typing import TYPE_CHECKING
+
+from hare.dialects.postgresql.schema.constants import POSTGRESQL_DEFERRABLE_CONSTRAINT_NAME_QUERY
+from hare.exceptions import HareError
+from hare.models.deletion.cascade.deletion_graph import DeletionGraph
+from hare.models.deletion.cascade.protect_constraint_deferral import ProtectConstraintDeferral
+from hare.models.tenancy.tenant_schemas import TenantSchemas
+
+if TYPE_CHECKING:
+    from hare.dialects.base.client.database_client import DatabaseClient
+    from hare.models import Model
+
+
+class PostgresqlForeignKeyDeferral:
+    """Defers the ``on_delete=PROTECT`` foreign keys a cascade delete can run into. PostgreSQL checks a
+    ``NO ACTION`` constraint at the end of every nested cascade statement, so a guarded row fails
+    the delete even when the same cascade removes the guarding row later. The PROTECT constraints
+    are created ``DEFERRABLE``, deferred for the delete and checked right after it.
+    """
+
+    @staticmethod
+    async def get_protect_constraint_names(model: type[Model], connection: DatabaseClient) -> tuple[str, ...]:
+        """The quoted, schema-qualified names of the deferrable constraints behind the PROTECT foreign
+        keys a hard delete of ``model`` rows can run into - those of a ``Meta.tenant_schema`` model in
+        every tenant's schema, since the delete of a row every tenant shares reaches them all - read
+        from ``pg_constraint`` and cached per model, connection and tenant schemas until DDL runs or a
+        relation changes.
+
+        Args:
+            model: The model rows are deleted from.
+            connection: The connection the delete runs on.
+
+        Returns:
+            The names; a constraint that is missing or not deferrable is left out.
+        """
+        foreign_key_fields = DeletionGraph.get_cascade_protect_foreign_keys(model)
+        tenant_schema_names: tuple[str, ...] = ()
+        if connection.tenant_schema_template is not None and any(
+            foreign_key_field.model._meta.tenant_schema for foreign_key_field in foreign_key_fields
+        ):
+            tenant_schema_names = tuple(schema_name for schema_name, _ in await TenantSchemas.get_schemas(connection))
+        names_key = (connection.connection_alias, tenant_schema_names)
+        cached_names: tuple[str, ...] | None = ProtectConstraintDeferral.CONSTRAINT_NAMES_CACHE.get_for_model(
+            model, names_key
+        )
+        if cached_names is not None:
+            return cached_names
+        names: list[str] = []
+        literals = connection.dialect.literals
+        for foreign_key_field in foreign_key_fields:
+            referencing_meta = foreign_key_field.model._meta
+            referenced_meta = foreign_key_field.related_model._meta
+            # The schemas a tenant model's table is in - each tenant's; a related tenant model's
+            # table is in the same one.
+            schema_names: tuple[str | None, ...] = (
+                tenant_schema_names if referencing_meta.tenant_schema and tenant_schema_names else (None,)
+            )
+            for schema_name in schema_names:
+                rows = await connection.execute_dicts(
+                    POSTGRESQL_DEFERRABLE_CONSTRAINT_NAME_QUERY,
+                    [
+                        literals.qualify_table_name(referencing_meta.db_table, schema_name or referencing_meta.schema),
+                        literals.qualify_table_name(
+                            referenced_meta.db_table,
+                            schema_name if referenced_meta.tenant_schema and schema_name else referenced_meta.schema,
+                        ),
+                        list(foreign_key_field.db_column_names),
+                    ],
+                )
+                names.extend(row["name"] for row in rows if row["name"] not in names)
+        constraint_names = tuple(names)
+        ProtectConstraintDeferral.CONSTRAINT_NAMES_CACHE[(model, *names_key)] = constraint_names
+        return constraint_names
+
+    @staticmethod
+    @asynccontextmanager
+    async def defer(model: type[Model], connection: DatabaseClient) -> AsyncGenerator[bool]:
+        """Defers the PROTECT constraints of a hard delete of ``model`` rows for the block.
+
+        Args:
+            model: The model rows are deleted from.
+            connection: A client inside the transaction the delete runs in.
+
+        Yields:
+            Whether anything was deferred - False when no deferrable PROTECT constraint exists.
+
+        Raises:
+            IntegrityError: If a deferred constraint still fails once the block ends.
+        """
+        names = await PostgresqlForeignKeyDeferral.get_protect_constraint_names(model, connection)
+        if not names:
+            yield False
+            return
+        joined_names = ", ".join(names)
+        await connection.execute(f"SET CONSTRAINTS {joined_names} DEFERRED")
+        try:
+            yield True
+        except Exception:
+            # A failed block takes the deferral back too, where the transaction still runs statements;
+            # after a database error it is aborted - rolling back to a savepoint takes the deferral
+            # back itself - and the block's own error is the one raised.
+            with suppress(HareError):
+                await connection.execute(f"SET CONSTRAINTS {joined_names} IMMEDIATE")
+            raise
+        await connection.execute(f"SET CONSTRAINTS {joined_names} IMMEDIATE")