plain.postgres 0.99.0__tar.gz → 0.99.1__tar.gz

{plain_postgres-0.99.0 → plain_postgres-0.99.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.99.0
+Version: 0.99.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.99.0 → plain_postgres-0.99.1}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,15 @@
 # plain-postgres changelog
 
+## [0.99.1](https://github.com/dropseed/plain/releases/plain-postgres@0.99.1) (2026-04-26)
+
+### What's changed
+
+- **Duplicate-index check now catches expression-prefix duplicates.** Previously the check excluded any index containing expressions (it compared raw `indkey`/`indclass` arrays), so a redundant `(LOWER(email))` alongside `(LOWER(email), team_id)` was missed. The query now compares per-column `pg_get_indexdef(indexrelid, k, false)` text — canonical output that includes column name/expression, opclass, collation, and sort order — and checks `pg_am.amname` separately so a hash and btree on the same column don't false-match. ([4bd8a713649f](https://github.com/dropseed/plain/commit/4bd8a713649f))
+
+### Upgrade instructions
+
+- No changes required.
+
 ## [0.99.0](https://github.com/dropseed/plain/releases/plain-postgres@0.99.0) (2026-04-23)
 
 ### What's changed

{plain_postgres-0.99.0 → plain_postgres-0.99.1}/plain/postgres/introspection/health/checks_structural.py

@@ -66,50 +66,65 @@ 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 where one is a column-prefix of another on the same table.
+
+    Each index column's canonical definition comes from
+    ``pg_get_indexdef(indexrelid, k, false)`` — that text includes the
+    column name or expression, plus any non-default operator class,
+    collation, or sort order. Comparing per-column definitions means we
+    catch expression duplicates (e.g. two ``LOWER(email)`` columns) and
+    won't false-positive across different opclasses or collations.
+    Access method (``pg_am.amname``) is checked separately because the
+    per-column text doesn't include it — a hash and btree on the same
+    column have identical column text but support different operators.
+    """
     cursor.execute("""
         SELECT
             ct.relname AS table_name,
             ci.relname AS index_name,
-            i.indkey::int[] AS column_numbers,
-            i.indclass::int[] AS opclass_numbers,
+            am.amname AS access_method,
+            array(
+                SELECT pg_get_indexdef(i.indexrelid, k, false)
+                FROM generate_series(1, i.indnatts) AS k
+            ) AS column_defs,
             i.indisunique,
-            pg_size_pretty(pg_relation_size(ci.oid)) AS index_size,
-            pg_relation_size(ci.oid) AS index_size_bytes
+            pg_size_pretty(pg_relation_size(ci.oid)) AS index_size
         FROM pg_catalog.pg_index i
         JOIN pg_catalog.pg_class ci ON ci.oid = i.indexrelid
         JOIN pg_catalog.pg_class ct ON ct.oid = i.indrelid
+        JOIN pg_catalog.pg_am am ON am.oid = ci.relam
         JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
         WHERE n.nspname = 'public'
           AND i.indisvalid
-          AND i.indexprs IS NULL
           AND i.indpred IS NULL
         ORDER BY ct.relname, ci.relname
     """)
     rows = cursor.fetchall()
 
-    # Group by table
-    by_table: dict[str, list[tuple[str, list[int], list[int], bool, str, int]]] = {}
-    for table_name, index_name, cols, opclasses, is_unique, size, size_bytes in rows:
+    by_table: dict[str, list[tuple[str, str, list[str], bool, str]]] = {}
+    for table_name, index_name, am_name, defs, is_unique, size in rows:
         by_table.setdefault(table_name, []).append(
-            (index_name, cols, opclasses, is_unique, size, size_bytes)
+            (index_name, am_name, defs, is_unique, size)
         )
 
     items: list[CheckItem] = []
-    flagged: set[str] = set()  # avoid reporting the same index multiple times
+    flagged: set[str] = set()
     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?
                 for shorter, longer in [(idx_a, idx_b), (idx_b, idx_a)]:
-                    name_s, cols_s, ops_s, unique_s, size_s, _ = shorter
-                    name_l, cols_l, ops_l, _, _, _ = longer
+                    name_s, am_s, defs_s, unique_s, size_s = shorter
+                    name_l, am_l, defs_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 len(cols_s) < len(cols_l)
-                        and cols_l[: len(cols_s)] == cols_s
-                        and ops_l[: len(cols_s)] == ops_s
-                        and not unique_s  # unique indexes serve a constraint purpose
+                        and am_s == am_l
+                        and 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

{plain_postgres-0.99.0 → plain_postgres-0.99.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.99.0"
+version = "0.99.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.99.0 → plain_postgres-0.99.1}/tests/test_diagnose.py

@@ -126,6 +126,174 @@ class TestStructuralScenarios:
         assert flagged[0]["name"] == "_diag_dup_a_idx"
         assert "_diag_dup_ab_idx" in flagged[0]["detail"]
 
+    def test_duplicate_indexes_detected_against_expression_index(self) -> None:
+        """A plain-column index is redundant with a longer index whose
+        trailing columns are expressions (e.g. `(team, LOWER(email))`)."""
+        _execute(
+            'CREATE TABLE "_diag_dup_expr" ('
+            '"id" serial PRIMARY KEY, "team_id" int, "email" text)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_team_idx" ON "_diag_dup_expr" ("team_id")'
+        )
+        _execute(
+            'CREATE UNIQUE INDEX "_diag_dup_expr_team_lower_email_uniq" '
+            'ON "_diag_dup_expr" ("team_id", LOWER("email"))'
+        )
+
+        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_expr"]
+        assert len(flagged) == 1, (
+            f"expected one duplicate on _diag_dup_expr, got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_dup_expr_team_idx"
+        assert "_diag_dup_expr_team_lower_email_uniq" in flagged[0]["detail"]
+
+    def test_duplicate_indexes_detected_when_shorter_is_expression(self) -> None:
+        """A `(LOWER(email))` index is redundant with `(LOWER(email), team_id)`
+        — the longer index's leading column satisfies any read on the shorter,
+        and `pg_get_indexdef` per-column comparison catches the match."""
+        _execute(
+            'CREATE TABLE "_diag_dup_expr_short" ('
+            '"id" serial PRIMARY KEY, "email" text, "team_id" int)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_short_lower_idx" '
+            'ON "_diag_dup_expr_short" (LOWER("email"))'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_short_lower_team_idx" '
+            'ON "_diag_dup_expr_short" (LOWER("email"), "team_id")'
+        )
+
+        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_expr_short"]
+        assert len(flagged) == 1, (
+            f"expected one duplicate on _diag_dup_expr_short, got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_dup_expr_short_lower_idx"
+        assert "_diag_dup_expr_short_lower_team_idx" in flagged[0]["detail"]
+
+    def test_duplicate_indexes_not_flagged_for_same_length_expression_indexes(
+        self,
+    ) -> None:
+        """Two single-column expression indexes with different expressions
+        (`LOWER(email)` vs `UPPER(email)`) — neither qualifies as shorter
+        under `len(defs_s) < len(defs_l)`, so no false positive."""
+        _execute(
+            'CREATE TABLE "_diag_dup_expr_eq" ("id" serial PRIMARY KEY, "email" text)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_eq_lower_idx" '
+            'ON "_diag_dup_expr_eq" (LOWER("email"))'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_eq_upper_idx" '
+            'ON "_diag_dup_expr_eq" (UPPER("email"))'
+        )
+
+        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_expr_eq"]
+        assert flagged == [], (
+            f"expected no duplicates flagged for same-length expression indexes, got {flagged}"
+        )
+
+    def test_duplicate_indexes_detected_when_longer_expression_index_is_not_unique(
+        self,
+    ) -> None:
+        """Uniqueness only matters for the shorter side (a unique short index
+        serves a constraint purpose). The longer side's uniqueness is
+        irrelevant — a redundant non-unique short index should still be
+        flagged against a non-unique longer expression index."""
+        _execute(
+            'CREATE TABLE "_diag_dup_expr_nonuniq" ('
+            '"id" serial PRIMARY KEY, "team_id" int, "email" text)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_nonuniq_team_idx" '
+            'ON "_diag_dup_expr_nonuniq" ("team_id")'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_nonuniq_team_lower_idx" '
+            'ON "_diag_dup_expr_nonuniq" ("team_id", LOWER("email"))'
+        )
+
+        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_expr_nonuniq"]
+        assert len(flagged) == 1, (
+            f"expected one duplicate on _diag_dup_expr_nonuniq, got {flagged}"
+        )
+        assert flagged[0]["name"] == "_diag_dup_expr_nonuniq_team_idx"
+        assert "_diag_dup_expr_nonuniq_team_lower_idx" in flagged[0]["detail"]
+
+    def test_duplicate_indexes_not_flagged_across_access_methods(self) -> None:
+        """A hash index and a btree index on the same column support different
+        operators (hash: only `=`; btree: ordering, range, etc.). Per-column
+        text is identical, so we must check `pg_am.amname` to avoid telling
+        the user to drop a deliberately-chosen hash index."""
+        _execute(
+            'CREATE TABLE "_diag_dup_am" ('
+            '"id" serial PRIMARY KEY, "team_id" int, "email" text)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_am_team_hash_idx" '
+            'ON "_diag_dup_am" USING hash ("team_id")'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_am_team_email_idx" '
+            'ON "_diag_dup_am" USING btree ("team_id", LOWER("email"))'
+        )
+
+        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_am"]
+        assert flagged == [], (
+            f"expected no duplicates flagged across access methods, got {flagged}"
+        )
+
+    def test_duplicate_indexes_not_flagged_when_longer_starts_with_expression(
+        self,
+    ) -> None:
+        """A column-only shorter index `(team_id)` is not a true prefix of a
+        longer index that leads with an expression `(LOWER(email), team_id)`
+        — Postgres can't satisfy `WHERE team_id = ?` from the longer index,
+        and per-column text comparison correctly skips it."""
+        _execute(
+            'CREATE TABLE "_diag_dup_expr_lead" ('
+            '"id" serial PRIMARY KEY, "email" text, "team_id" int)'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_lead_team_idx" '
+            'ON "_diag_dup_expr_lead" ("team_id")'
+        )
+        _execute(
+            'CREATE INDEX "_diag_dup_expr_lead_lower_team_idx" '
+            'ON "_diag_dup_expr_lead" (LOWER("email"), "team_id")'
+        )
+
+        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_expr_lead"]
+        assert flagged == [], (
+            f"expected no duplicates flagged when longer leads with expression, got {flagged}"
+        )
+
     def test_missing_fk_index_detected(self) -> None:
         _execute('CREATE TABLE "_diag_fk_parent" ("id" serial PRIMARY KEY)')
         _execute(