plain.postgres 0.114.0__tar.gz → 0.116.0__tar.gz

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

@@ -1,3 +1,16 @@
+Metadata-Version: 2.5
+Name: plain.postgres
+Version: 0.116.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.116.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,48 @@
 # plain-postgres changelog
 
+## [0.116.0](https://github.com/dropseed/plain/releases/plain-postgres@0.116.0) (2026-09-04)
+
+### What's changed
+
+- **`Meta` now exposes exactly two forward-field collections: `fields` and `many_to_many`.** `local_fields`, `local_many_to_many`, `concrete_fields`, and `local_concrete_fields` are gone. Plain has no model inheritance and no non-concrete forward fields, so "local" and "concrete" drew distinctions that could never differ — four names for two lists, each with its own cached property and its own filtering pass. `fields` is every column-backed field (primary key first, then sorted by name) and `many_to_many` is every `ManyToManyField` (sorted by name); both now read straight from the storage `add_field()` fills, instead of re-filtering `_get_fields()` on each access ([9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- `Meta.fields` is typed as `ImmutableList[ColumnField]` and `Meta.many_to_many` as `ImmutableList[ManyToManyField]`, so the column attributes (`column`, `db_type()`, `primary_key`) are readable off a field without an `isinstance` check first. `add_field()` enforces that by raising `TypeError` for a field that is neither a `ColumnField` nor a `ManyToManyField` ([996c099e2b](https://github.com/dropseed/plain/commit/996c099e2b), [9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- The `postgres.non_local_field_reference` preflight check is removed. It rejected an `indexes` or `constraints` entry naming a field "not local to" the model — unreachable without inheritance, since a forward field found on the model is always the model's own ([9f0d0da22d](https://github.com/dropseed/plain/commit/9f0d0da22d))
+- `Field.name` is typed `str` instead of `str | None` — it starts as `""` and becomes the real name in `set_attributes_from_name()`. That drops roughly twenty `assert self.name is not None` guards from the field descriptor, save, and preflight paths. `Field.deconstruct()` (and the `ColumnField`, `DefaultableField`, `ChoicesField`, `RelatedField`, `ForeignKeyField`, and `ManyToManyField` overrides) returns `tuple[str, str, list, dict]` accordingly ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `get_joining_columns()` moved from `ForeignObjectRel` to `ForeignKeyRel`. It delegates to `field.get_joining_columns(reverse_join=True)`, which only a foreign key has ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `PathInfo.join_field` is typed `ForeignKeyField | ForeignKeyRel` (was `ForeignKeyField | ForeignObjectRel`), and `select_related_descend()` is a `TypeGuard[RelatedField]` so a passing field narrows at the call site ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+- `QuerySet._update()`, `_insert()`, `_batched_insert()`, `UpdateQuery.add_update_fields()`, and `InsertQuery.insert_values()` accept a `Sequence` of fields rather than requiring a `list`, so an `ImmutableList` from `Meta` can be passed straight through ([51cb71f758](https://github.com/dropseed/plain/commit/51cb71f758))
+
+### Upgrade instructions
+
+- Replace `_model_meta.local_fields`, `_model_meta.concrete_fields`, and `_model_meta.local_concrete_fields` with `_model_meta.fields`. In Plain these were always the same set of fields.
+- Replace `_model_meta.local_many_to_many` with `_model_meta.many_to_many`.
+- Replace `_model_meta._non_pk_concrete_field_names` with `_model_meta._non_pk_field_names`.
+- If you have a custom `Field` subclass, `deconstruct()` now returns `str` as its first element rather than `str | None`, and `self.name` is `""` (not `None`) before the field is contributed to a model class. Update any annotation or `is None` check accordingly.
+- If you called `get_joining_columns()` on a reverse relation, it is now available on `ForeignKeyRel` only.
+
+## [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.116.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.116.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.116.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.116.0}/plain/postgres/base.py

@@ -27,7 +27,6 @@ from plain.postgres.exceptions import (
 )
 from plain.postgres.expressions import RawSQL, Value
 from plain.postgres.fields import DATABASE_DEFAULT, Field
-from plain.postgres.fields.base import ColumnField
 from plain.postgres.fields.related import RelatedField
 from plain.postgres.fields.reverse_related import ForeignObjectRel
 from plain.postgres.meta import Meta
@@ -123,10 +122,6 @@ class Model(metaclass=ModelBase):
         for field in meta.fields:
             from plain.postgres.fields.related import RelatedField
 
-            # meta.fields excludes ManyToManyField, so every iterated field
-            # is column-backed and exposes the ColumnField surface.
-            assert isinstance(field, ColumnField)
-
             is_related_object = False
             # Virtual field
             if field.name not in kwargs and field.column is None:
@@ -193,16 +188,14 @@ class Model(metaclass=ModelBase):
 
     @classmethod
     def from_db(cls, field_names: Iterable[str], values: Sequence[Any]) -> Model:
-        if len(values) != len(cls._model_meta.concrete_fields):
+        if len(values) != len(cls._model_meta.fields):
             values_iter = iter(values)
             values = [
                 next(values_iter) if f.name in field_names else DEFERRED
-                for f in cls._model_meta.concrete_fields
+                for f in cls._model_meta.fields
             ]
         # Build kwargs dict from field names and values
-        field_dict = dict(
-            zip((f.name for f in cls._model_meta.concrete_fields), values)
-        )
+        field_dict = dict(zip((f.name for f in cls._model_meta.fields), values))
         new = cls(_from_db=True, **field_dict)
         new._state.adding = False
         return new
@@ -279,11 +272,7 @@ class Model(metaclass=ModelBase):
         """
         Return a set containing names of deferred fields for this instance.
         """
-        return {
-            f.name
-            for f in self._model_meta.concrete_fields
-            if f.name not in self.__dict__
-        }
+        return {f.name for f in self._model_meta.fields if f.name not in self.__dict__}
 
     def refresh_from_db(self, fields: list[str] | None = None) -> None:
         """
@@ -320,15 +309,13 @@ class Model(metaclass=ModelBase):
             db_instance_qs = db_instance_qs.only(*fields)
         elif deferred_fields:
             fields = [
-                f.name
-                for f in self._model_meta.concrete_fields
-                if f.name not in deferred_fields
+                f.name for f in self._model_meta.fields if f.name not in deferred_fields
             ]
             db_instance_qs = db_instance_qs.only(*fields)
 
         db_instance = db_instance_qs.get()
         non_loaded_fields = db_instance.get_deferred_fields()
-        for field in self._model_meta.concrete_fields:
+        for field in self._model_meta.fields:
             if field.name in non_loaded_fields:
                 # This field wasn't refreshed - skip ahead.
                 continue
@@ -404,7 +391,7 @@ class Model(metaclass=ModelBase):
             if not fields:
                 return self  # explicit "update nothing" -- no-op
             fields = frozenset(fields)
-            field_names = self._model_meta._non_pk_concrete_field_names
+            field_names = self._model_meta._non_pk_field_names
             non_model_fields = fields.difference(field_names)
             if non_model_fields:
                 raise ValueError(
@@ -420,7 +407,7 @@ class Model(metaclass=ModelBase):
                 )
         elif deferred_fields:
             # Loaded via .only()/.defer() -- write just the loaded fields.
-            loaded = self._model_meta._non_pk_concrete_field_names - deferred_fields
+            loaded = self._model_meta._non_pk_field_names - deferred_fields
             if loaded:
                 fields = loaded
         self._prepare_related_fields_for_save(
@@ -438,16 +425,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__)
@@ -480,7 +471,7 @@ class Model(metaclass=ModelBase):
         fields from RETURNING. Omits id from the INSERT when unset so Postgres
         generates the identity value."""
         meta = self._model_meta
-        fields = list(meta.local_concrete_fields)
+        fields = list(meta.fields)
         if self.id is None:
             id_field = meta.get_forward_field("id")
             fields = [f for f in fields if f is not id_field]
@@ -490,7 +481,6 @@ class Model(metaclass=ModelBase):
         )
         if results:
             for value, field in zip(results[0], returning_fields):
-                assert field.name is not None
                 setattr(self, field.name, value)
 
     def _update_row(self, fields: Iterable[str] | None) -> None:
@@ -498,7 +488,7 @@ class Model(metaclass=ModelBase):
         row matched -- update() targets an existing row and has no INSERT
         fallback (that's create())."""
         meta = self._model_meta
-        non_pks = [f for f in meta.local_concrete_fields if not f.primary_key]
+        non_pks = [f for f in meta.fields if not f.primary_key]
         if fields:
             non_pks = [f for f in non_pks if f.name in fields]
         values = [(f, f.pre_save(self, False)) for f in non_pks]
@@ -521,7 +511,7 @@ class Model(metaclass=ModelBase):
     ) -> None:
         # Ensure that a model instance without a PK hasn't been assigned to
         # a ForeignKeyField on this model. If the field is nullable, allowing the save would result in silent data loss.
-        for field in self._model_meta.concrete_fields:
+        for field in self._model_meta.fields:
             if field_names and field.name not in field_names:
                 continue
             # If the related field isn't cached, then an instance hasn't been
@@ -531,11 +521,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,13 +558,12 @@ 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")
-        assert id_field.name is not None
         setattr(self, id_field.name, None)
         # Only the id is cleared -- every other field value survives so callers
         # can still reference a deleted row (correlate it, log it, check it's
@@ -609,7 +596,7 @@ class Model(metaclass=ModelBase):
         meta = meta or self._model_meta
         return {
             field.name: Value(field.value_from_object(self), field)
-            for field in meta.local_concrete_fields
+            for field in meta.fields
             if field.name not in exclude
         }
 
@@ -753,9 +740,9 @@ class Model(metaclass=ModelBase):
     def _check_fields(cls) -> list[PreflightResult]:
         """Perform all field checks."""
         errors: list[PreflightResult] = []
-        for field in cls._model_meta.local_fields:
+        for field in cls._model_meta.fields:
             errors.extend(field.preflight(from_model=cls))
-        for field in cls._model_meta.local_many_to_many:
+        for field in cls._model_meta.many_to_many:
             errors.extend(field.preflight(from_model=cls))
         return errors
 
@@ -766,7 +753,7 @@ class Model(metaclass=ModelBase):
         errors: list[PreflightResult] = []
         seen_intermediary_signatures = []
 
-        fields = cls._model_meta.local_many_to_many
+        fields = cls._model_meta.many_to_many
 
         # Skip when the target model wasn't found.
         fields = (f for f in fields if isinstance(f.remote_field.model, ModelBase))
@@ -798,9 +785,7 @@ class Model(metaclass=ModelBase):
     def _check_id_field(cls) -> list[PreflightResult]:
         """Disallow user-defined fields named ``id``."""
         if any(
-            f
-            for f in cls._model_meta.local_fields
-            if f.name == "id" and not f.auto_created
+            f for f in cls._model_meta.fields if f.name == "id" and not f.auto_created
         ):
             return [
                 PreflightResult(
@@ -817,7 +802,7 @@ class Model(metaclass=ModelBase):
         errors: list[PreflightResult] = []
         used_fields = {}  # name -> field
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             clash = used_fields.get(f.name)
             # Note that we may detect clash between user-defined non-unique
             # field "id" and automatically added unique field "id", both
@@ -845,7 +830,7 @@ class Model(metaclass=ModelBase):
         used_column_names: list[str] = []
         errors: list[PreflightResult] = []
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             column_name = f.column
 
             # Ensure the column name is not already in use.
@@ -913,7 +898,7 @@ class Model(metaclass=ModelBase):
     @classmethod
     def _check_single_primary_key(cls) -> list[PreflightResult]:
         errors: list[PreflightResult] = []
-        if sum(1 for f in cls._model_meta.local_fields if f.primary_key) > 1:
+        if sum(1 for f in cls._model_meta.fields if f.primary_key) > 1:
             errors.append(
                 PreflightResult(
                     fix="The model cannot have more than one field with "
@@ -964,11 +949,11 @@ class Model(metaclass=ModelBase):
             include for index in cls.model_options.indexes for include in index.include
         ]
         fields += references
-        errors.extend(cls._check_local_fields(fields, "indexes"))
+        errors.extend(cls._check_referenced_fields(fields, "indexes"))
         return errors
 
     @classmethod
-    def _check_local_fields(
+    def _check_referenced_fields(
         cls, fields: Iterable[str], option: str
     ) -> list[PreflightResult]:
         # In order to avoid hitting the relation tree prematurely, we use our
@@ -1001,15 +986,6 @@ class Model(metaclass=ModelBase):
                             id="postgres.m2m_field_in_meta_option",
                         )
                     )
-                elif field not in cls._model_meta.local_fields:
-                    errors.append(
-                        PreflightResult(
-                            fix=f"'{option}' refers to field '{field_name}' which is not local to model "
-                            f"'{cls.model_options.object_name}'.",
-                            obj=cls,
-                            id="postgres.non_local_field_reference",
-                        )
-                    )
         return errors
 
     @classmethod
@@ -1087,9 +1063,9 @@ class Model(metaclass=ModelBase):
         meta = cls._model_meta
         valid_fields = set(
             chain.from_iterable(
-                (f.name,)
-                if not (f.auto_created and not f.concrete)
-                else (f.field.related_query_name(),)
+                (f.field.related_query_name(),)
+                if isinstance(f, ForeignObjectRel)
+                else (f.name,)
                 for f in chain(meta.fields, meta.related_objects)
             )
         )
@@ -1119,7 +1095,7 @@ class Model(metaclass=ModelBase):
         # silently truncate, so we check for names that are too long
         allowed_len = MAX_NAME_LENGTH
 
-        for f in cls._model_meta.local_fields:
+        for f in cls._model_meta.fields:
             column_name = f.column
 
             # Check if column name is too long for the database.
@@ -1133,13 +1109,13 @@ class Model(metaclass=ModelBase):
                     )
                 )
 
-        for f in cls._model_meta.local_many_to_many:
+        for f in cls._model_meta.many_to_many:
             # Skip nonexistent models.
             if isinstance(f.remote_field.through, str):
                 continue
 
             # Check if column name for the M2M field is too long for the database.
-            for m2m in f.remote_field.through._model_meta.local_fields:
+            for m2m in f.remote_field.through._model_meta.fields:
                 rel_name = m2m.column
                 if rel_name is not None and len(rel_name) > allowed_len:
                     errors.append(
@@ -1233,7 +1209,7 @@ class Model(metaclass=ModelBase):
                         id="postgres.constraint_refers_to_joined_field",
                     )
                 )
-        errors.extend(cls._check_local_fields(fields, "constraints"))
+        errors.extend(cls._check_referenced_fields(fields, "constraints"))
         return errors
 
 

{plain_postgres-0.114.0 → plain_postgres-0.116.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)
 
@@ -544,9 +535,7 @@ class DatabaseConnection:
         tables = set()
         for model in get_migratable_models():
             tables.add(model.model_options.db_table)
-            tables.update(
-                f.m2m_db_table() for f in model._model_meta.local_many_to_many
-            )
+            tables.update(f.m2m_db_table() for f in model._model_meta.many_to_many)
         tables = list(tables)
         if only_existing:
             existing_tables = set(self.table_names(include_views=include_views))
@@ -615,7 +604,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 +620,7 @@ class DatabaseConnection:
             validated,
             constraintdef,
             confdeltype,
+            condeferrable,
         ) in cursor.fetchall():
             constraints[constraint] = {
                 "columns": columns,
@@ -639,6 +630,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