plain.postgres 0.103.0__tar.gz → 0.103.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.103.0
+Version: 0.103.1
 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.1}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,15 @@
 # plain-postgres changelog
 
+## [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.1}/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",

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

@@ -412,7 +412,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 +430,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."
+                            )
+                        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."
                             )
-                            flagged.add(s_name)
+
+                        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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.103.0"
+version = "0.103.1"
 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.1}/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: