plain.postgres 0.114.0__tar.gz → 0.115.0__tar.gz

plain_postgres-0.114.0/plain/postgres/README.md → plain_postgres-0.115.0/PKG-INFO

@@ -1,3 +1,16 @@
+Metadata-Version: 2.5
+Name: plain.postgres
+Version: 0.115.0
+Summary: Model your data and store it in a database.
+Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: plain<1.0.0,>=0.157.0
+Requires-Dist: psycopg-pool>=3.2
+Requires-Dist: psycopg>=3.2
+Description-Content-Type: text/markdown
+
 # plain.postgres
 
 **Model your data and store it in a database.**
@@ -983,6 +996,14 @@ The first access to any non-key field loads the whole row in a single query. The
 
 The partial-instance shortcut is safe because Plain always creates a database foreign-key constraint, so the referenced row is guaranteed to exist.
 
+### Constraints are checked immediately
+
+Every constraint is checked at the write that violates it, never at commit — the same as Postgres's own default. Inserting a child row that points at a parent that doesn't exist yet fails at that `INSERT`, with a traceback pointing at the offending write, and deleting a parent with `RESTRICT` children fails at that `DELETE`. Create parents before children. A cycle of foreign keys needs a nullable back-reference: create both rows, then `update()` the back-reference. Two required foreign keys pointing at each other can never be inserted.
+
+To swap two rows' values under a unique constraint (reordering by `position`, say), move one row to a temporary value first — a single `UPDATE` that swaps them fails, because Postgres checks uniqueness per row.
+
+A migration can add a column, backfill it in `RunPython`, and drop or alter columns on the same table, all in one transaction.
+
 ### Reverse relationships
 
 When you define a `ForeignKey` or `ManyToManyField`, Plain automatically creates a reverse accessor on the related model (like `author.book_set`). You can explicitly declare these reverse relationships using [`ReverseForeignKey`](./fields/reverse_descriptors.py#ReverseForeignKey) and [`ReverseManyToMany`](./fields/reverse_descriptors.py#ReverseManyToMany):
@@ -1087,7 +1108,7 @@ class User(postgres.Model):
 
 Field-level validation happens automatically based on field types and constraints.
 
-**The database is authoritative for constraints.** `create()`/`update()` don't pre-check your declared unique/check constraints — they attempt the write, and if Postgres rejects it, translate the `IntegrityError` into a `ValidationError` (routed to the field for single-column uniques, `NON_FIELD_ERRORS` otherwise). You get the same field-level error you'd expect, the write costs no per-constraint `SELECT`, and a raced concurrent insert can't slip through as a 500. (FK violations, `NOT NULL`, and a hand-set primary-key collision have no declared constraint to map to and re-raise as the original `IntegrityError`. `create()` always inserts, so passing a stray `id` that already exists is rejected by Postgres as the original `IntegrityError`.)
+**The database is authoritative for constraints.** `create()`/`update()` don't pre-check your declared unique/check constraints — they attempt the write, and if Postgres rejects it, translate the `IntegrityError` into a `ValidationError` (routed to the field for single-column uniques, `NON_FIELD_ERRORS` otherwise). You get the same field-level error you'd expect, the write costs no per-constraint `SELECT`, and a raced concurrent insert can't slip through as a 500. A foreign key pointing at a row that doesn't exist maps the same way, as an error on that field. (`NOT NULL` and a hand-set primary-key collision have no declared constraint to map to and re-raise as the original `IntegrityError`. `create()` always inserts, so passing a stray `id` that already exists is rejected by Postgres as the original `IntegrityError`.)
 
 Because the rejected write reaches the database, it aborts the surrounding transaction. If you catch the `ValidationError` and want to keep using the transaction, wrap the write in `transaction.atomic()` so it rolls back to a savepoint:
 
@@ -1101,7 +1122,7 @@ except ValidationError:
 
 Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then writes via `form.create()`/`form.update()` with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
 
-This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to. If you retry on a unique conflict, catch both:
+This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to, and so does a `delete()` blocked by `RESTRICT` children. If you retry on a unique conflict, catch both:
 
 ```python
 try:
@@ -1112,8 +1133,6 @@ except (psycopg.IntegrityError, ValidationError):
 
 For a plain insert-or-update with no per-row logic, `bulk_create(..., update_conflicts=True, unique_fields=[...])` is an atomic upsert with no race to catch.
 
-Two caveats. The mapping covers **immediate** constraints — the default. An explicitly deferred constraint (`UniqueConstraint(deferrable=Deferrable.DEFERRED)`) is checked at commit, _after_ the write returns, so its violation still surfaces as a raw `psycopg.IntegrityError`. And when a row violates several constraints at once, a form's pre-check (or an explicit `validate_constraints()`) reports them all, while a direct `create()`/`update()` gets only the first one the database hits.
-
 ### Indexes and constraints
 
 You can optimize queries and ensure data integrity with indexes and constraints. These are managed automatically by [convergence](#convergence) — just declare them on the model and run `postgres sync`.

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,28 @@
 # plain-postgres changelog
 
+## [0.115.0](https://github.com/dropseed/plain/releases/plain-postgres@0.115.0) (2026-09-02)
+
+### What's changed
+
+- **Foreign keys are now `NOT DEFERRABLE`** (Postgres's own default) and checked at each write. Plain inherited Django's `DEFERRABLE INITIALLY DEFERRED` foreign keys, added in 2007 so fixtures could contain forward references. Plain has no fixtures, and the deferral was causing real problems: a migration that adds a column, backfills it in `RunPython`, then alters the same table failed with "cannot ALTER TABLE ... because it has pending trigger events" whenever the backfill touched a row, and FK violations only surfaced at `COMMIT` with a traceback pointing at `atomic.__exit__` instead of the offending write ([8cbfa0cb40](https://github.com/dropseed/plain/commit/8cbfa0cb40))
+- Convergence detects an existing `DEFERRABLE` foreign key as drift and fixes it with a catalog-only `ALTER CONSTRAINT ... NOT DEFERRABLE` — no revalidation scan, just a brief `ACCESS EXCLUSIVE` lock bounded by the usual `lock_timeout` — so the first `postgres sync` after upgrading rewrites every FK quickly. A legacy `DEFERRABLE` + `NOT VALID` foreign key gets both corrections in one pass ([8cbfa0cb40](https://github.com/dropseed/plain/commit/8cbfa0cb40))
+- `NO_ACTION` is removed. Its only meaning was deferred checking — use `RESTRICT` ([8cbfa0cb40](https://github.com/dropseed/plain/commit/8cbfa0cb40))
+- A foreign key violation from `create()`/`update()` now surfaces as a `ValidationError` routed to the `ForeignKeyField` — "Author with id 5 does not exist." — with code `invalid_choice` so forms can override it. It lands in the same `IntegrityError` mapping that unique and check constraints already used, so a missing related row reports like any other field error instead of a 500. The message is `ForeignKeyField.does_not_exist_error_message`. Set-based writes (`QuerySet.update()`, `bulk_create()`) and a `delete()` blocked by `RESTRICT` still raise the raw `psycopg` error, since there's no instance to attribute it to ([31df77e665](https://github.com/dropseed/plain/commit/31df77e665))
+- That mapping keys on the foreign key's generated constraint name, so convergence now treats a stale name — left behind by `RenameField`/`RenameModel`, which only rename the column or table — as drift and renames the constraint. Because the write-path mapping depends on those corrections having run, FK renames and the `NOT DEFERRABLE` flip block sync on failure. `generate_fk_constraint_name()` moved to `plain.postgres.utils` and is now the single source of that name for both convergence and the write path ([31df77e665](https://github.com/dropseed/plain/commit/31df77e665))
+- **`UniqueConstraint(deferrable=...)` and the `Deferrable` enum are removed.** With foreign keys immediate, this was the last deferred-constraint concept in Plain, nothing in Plain's own packages used it, and it forced a caveat onto every "constraints are checked at the write" statement while keeping the pending-trigger-events failure alive for one case. Rails (pre-7.1), Ecto, and Laravel never had it for uniques. Every constraint is now checked at the write that violates it, never at commit ([fd1e7f1e13](https://github.com/dropseed/plain/commit/fd1e7f1e13))
+- `DatabaseConnection.check_constraints()` is gone, and the pytest `db` fixture no longer forces deferred constraints to immediate at teardown — there is nothing left to defer ([fd1e7f1e13](https://github.com/dropseed/plain/commit/fd1e7f1e13))
+- Constraint renames now run in convergence pass 1, matching index renames, so anything else planned for the same constraint in that pass addresses it by its new name ([fd1e7f1e13](https://github.com/dropseed/plain/commit/fd1e7f1e13))
+- New README section, "Constraints are checked immediately", covering the patterns this changes: create parents before children, use a nullable back-reference for a foreign key cycle (two required FKs pointing at each other can never be inserted), and move through a temporary value when swapping two rows under a unique constraint, since Postgres checks uniqueness per row even within a single `UPDATE` ([8cbfa0cb40](https://github.com/dropseed/plain/commit/8cbfa0cb40), [fd1e7f1e13](https://github.com/dropseed/plain/commit/fd1e7f1e13))
+
+### Upgrade instructions
+
+- Replace `NO_ACTION` with `RESTRICT` in your models **and in any historical migration file that references it** — `postgres.NO_ACTION` no longer exists, so a migration importing it fails to load.
+- Remove `deferrable=` from every `UniqueConstraint(...)` and drop any `Deferrable` import. An existing deferred unique constraint in the database shows as CHANGED drift with staged-rollout guidance — nothing is rewritten silently.
+- Run `plain postgres sync` after upgrading. It flips every existing foreign key to `NOT DEFERRABLE` (catalog-only, no table scan) and renames foreign key constraints left stale by past `RenameField`/`RenameModel`.
+- Code that inserted a child row before its parent, or deleted a parent and re-pointed its children later in the same transaction, now raises `ForeignKeyViolation` at that statement rather than succeeding by commit time. Create parents before children; for a foreign key cycle, create both rows and then `update()` the nullable back-reference.
+- If you catch `psycopg.IntegrityError` around `create()`/`update()` to handle a missing related row, catch `ValidationError` instead — or both, if the same block also covers set-based writes.
+- If you called `connection.check_constraints()`, remove the call.
+
 ## [0.114.0](https://github.com/dropseed/plain/releases/plain-postgres@0.114.0) (2026-08-12)
 
 ### What's changed

plain_postgres-0.114.0/PKG-INFO → plain_postgres-0.115.0/plain/postgres/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.5
-Name: plain.postgres
-Version: 0.114.0
-Summary: Model your data and store it in a database.
-Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
-License-Expression: BSD-3-Clause
-License-File: LICENSE
-Requires-Python: >=3.13
-Requires-Dist: plain<1.0.0,>=0.157.0
-Requires-Dist: psycopg-pool>=3.2
-Requires-Dist: psycopg>=3.2
-Description-Content-Type: text/markdown
-
 # plain.postgres
 
 **Model your data and store it in a database.**
@@ -996,6 +983,14 @@ The first access to any non-key field loads the whole row in a single query. The
 
 The partial-instance shortcut is safe because Plain always creates a database foreign-key constraint, so the referenced row is guaranteed to exist.
 
+### Constraints are checked immediately
+
+Every constraint is checked at the write that violates it, never at commit — the same as Postgres's own default. Inserting a child row that points at a parent that doesn't exist yet fails at that `INSERT`, with a traceback pointing at the offending write, and deleting a parent with `RESTRICT` children fails at that `DELETE`. Create parents before children. A cycle of foreign keys needs a nullable back-reference: create both rows, then `update()` the back-reference. Two required foreign keys pointing at each other can never be inserted.
+
+To swap two rows' values under a unique constraint (reordering by `position`, say), move one row to a temporary value first — a single `UPDATE` that swaps them fails, because Postgres checks uniqueness per row.
+
+A migration can add a column, backfill it in `RunPython`, and drop or alter columns on the same table, all in one transaction.
+
 ### Reverse relationships
 
 When you define a `ForeignKey` or `ManyToManyField`, Plain automatically creates a reverse accessor on the related model (like `author.book_set`). You can explicitly declare these reverse relationships using [`ReverseForeignKey`](./fields/reverse_descriptors.py#ReverseForeignKey) and [`ReverseManyToMany`](./fields/reverse_descriptors.py#ReverseManyToMany):
@@ -1100,7 +1095,7 @@ class User(postgres.Model):
 
 Field-level validation happens automatically based on field types and constraints.
 
-**The database is authoritative for constraints.** `create()`/`update()` don't pre-check your declared unique/check constraints — they attempt the write, and if Postgres rejects it, translate the `IntegrityError` into a `ValidationError` (routed to the field for single-column uniques, `NON_FIELD_ERRORS` otherwise). You get the same field-level error you'd expect, the write costs no per-constraint `SELECT`, and a raced concurrent insert can't slip through as a 500. (FK violations, `NOT NULL`, and a hand-set primary-key collision have no declared constraint to map to and re-raise as the original `IntegrityError`. `create()` always inserts, so passing a stray `id` that already exists is rejected by Postgres as the original `IntegrityError`.)
+**The database is authoritative for constraints.** `create()`/`update()` don't pre-check your declared unique/check constraints — they attempt the write, and if Postgres rejects it, translate the `IntegrityError` into a `ValidationError` (routed to the field for single-column uniques, `NON_FIELD_ERRORS` otherwise). You get the same field-level error you'd expect, the write costs no per-constraint `SELECT`, and a raced concurrent insert can't slip through as a 500. A foreign key pointing at a row that doesn't exist maps the same way, as an error on that field. (`NOT NULL` and a hand-set primary-key collision have no declared constraint to map to and re-raise as the original `IntegrityError`. `create()` always inserts, so passing a stray `id` that already exists is rejected by Postgres as the original `IntegrityError`.)
 
 Because the rejected write reaches the database, it aborts the surrounding transaction. If you catch the `ValidationError` and want to keep using the transaction, wrap the write in `transaction.atomic()` so it rolls back to a savepoint:
 
@@ -1114,7 +1109,7 @@ except ValidationError:
 
 Forms are the exception: a `ModelForm` pre-checks constraints explicitly (a `validate_constraints()` call in its `_post_clean`) so it can surface every violation at once, then writes via `form.create()`/`form.update()` with validation already done. A direct `create()`/`update()` reports the first violation Postgres hits.
 
-This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to. If you retry on a unique conflict, catch both:
+This applies to instance writes only. Set-based writes — `QuerySet.update()` and `bulk_create()` — raise the raw `psycopg.IntegrityError`, since there's no instance to attribute the error to, and so does a `delete()` blocked by `RESTRICT` children. If you retry on a unique conflict, catch both:
 
 ```python
 try:
@@ -1125,8 +1120,6 @@ except (psycopg.IntegrityError, ValidationError):
 
 For a plain insert-or-update with no per-row logic, `bulk_create(..., update_conflicts=True, unique_fields=[...])` is an atomic upsert with no race to catch.
 
-Two caveats. The mapping covers **immediate** constraints — the default. An explicitly deferred constraint (`UniqueConstraint(deferrable=Deferrable.DEFERRED)`) is checked at commit, _after_ the write returns, so its violation still surfaces as a raw `psycopg.IntegrityError`. And when a row violates several constraints at once, a form's pre-check (or an explicit `validate_constraints()`) reports them all, while a direct `create()`/`update()` gets only the first one the database hits.
-
 ### Indexes and constraints
 
 You can optimize queries and ensure data integrity with indexes and constraints. These are managed automatically by [convergence](#convergence) — just declare them on the model and run `postgres sync`.

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/__init__.py

@@ -12,7 +12,7 @@ from .base import Model
 from .constraints import CheckConstraint, UniqueConstraint
 from .db import get_connection, use_management_connection
 from .middleware import DatabaseConnectionMiddleware
-from .deletion import CASCADE, NO_ACTION, RESTRICT, SET_NULL
+from .deletion import CASCADE, RESTRICT, SET_NULL
 from .expressions import F
 from .enums import TextChoices
 from .fields import (
@@ -57,7 +57,6 @@ from . import types
 # imported from their specific modules (e.g., plain.postgres.aggregates).
 __all__ = [
     "CASCADE",
-    "NO_ACTION",
     "RESTRICT",
     "SET_NULL",
     "BigIntegerField",

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/agents/.claude/rules/plain-postgres.md

@@ -69,7 +69,7 @@ Use `Model.query` to build querysets (e.g., `User.query.filter(is_active=True)`)
 - Use `.values_list()` when you only need specific columns
 - Wrap multi-step writes in `transaction.atomic()`
 - Instance writes are `obj.create()` (always INSERT) and `obj.update()` (always UPDATE; `update(fields=[...])` limits the columns) — there is no `save()`, `force_insert`, or `force_update`. Constructing an instance then `create()`-ing it inserts; a hand-set `id` that collides raises `IntegrityError`.
-- `create()`/`update()` raise `ValidationError` (not raw `psycopg.IntegrityError`) on a declared unique/check constraint violation, even a raced one — the DB enforces it, so inside an open `transaction.atomic()` the violation aborts the transaction (wrap the write in its own `atomic()` to catch and keep using the transaction). Set-based writes (`QuerySet.update()`/`bulk_create()`) raise raw `psycopg.IntegrityError`. Retrying on conflict? `except (psycopg.IntegrityError, ValidationError)`, or `bulk_create(..., update_conflicts=True)`
+- `create()`/`update()` raise `ValidationError` (not raw `psycopg.IntegrityError`) on a declared unique/check constraint violation or a foreign key pointing at a missing row, even a raced one — the DB enforces it, so inside an open `transaction.atomic()` the violation aborts the transaction (wrap the write in its own `atomic()` to catch and keep using the transaction). Set-based writes (`QuerySet.update()`/`bulk_create()`) and `delete()` blocked by `RESTRICT` raise raw `psycopg.IntegrityError`. Retrying on conflict? `except (psycopg.IntegrityError, ValidationError)`, or `bulk_create(..., update_conflicts=True)`
 - Always paginate list queries — unbounded querysets get slower as data grows
 
 Run `uv run plain docs postgres` for full patterns with code examples.
@@ -81,6 +81,7 @@ Run `uv run plain docs postgres` for full patterns with code examples.
 - Indexes: `{table}_{column(s)}_idx`
 - Constraints: `{table}_{column(s)}_{type}` (e.g., `_unique`, `_check`)
 - Choose `on_delete` deliberately: CASCADE for owned children, RESTRICT for referenced data, SET_NULL for optional references
+- Foreign keys are checked at each write, not at commit — create parents before children. A backfill followed by DDL on the same table in one migration is fine.
 - No `allow_null` on string fields — use `default=""`. Optional string fields are `required=False, default=""` — the declared default is what lets the column be added to a populated table (`required=False` alone only affects Python-side validation)
 
 Run `uv run plain docs postgres` for full patterns with code examples.

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/base.py

@@ -438,16 +438,20 @@ class Model(metaclass=ModelBase):
         """
         Map a Postgres constraint violation back to the constraint that raised
         it and return the ValidationError the in-Python check produces for that
-        constraint, or None when the violation doesn't correspond to a declared
-        constraint that can describe it (PK collisions, FK violations, and NOT
-        NULL — which carries no constraint name — all fall through to None and
-        re-raise as the original IntegrityError). A PK collision reaches here
-        when create() inserts a hand-set id that's already taken.
+        constraint or foreign key, or None when the violation doesn't
+        correspond to a declared constraint that can describe it (PK
+        collisions and NOT NULL — which carries no constraint name — fall
+        through to None and re-raise as the original IntegrityError). A PK
+        collision reaches here when create() inserts a hand-set id that's
+        already taken.
         """
         constraint_name = exc.diag.constraint_name
         if not constraint_name:
             return None
-        constraint = self._model_meta.constraints_by_name.get(constraint_name)
+        meta = self._model_meta
+        constraint = meta.constraints_by_name.get(
+            constraint_name
+        ) or meta.foreign_keys_by_constraint_name.get(constraint_name)
         if constraint is None:
             return None
         error = constraint._db_violation_error(self, self.__class__)
@@ -531,11 +535,9 @@ class Model(metaclass=ModelBase):
                 if not obj:
                     continue
                 # A pk may have been assigned manually to a model instance not
-                # saved to the database (or auto-generated in a case like
-                # UUIDField), but we allow the save to proceed and rely on the
-                # database to raise an IntegrityError if applicable. If
-                # constraints aren't supported by the database, there's the
-                # unavoidable risk of data corruption.
+                # saved to the database, but we allow the write to proceed and
+                # rely on the database's foreign key check (mapped to a
+                # ValidationError on the field) if the row doesn't exist.
                 if obj.id is None:
                     raise ValueError(
                         f"{operation_name}() prohibited to prevent data loss due to unsaved "
@@ -570,9 +572,9 @@ class Model(metaclass=ModelBase):
         # should always be deletable — custom querysets shape reads, not
         # internal row lifecycle operations.
         #
-        # mark_for_rollback_on_error: FK errors (RESTRICT / NO_ACTION) leave
-        # the DB transaction aborted. Mark the connection so outer atomic()
-        # blocks see the abort state even if the caller catches IntegrityError.
+        # mark_for_rollback_on_error: RESTRICT violations leave the DB
+        # transaction aborted. Mark the connection so outer atomic() blocks
+        # see the abort state even if the caller catches IntegrityError.
         with transaction.mark_for_rollback_on_error():
             count = self._model_meta.base_queryset.filter(id=self.id)._raw_delete()
         id_field = self._model_meta.get_forward_field("id")

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/connection.py

@@ -148,15 +148,6 @@ class DatabaseConnection:
         assert self.connection is not None
         self.connection.autocommit = autocommit
 
-    def check_constraints(self, table_names: list[str] | None = None) -> None:
-        """
-        Check constraints by setting them to immediate. Return them to deferred
-        afterward.
-        """
-        with self.cursor() as cursor:
-            cursor.execute("SET CONSTRAINTS ALL IMMEDIATE")
-            cursor.execute("SET CONSTRAINTS ALL DEFERRED")
-
     def make_debug_cursor(self, cursor: psycopg.Cursor[Any]) -> CursorDebugWrapper:
         return CursorDebugWrapper(cursor, self)
 
@@ -615,7 +606,8 @@ class DatabaseConnection:
                 WHERE fka.attrelid = c.confrelid AND fka.attnum = c.confkey[1]),
                 c.convalidated,
                 pg_get_constraintdef(c.oid),
-                c.confdeltype
+                c.confdeltype,
+                c.condeferrable
             FROM pg_constraint AS c
             JOIN pg_class AS cl ON c.conrelid = cl.oid
             WHERE cl.relname = %s AND pg_catalog.pg_table_is_visible(cl.oid)
@@ -630,6 +622,7 @@ class DatabaseConnection:
             validated,
             constraintdef,
             confdeltype,
+            condeferrable,
         ) in cursor.fetchall():
             constraints[constraint] = {
                 "columns": columns,
@@ -639,6 +632,7 @@ class DatabaseConnection:
                 "definition": constraintdef,
                 "validated": validated,
                 "on_delete_action": confdeltype if kind == "f" else None,
+                "deferrable": condeferrable if kind == "f" else None,
             }
         # Now get indexes. Sort order, opclasses, INCLUDE, and predicates all
         # ride along inside `pg_get_indexdef` and are compared via the

{plain_postgres-0.114.0 → plain_postgres-0.115.0}/plain/postgres/constraints.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from enum import Enum
 from types import NoneType
 from typing import TYPE_CHECKING, Any, cast
 
@@ -10,7 +9,6 @@ from plain.postgres.ddl import (
     build_include_sql,
     compile_expression_sql,
     compile_index_expressions_sql,
-    deferrable_sql,
 )
 from plain.postgres.dialect import quote_name
 from plain.postgres.exceptions import FieldError
@@ -26,7 +24,7 @@ from plain.postgres.query_utils import Q
 if TYPE_CHECKING:
     from plain.postgres.base import Model
 
-__all__ = ["BaseConstraint", "CheckConstraint", "Deferrable", "UniqueConstraint"]
+__all__ = ["BaseConstraint", "CheckConstraint", "UniqueConstraint"]
 
 
 ViolationError = str | dict[str, Any] | list[Any] | ValidationError
@@ -190,15 +188,6 @@ class CheckConstraint(BaseConstraint):
         return path, args, kwargs
 
 
-class Deferrable(Enum):
-    DEFERRED = "deferred"
-    IMMEDIATE = "immediate"
-
-    # A similar format was proposed for Python 3.10.
-    def __repr__(self) -> str:
-        return f"{self.__class__.__qualname__}.{self._name_}"
-
-
 class UniqueConstraint(BaseConstraint):
     expressions: tuple[ReplaceableExpression, ...]
 
@@ -208,7 +197,6 @@ class UniqueConstraint(BaseConstraint):
         fields: tuple[str, ...] | list[str] = (),
         name: str | None = None,
         condition: Q | None = None,
-        deferrable: Deferrable | None = None,
         include: tuple[str, ...] | list[str] | None = None,
         opclasses: tuple[str, ...] | list[str] = (),
         violation_error: ViolationError | None = None,
@@ -226,23 +214,11 @@ class UniqueConstraint(BaseConstraint):
             )
         if not isinstance(condition, NoneType | Q):
             raise TypeError("UniqueConstraint.condition must be a Q instance.")
-        if condition and deferrable:
-            raise ValueError("UniqueConstraint with conditions cannot be deferred.")
-        if include and deferrable:
-            raise ValueError("UniqueConstraint with include fields cannot be deferred.")
-        if opclasses and deferrable:
-            raise ValueError("UniqueConstraint with opclasses cannot be deferred.")
-        if expressions and deferrable:
-            raise ValueError("UniqueConstraint with expressions cannot be deferred.")
         if expressions and opclasses:
             raise ValueError(
                 "UniqueConstraint.opclasses cannot be used with expressions. "
                 "Use a custom OpClass() instead."
             )
-        if not isinstance(deferrable, NoneType | Deferrable):
-            raise TypeError(
-                "UniqueConstraint.deferrable must be a Deferrable instance."
-            )
         if not isinstance(include, NoneType | list | tuple):
             raise TypeError("UniqueConstraint.include must be a list or tuple.")
         if not isinstance(opclasses, list | tuple):
@@ -254,7 +230,6 @@ class UniqueConstraint(BaseConstraint):
             )
         self.fields = tuple(fields)
         self.condition = condition
-        self.deferrable = deferrable
         self.include = tuple(include) if include else ()
         self.opclasses = opclasses
         self.expressions = tuple(
@@ -311,7 +286,7 @@ class UniqueConstraint(BaseConstraint):
         elif condition or self.include or self.opclasses or self.expressions:
             return f"CREATE UNIQUE INDEX {name} ON {table} ({columns_sql}){include_sql}{condition_sql}"
         else:
-            return f"ALTER TABLE {table} ADD CONSTRAINT {name} UNIQUE ({columns_sql}){deferrable_sql(self.deferrable)}"
+            return f"ALTER TABLE {table} ADD CONSTRAINT {name} UNIQUE ({columns_sql})"
 
     def to_attach_sql(self, model: type[Model]) -> str:
         """Generate ALTER TABLE ADD CONSTRAINT UNIQUE USING INDEX SQL.
@@ -321,18 +296,15 @@ class UniqueConstraint(BaseConstraint):
         """
         table = quote_name(model.model_options.db_table)
         name = quote_name(self.name)
-        sql = f"ALTER TABLE {table} ADD CONSTRAINT {name} UNIQUE USING INDEX {name}"
-        sql += deferrable_sql(self.deferrable)
-        return sql
+        return f"ALTER TABLE {table} ADD CONSTRAINT {name} UNIQUE USING INDEX {name}"
 
     def __repr__(self) -> str:
-        return "<{}:{}{}{}{}{}{}{}{}>".format(
+        return "<{}:{}{}{}{}{}{}{}>".format(
             self.__class__.__qualname__,
             "" if not self.fields else f" fields={self.fields!r}",
             "" if not self.expressions else f" expressions={self.expressions!r}",
             f" name={self.name!r}",
             "" if self.condition is None else f" condition={self.condition}",
-            "" if self.deferrable is None else f" deferrable={self.deferrable!r}",
             "" if not self.include else f" include={self.include!r}",
             "" if not self.opclasses else f" opclasses={self.opclasses!r}",
             (
@@ -348,7 +320,6 @@ class UniqueConstraint(BaseConstraint):
                 self.name == other.name
                 and self.fields == other.fields
                 and self.condition == other.condition
-                and self.deferrable == other.deferrable
                 and self.include == other.include
                 and self.opclasses == other.opclasses
                 and self.expressions == other.expressions
@@ -362,8 +333,6 @@ class UniqueConstraint(BaseConstraint):
             kwargs["fields"] = self.fields
         if self.condition:
             kwargs["condition"] = self.condition
-        if self.deferrable:
-            kwargs["deferrable"] = self.deferrable
         if self.include:
             kwargs["include"] = self.include
         if self.opclasses: