plain.postgres 0.103.0__tar.gz → 0.103.2__tar.gz

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.103.0
+Version: 0.103.2
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,27 @@
 # plain-postgres changelog
 
+## [0.103.2](https://github.com/dropseed/plain/releases/plain-postgres@0.103.2) (2026-05-06)
+
+### What's changed
+
+- **`postgres.missing_fk_indexes` preflight now recognizes bare-column leading expressions.** A `UniqueConstraint(F("team"), Lower("email"))` declared via the `expressions=` API previously slipped past the model-level check — the preflight only inspected `fields=`, so it warned about a missing FK index even though the underlying btree's leading column was the real `team` attribute and the live diagnose check correctly recognized coverage. The preflight now extracts the leading column from `F(...)` and `OrderBy(F(...))` expressions to match Postgres' actual coverage semantics. ([ae3880098f](https://github.com/dropseed/plain/commit/ae3880098f))
+- **Both FK-coverage checks now skip partial indexes.** A partial index like `Index(fields=["team"], condition=Q(deleted_at__isnull=True))` only satisfies queries whose predicate implies the partial-index `WHERE`, so an unfiltered FK lookup or cascade delete still sequential-scans. The preflight (`_fk_covered_field_names`) and the live diagnose check (`check_missing_fk_indexes`) both used to silently treat partial indexes as covering — now they don't, so the warning fires on the real coverage gap. The narrow `WHERE fk IS NOT NULL` case is conservatively also treated as not covering; users wanting guaranteed FK coverage should add a regular non-partial `Index(fields=[...])`. ([b1d13a6b42](https://github.com/dropseed/plain/commit/b1d13a6b42))
+- New `is_partial` property on `Index` and `UniqueConstraint` returning `condition is not None`, for callers that need the distinction. ([b1d13a6b42](https://github.com/dropseed/plain/commit/b1d13a6b42))
+
+### Upgrade instructions
+
+- No changes required. After upgrading, `postgres.missing_fk_indexes` may surface previously-undetected FK coverage gaps (where the only matching index was partial) and may suppress previously-warning false positives (where the only matching index used `expressions=`). Add a non-partial `Index(fields=["fk"])` to silence the warning in the partial-index case.
+
+## [0.103.1](https://github.com/dropseed/plain/releases/plain-postgres@0.103.1) (2026-05-06)
+
+### What's changed
+
+- **`postgres.duplicate_indexes` now flags exact-column duplicates**, not just prefix-redundancy. Previously the check required the redundant index to be strictly shorter than the index covering it, so an `Index(fields=["x"])` declared next to a same-column `UniqueConstraint(fields=["x"])` slipped past — even though the unique-backed btree already covers the same lookups and enforces uniqueness. The check (and the matching preflight) now flag the non-unique side of a same-column pair. Two non-unique indexes on identical columns flag the alphabetically later name (deterministic). ([253513b9](https://github.com/dropseed/plain/commit/253513b9))
+
+### Upgrade instructions
+
+- No changes required. After upgrading, `plain postgres diagnose` and `plain preflight` may surface previously-undetected duplicate indexes — drop the redundant `Index(...)` declaration on the model and run `plain postgres sync`.
+
 ## [0.103.0](https://github.com/dropseed/plain/releases/plain-postgres@0.103.0) (2026-05-06)
 
 ### What's changed

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/plain/postgres/constraints.py

@@ -250,6 +250,10 @@ class UniqueConstraint(BaseConstraint):
     def contains_expressions(self) -> bool:
         return bool(self.expressions)
 
+    @property
+    def is_partial(self) -> bool:
+        return self.condition is not None
+
     @property
     def index_only(self) -> bool:
         """Whether PostgreSQL can only store this as a unique index, not a constraint.

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/plain/postgres/indexes.py

@@ -83,6 +83,10 @@ class Index:
     def contains_expressions(self) -> bool:
         return bool(self.expressions)
 
+    @property
+    def is_partial(self) -> bool:
+        return self.condition is not None
+
     def to_sql(self, model: type[Model]) -> str:
         """Generate CREATE INDEX CONCURRENTLY SQL as a plain string."""
         table = model.model_options.db_table

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/plain/postgres/introspection/health/checks_structural.py

@@ -66,7 +66,17 @@ def check_invalid_indexes(
 def check_duplicate_indexes(
     cursor: Any, table_owners: dict[str, TableOwner]
 ) -> CheckResult:
-    """Indexes where one is a column-prefix of another on the same table.
+    """Indexes redundant with another on the same table.
+
+    Two flavors are flagged:
+
+    - **Prefix duplicate** — a non-unique index whose columns are a strict
+      prefix of another index's. The longer index covers the same queries.
+    - **Exact duplicate** — same columns and access method as another index.
+      If the pair contains a unique-backed btree, the non-unique one is the
+      redundant one (the unique already covers the queries and enforces
+      uniqueness). If both are non-unique, the alphabetically later name
+      gets flagged (deterministic).
 
     Each index column's canonical definition comes from
     ``pg_get_indexdef(indexrelid, k, false)`` — that text includes the
@@ -112,46 +122,56 @@ def check_duplicate_indexes(
     for table_name, indexes in by_table.items():
         for i, idx_a in enumerate(indexes):
             for idx_b in indexes[i + 1 :]:
-                # Check both directions: is either a prefix of the other?
+                # Try both orderings — prefix-redundancy is asymmetric, and
+                # exact-duplicate flagging picks one side deterministically.
                 for shorter, longer in [(idx_a, idx_b), (idx_b, idx_a)]:
                     name_s, am_s, defs_s, unique_s, size_s = shorter
-                    name_l, am_l, defs_l, _, _ = longer
+                    name_l, am_l, defs_l, unique_l, _ = longer
                     # Different access methods serve different operators
-                    # (e.g. hash supports `=` only, btree supports ordering),
-                    # and unique indexes serve a constraint purpose.
-                    if (
-                        name_s not in flagged
-                        and am_s == am_l
-                        and not unique_s
+                    # (e.g. hash supports `=` only, btree supports ordering).
+                    if name_s in flagged or am_s != am_l:
+                        continue
+
+                    is_prefix_dup = (
+                        not unique_s
                         and len(defs_s) < len(defs_l)
                         and defs_l[: len(defs_s)] == defs_s
-                    ):
-                        source, package, model_class, model_file = _table_info(
-                            table_name, table_owners
-                        )
-                        app_suggestion = f'Remove "{name_s}" from model indexes/constraints, then run plain postgres sync'
+                    )
+                    is_exact_dup = (
+                        defs_s == defs_l
+                        and not unique_s
+                        and (unique_l or name_s > name_l)
+                    )
+
+                    if not (is_prefix_dup or is_exact_dup):
+                        continue
+
+                    source, package, model_class, model_file = _table_info(
+                        table_name, table_owners
+                    )
+                    app_suggestion = f'Remove "{name_s}" from model indexes/constraints, then run plain postgres sync'
 
-                        items.append(
-                            CheckItem(
-                                table=table_name,
-                                name=name_s,
-                                detail=f"{size_s}, redundant with {name_l}",
+                    items.append(
+                        CheckItem(
+                            table=table_name,
+                            name=name_s,
+                            detail=f"{size_s}, redundant with {name_l}",
+                            source=source,
+                            package=package,
+                            model_class=model_class,
+                            model_file=model_file,
+                            suggestion=_index_suggestion(
                                 source=source,
                                 package=package,
                                 model_class=model_class,
                                 model_file=model_file,
-                                suggestion=_index_suggestion(
-                                    source=source,
-                                    package=package,
-                                    model_class=model_class,
-                                    model_file=model_file,
-                                    app_suggestion=app_suggestion,
-                                    unmanaged_suggestion=f'DROP INDEX CONCURRENTLY "{name_s}";',
-                                ),
-                                caveats=[],
-                            )
+                                app_suggestion=app_suggestion,
+                                unmanaged_suggestion=f'DROP INDEX CONCURRENTLY "{name_s}";',
+                            ),
+                            caveats=[],
                         )
-                        flagged.add(name_s)
+                    )
+                    flagged.add(name_s)
 
     return CheckResult(
         name="duplicate_indexes",
@@ -167,7 +187,16 @@ def check_duplicate_indexes(
 def check_missing_fk_indexes(
     cursor: Any, table_owners: dict[str, TableOwner]
 ) -> CheckResult:
-    """Foreign key columns without a leading index — JOINs on these do sequential scans."""
+    """Foreign key columns without a leading index — JOINs on these do sequential scans.
+
+    Partial indexes (``WHERE`` clause set on ``pg_index.indpred``) don't
+    count: Postgres only uses them for queries that imply the partial
+    predicate, so FK lookups and cascade deletes outside that predicate
+    still sequential-scan. The narrow ``WHERE fk IS NOT NULL`` case —
+    which Postgres can match to ``WHERE fk = ?`` — is conservatively
+    treated as not covering; users wanting guaranteed FK coverage should
+    add a regular non-partial index. Match the preflight's coverage rule.
+    """
     cursor.execute("""
         SELECT
             ct.relname AS table_name,
@@ -187,6 +216,7 @@ def check_missing_fk_indexes(
               FROM pg_catalog.pg_index i
               WHERE i.indrelid = c.conrelid
                 AND i.indkey[0] = c.conkey[1]
+                AND i.indpred IS NULL
           )
         ORDER BY ct.relname, a.attname
     """)

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/plain/postgres/preflight.py

@@ -8,6 +8,7 @@ from typing import Any
 from plain.packages import packages_registry
 from plain.postgres.constraints import UniqueConstraint
 from plain.postgres.db import get_connection
+from plain.postgres.expressions import F, OrderBy
 from plain.postgres.fields.related import ForeignKeyField
 from plain.postgres.registry import ModelsRegistry, models_registry
 from plain.preflight import PreflightCheck, PreflightResult, register_check
@@ -41,6 +42,61 @@ def _collect_model_indexes(model: Any) -> list[tuple[str, list[str], bool]]:
     return all_indexes
 
 
+def _bare_column_name(expr: Any) -> str | None:
+    """Return the column name if `expr` resolves to a bare column, else `None`.
+
+    Postgres can range-scan the leading column of an index for `WHERE col = ?`
+    only when that column is a real attribute, not an expression — so a
+    compound leading expression like `Lower("email")` returns `None` here.
+    Sort direction (`F("col").desc()` / `OrderBy(F)`) doesn't affect equality
+    lookups, so we unwrap one layer of `OrderBy` around a bare `F`.
+    """
+    if isinstance(expr, OrderBy):
+        expr = expr.expression
+    if isinstance(expr, F):
+        return expr.name
+    return None
+
+
+def _fk_covered_field_names(model: Any) -> set[str]:
+    """Field names that appear as the leading column of a non-partial index
+    or unique constraint — covering arbitrary FK lookups via the index's
+    leading column.
+
+    Partial indexes/constraints (declared with ``condition=Q(...)``) are
+    excluded: Postgres can only use them for queries whose predicate
+    implies the partial-index predicate, so an FK lookup or cascade
+    delete that doesn't filter by that condition still does a sequential
+    scan. (The narrow ``WHERE fk IS NOT NULL`` case — which Postgres can
+    match to ``WHERE fk = ?`` — is conservatively treated as not
+    covering; users wanting guaranteed FK coverage should add a regular
+    non-partial ``Index(fields=[...])``.) Includes expression-based
+    indexes/constraints whose leading expression is a bare
+    ``F(field_name)``.
+    """
+    covered: set[str] = set()
+
+    def _record_leading(
+        fields: tuple[str, ...] | list[str], expressions: tuple
+    ) -> None:
+        if fields:
+            covered.add(fields[0].lstrip("-"))
+        elif expressions:
+            name = _bare_column_name(expressions[0])
+            if name is not None:
+                covered.add(name)
+
+    for index in model.model_options.indexes:
+        if not index.is_partial:
+            _record_leading(index.fields, index.expressions)
+
+    for constraint in model.model_options.constraints:
+        if isinstance(constraint, UniqueConstraint) and not constraint.is_partial:
+            _record_leading(constraint.fields, constraint.expressions)
+
+    return covered
+
+
 @register_check("postgres.all_models")
 class CheckAllModels(PreflightCheck):
     """Validates all model definitions for common issues."""
@@ -386,10 +442,7 @@ class CheckMissingFKIndexes(PreflightCheck):
         results = []
 
         for model in _get_app_models():
-            # Leading field of each index/constraint covers FK lookups
-            covered_fields = {
-                fields[0] for _, fields, _ in _collect_model_indexes(model)
-            }
+            covered_fields = _fk_covered_field_names(model)
 
             for field in model._model_meta.local_fields:
                 if (
@@ -412,7 +465,12 @@ class CheckMissingFKIndexes(PreflightCheck):
 
 @register_check("postgres.duplicate_indexes")
 class CheckDuplicateIndexes(PreflightCheck):
-    """Warns about indexes that are prefix-redundant with other indexes or constraints."""
+    """Warns about indexes redundant with other indexes or constraints.
+
+    Catches both prefix-redundancy (a 1-column index shadowed by a wider
+    composite) and exact-column duplicates (an `Index(fields=["x"])` that
+    duplicates a same-column `UniqueConstraint`).
+    """
 
     def run(self) -> list[PreflightResult]:
         results = []
@@ -425,23 +483,52 @@ class CheckDuplicateIndexes(PreflightCheck):
                 for idx_b in all_indexes[i + 1 :]:
                     for shorter, longer in [(idx_a, idx_b), (idx_b, idx_a)]:
                         s_name, s_fields, s_unique = shorter
-                        l_name, l_fields, _ = longer
-                        if (
-                            s_name not in flagged
+                        l_name, l_fields, l_unique = longer
+
+                        if s_name in flagged:
+                            continue
+
+                        is_prefix_dup = (
+                            not s_unique
                             and len(s_fields) < len(l_fields)
                             and l_fields[: len(s_fields)] == s_fields
+                        )
+                        is_exact_dup = (
+                            s_fields == l_fields
                             and not s_unique
-                        ):
-                            results.append(
-                                PreflightResult(
-                                    fix=f"Index '{s_name}' on [{', '.join(s_fields)}] "
-                                    f"is redundant with '{l_name}' on [{', '.join(l_fields)}]. "
-                                    f"The longer index covers the same queries.",
-                                    obj=model.model_options.label,
-                                    id="postgres.duplicate_index",
-                                    warning=True,
-                                )
+                            and (l_unique or s_name > l_name)
+                        )
+
+                        if not (is_prefix_dup or is_exact_dup):
+                            continue
+
+                        if is_prefix_dup:
+                            fix = (
+                                f"Index '{s_name}' on [{', '.join(s_fields)}] "
+                                f"is redundant with '{l_name}' on [{', '.join(l_fields)}]. "
+                                f"The longer index covers the same queries."
                             )
-                            flagged.add(s_name)
+                        elif l_unique:
+                            fix = (
+                                f"Index '{s_name}' on [{', '.join(s_fields)}] "
+                                f"is redundant with '{l_name}' on the same columns. "
+                                f"The unique-backed index already covers these queries."
+                            )
+                        else:
+                            fix = (
+                                f"Index '{s_name}' on [{', '.join(s_fields)}] "
+                                f"is an exact duplicate of '{l_name}'. "
+                                f"Drop one of them."
+                            )
+
+                        results.append(
+                            PreflightResult(
+                                fix=fix,
+                                obj=model.model_options.label,
+                                id="postgres.duplicate_index",
+                                warning=True,
+                            )
+                        )
+                        flagged.add(s_name)
 
         return results

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.103.0"
+version = "0.103.2"
 description = "Model your data and store it in a database."
 authors = [{ name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev" }]
 readme = "README.md"

{plain_postgres-0.103.0 → plain_postgres-0.103.2}/tests/internal/test_diagnose.py

@@ -266,6 +266,75 @@ class TestStructuralScenarios:
             f"expected no duplicates flagged across access methods, got {flagged}"
         )
 
+    def test_duplicate_indexes_detected_when_non_unique_shadows_unique(self) -> None:
+        """A non-unique `Index(fields=["x"])` declared alongside a same-column
+        `UniqueConstraint(fields=["x"])` is pure overhead — the unique-backed
+        btree already covers the same queries. Flag the non-unique side."""
+        _execute(
+            'CREATE TABLE "_diag_dup_exact" ('
+            '"id" serial PRIMARY KEY, "uuid" uuid NOT NULL)'
+        )
+        _execute(
+            'CREATE UNIQUE INDEX "_diag_dup_exact_unique_uuid" '
+            'ON "_diag_dup_exact" ("uuid")'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_exact_uuid_idx" ON "_diag_dup_exact" ("uuid")'
+        )
+
+        conn = get_connection()
+        with conn.cursor() as cursor:
+            result = check_duplicate_indexes(cursor, {})
+
+        flagged = [i for i in result["items"] if i["table"] == "_diag_dup_exact"]
+        assert len(flagged) == 1, (
+            f"expected one duplicate on _diag_dup_exact, got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_dup_exact_uuid_idx"
+        assert "_diag_dup_exact_unique_uuid" in flagged[0]["detail"]
+
+    def test_duplicate_indexes_detected_when_two_non_unique_match_exactly(
+        self,
+    ) -> None:
+        """Two non-unique indexes on identical columns — flag the alphabetically
+        later name (deterministic) so we don't double-report or oscillate."""
+        _execute('CREATE TABLE "_diag_dup_pair" ("id" serial PRIMARY KEY, "x" int)')
+        _execute('CREATE INDEX "_diag_dup_pair_a_idx" ON "_diag_dup_pair" ("x")')
+        _execute('CREATE INDEX "_diag_dup_pair_z_idx" ON "_diag_dup_pair" ("x")')
+
+        conn = get_connection()
+        with conn.cursor() as cursor:
+            result = check_duplicate_indexes(cursor, {})
+
+        flagged = [i for i in result["items"] if i["table"] == "_diag_dup_pair"]
+        assert len(flagged) == 1, (
+            f"expected one duplicate on _diag_dup_pair, got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_dup_pair_z_idx"
+
+    def test_duplicate_indexes_not_flagged_for_two_unique_same_columns(self) -> None:
+        """Two unique indexes on identical columns is a Postgres-level redundancy
+        but neither is "the" overhead — both enforce uniqueness. Don't flag."""
+        _execute(
+            'CREATE TABLE "_diag_dup_two_uniq" ('
+            '"id" serial PRIMARY KEY, "x" int NOT NULL)'
+        )
+        _execute(
+            'CREATE UNIQUE INDEX "_diag_dup_two_uniq_a" ON "_diag_dup_two_uniq" ("x")'
+        )
+        _execute(
+            'CREATE UNIQUE INDEX "_diag_dup_two_uniq_b" ON "_diag_dup_two_uniq" ("x")'
+        )
+
+        conn = get_connection()
+        with conn.cursor() as cursor:
+            result = check_duplicate_indexes(cursor, {})
+
+        flagged = [i for i in result["items"] if i["table"] == "_diag_dup_two_uniq"]
+        assert flagged == [], (
+            f"expected no duplicates flagged for two unique same-column indexes, got {flagged}"
+        )
+
     def test_duplicate_indexes_not_flagged_when_longer_starts_with_expression(
         self,
     ) -> None:
@@ -335,6 +404,34 @@ class TestStructuralScenarios:
         flagged = [i for i in result["items"] if i["table"] == "_diag_fk_child2"]
         assert flagged == [], f"indexed FK should not be flagged; got {flagged}"
 
+    def test_missing_fk_index_detected_when_only_partial_index_covers(self) -> None:
+        """A partial index on the FK column doesn't cover arbitrary FK
+        lookups — Postgres can only use it for queries whose predicate
+        implies the partial-index `WHERE`. The check must still flag the
+        FK as missing index coverage."""
+        _execute('CREATE TABLE "_diag_fk_parent3" ("id" serial PRIMARY KEY)')
+        _execute(
+            'CREATE TABLE "_diag_fk_child3" ('
+            '"id" serial PRIMARY KEY, '
+            '"parent_id" int REFERENCES "_diag_fk_parent3"("id"), '
+            '"deleted_at" timestamptz)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_fk_child3_partial_parent_idx" '
+            'ON "_diag_fk_child3" ("parent_id") '
+            "WHERE deleted_at IS NULL"
+        )
+
+        conn = get_connection()
+        with conn.cursor() as cursor:
+            result = check_missing_fk_indexes(cursor, {})
+
+        flagged = [i for i in result["items"] if i["table"] == "_diag_fk_child3"]
+        assert len(flagged) == 1, (
+            f"partial index must not satisfy FK coverage; got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_fk_child3.parent_id"
+
     def test_sequence_exhaustion_critical_above_90pct(self) -> None:
         _execute('CREATE TABLE "_diag_seq" ("id" serial PRIMARY KEY, "n" int)')
         # int4 sequence max is 2^31-1 = 2147483647; push past 90% to trip critical.

plain_postgres-0.103.2/tests/internal/test_preflight_fk_coverage.py

@@ -0,0 +1,157 @@
+"""Unit tests for `_fk_covered_field_names` — the helper that powers
+`postgres.missing_fk_indexes`'s preflight check.
+
+The check fires on FK fields whose name doesn't appear here. The helper
+must recognize bare `F("col")` leading expressions so a constraint like
+`UniqueConstraint(F("team"), Lower("email"))` counts as covering the
+`team` FK — Postgres' underlying btree's leading column is the real
+`team` attribute, not an expression.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from plain.postgres import Q
+from plain.postgres.constraints import UniqueConstraint
+from plain.postgres.expressions import F
+from plain.postgres.functions import Lower
+from plain.postgres.indexes import Index
+from plain.postgres.preflight import _fk_covered_field_names
+
+
+def _model(*, indexes=(), constraints=()) -> SimpleNamespace:
+    """Minimal model_options stand-in for the helper."""
+    return SimpleNamespace(
+        model_options=SimpleNamespace(
+            indexes=list(indexes), constraints=list(constraints)
+        )
+    )
+
+
+def test_covers_index_with_fields():
+    model = _model(indexes=[Index(name="t_team_idx", fields=["team"])])
+    assert _fk_covered_field_names(model) == {"team"}
+
+
+def test_covers_unique_constraint_with_fields():
+    model = _model(
+        constraints=[
+            UniqueConstraint(fields=["team", "account"], name="t_team_acct_uniq")
+        ]
+    )
+    assert _fk_covered_field_names(model) == {"team"}
+
+
+def test_covers_unique_constraint_with_bare_f_leading_expression():
+    """A unique constraint declared via `expressions=` whose leading
+    expression is a bare `F("col")` covers the FK — the underlying btree's
+    leading attribute is still the real column."""
+    model = _model(
+        constraints=[
+            UniqueConstraint(
+                F("team"),
+                Lower("email"),
+                name="t_team_email_uniq",
+            )
+        ]
+    )
+    assert "team" in _fk_covered_field_names(model)
+
+
+def test_covers_unique_constraint_with_ordered_bare_f_leading_expression():
+    """`F("team").desc()` produces `OrderBy(F("team"))`. Postgres still emits
+    `team_id DESC` as a real leading column attribute, so equality FK
+    lookups are covered (sort direction doesn't matter for `WHERE = ?`)."""
+    model = _model(
+        constraints=[
+            UniqueConstraint(
+                F("team").desc(),
+                Lower("email"),
+                name="t_team_desc_email_uniq",
+            )
+        ]
+    )
+    assert "team" in _fk_covered_field_names(model)
+
+
+def test_does_not_cover_when_leading_expression_is_compound():
+    """`(LOWER(email), team)` cannot satisfy `WHERE team = ?` from the
+    leading column — the leading "column" is an expression, so Postgres
+    can't range-scan it for a value lookup on team."""
+    model = _model(
+        constraints=[
+            UniqueConstraint(
+                Lower("email"),
+                F("team"),
+                name="t_lower_email_team_uniq",
+            )
+        ]
+    )
+    assert "team" not in _fk_covered_field_names(model)
+
+
+def test_strips_descending_prefix_from_field_name():
+    """`fields=["-created_at"]` (descending) still has `created_at` as the
+    underlying column. The leading-column extraction must strip the prefix."""
+    model = _model(indexes=[Index(name="t_created_idx", fields=["-created_at"])])
+    assert _fk_covered_field_names(model) == {"created_at"}
+
+
+def test_unions_indexes_and_constraints():
+    model = _model(
+        indexes=[Index(name="t_a_idx", fields=["a"])],
+        constraints=[
+            UniqueConstraint(fields=["b"], name="t_b_uniq"),
+            UniqueConstraint(F("c"), Lower("d"), name="t_c_d_uniq"),
+        ],
+    )
+    assert _fk_covered_field_names(model) == {"a", "b", "c"}
+
+
+def test_partial_index_does_not_cover():
+    """`Index(fields=["team"], condition=Q(...))` only satisfies queries
+    whose predicate implies the partial-index `WHERE`. An unfiltered FK
+    lookup or cascade delete still sequential-scans, so the partial index
+    must not count as covering."""
+    model = _model(
+        indexes=[
+            Index(
+                name="t_team_active_idx",
+                fields=["team"],
+                condition=Q(deleted_at__isnull=True),
+            )
+        ]
+    )
+    assert "team" not in _fk_covered_field_names(model)
+
+
+def test_partial_unique_constraint_does_not_cover():
+    """Same logic as the partial index — soft-delete-style partial unique
+    constraints don't guarantee FK lookup coverage."""
+    model = _model(
+        constraints=[
+            UniqueConstraint(
+                fields=["team"],
+                name="t_team_active_uniq",
+                condition=Q(deleted_at__isnull=True),
+            )
+        ]
+    )
+    assert "team" not in _fk_covered_field_names(model)
+
+
+def test_full_index_still_covers_when_partial_sibling_exists():
+    """A non-partial index on the same column wins — partial-ness is per
+    declaration, not per column."""
+    model = _model(
+        indexes=[
+            Index(
+                name="t_team_active_idx",
+                fields=["team"],
+                condition=Q(deleted_at__isnull=True),
+            ),
+            Index(name="t_team_idx", fields=["team"]),
+        ]
+    )
+    assert "team" in _fk_covered_field_names(model)