plain.postgres 0.88.2__tar.gz → 0.89.1__tar.gz

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.88.2
+Version: 0.89.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.88.2 → plain_postgres-0.89.1}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,63 @@
 # plain-postgres changelog
 
+## [0.89.1](https://github.com/dropseed/plain/releases/plain-postgres@0.89.1) (2026-03-26)
+
+### What's changed
+
+- Fixed `schema` command type mismatches for `time`, `timestamp`, and `DecimalField` types that caused false drift reports ([187e39e3faeb](https://github.com/dropseed/plain/commit/187e39e3faeb))
+- Fixed `schema` command crash on expression-based unique constraints (e.g. `UniqueConstraint` with `expressions` instead of `fields`) ([187e39e3faeb](https://github.com/dropseed/plain/commit/187e39e3faeb))
+- Improved 0.89.0 upgrade instructions with clearer ordering and step descriptions ([a59062327ed5](https://github.com/dropseed/plain/commit/a59062327ed5), [c0520bdca709](https://github.com/dropseed/plain/commit/c0520bdca709))
+
+### Upgrade instructions
+
+- No changes required.
+
+## [0.89.0](https://github.com/dropseed/plain/releases/plain-postgres@0.89.0) (2026-03-25)
+
+### What's changed
+
+- **Removed `db_index` from `ForeignKeyField`** — FK fields no longer create indexes automatically. Declare an explicit `Index(fields=["field"], name="...")` for any FK column that needs one. The `db_index` parameter has been removed entirely. ([061b97f5d538](https://github.com/dropseed/plain/commit/061b97f5d538))
+- **Removed `Index.set_name_with_model()`** — the hash-based auto-naming machinery is gone. `Index.name` is now validated as non-empty at construction time. ([9a4ecf8ac2f0](https://github.com/dropseed/plain/commit/9a4ecf8ac2f0))
+- **Index/constraint name collision detection** — preflight now checks index and constraint names together (they share the same Postgres namespace), catching cross-type collisions that would fail at migrate time. ([292f8d6791d6](https://github.com/dropseed/plain/commit/292f8d6791d6))
+- **New `plain postgres schema` command** — shows expected DB schema from model definitions and compares it against the actual database. Detects column type mismatches, nullability drift, missing/extra columns, and orphan indexes. Use `--check` for CI (exits non-zero on drift). ([ee336078483f](https://github.com/dropseed/plain/commit/ee336078483f))
+
+### Upgrade instructions
+
+1. Remove any `db_index=False` from FK fields in models and migration files — the parameter no longer exists.
+
+2. For each `ForeignKeyField`, check if it's covered by an explicit `Index` or `UniqueConstraint` (with the FK as the leading field). Most FK columns should have an index.
+
+3. **If uncovered**, add an explicit index:
+
+    ```python
+    model_options = postgres.Options(
+        indexes=[
+            postgres.Index(name="myapp_mymodel_author_id_idx", fields=["author"]),
+        ],
+    )
+    ```
+
+4. Run `makemigrations`. Before the `AddIndex` operation, add a `RunSQL` to drop the orphan auto-index left behind by the old `db_index=True` default:
+
+    ```python
+    operations = [
+        migrations.RunSQL('DROP INDEX IF EXISTS "myapp_mymodel_author_id_abc12345"'),
+        migrations.AddIndex(...),
+    ]
+    ```
+
+    The old auto-index name follows the pattern `{table}_{column}_{hash}`. Find orphan names by running `plain postgres schema`.
+
+5. **If already covered** by a composite index or unique constraint, the orphan auto-index is redundant. Generate a migration to drop it:
+
+    ```python
+    operations = [
+        migrations.RunSQL('DROP INDEX IF EXISTS "myapp_mymodel_author_id_abc12345"'),
+    ]
+    ```
+
+6. Run `migrate`.
+
 ## [0.88.2](https://github.com/dropseed/plain/releases/plain-postgres@0.88.2) (2026-03-25)
 
 ### What's changed

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/cli/core.py

@@ -15,6 +15,7 @@ from ..db import get_connection
 from ..dialect import quote_name
 from ..migrations.recorder import MIGRATION_TABLE_NAME
 from .diagnose import diagnose
+from .schema import schema
 
 
 @register_cli("postgres")
@@ -25,6 +26,7 @@ def cli() -> None:
 
 cli.add_command(backups_cli)
 cli.add_command(diagnose)
+cli.add_command(schema)
 
 
 @cli.command()

plain_postgres-0.89.1/plain/postgres/cli/schema.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import re
+import sys
+from typing import Any
+
+import click
+
+from ..db import get_connection
+from ..registry import models_registry
+
+# Map from db_type() short names to format_type() canonical names.
+# Postgres stores these as aliases; format_type() returns the long form.
+_TYPE_ALIASES: dict[str, str] = {
+    "bool": "boolean",
+    "varchar": "character varying",
+    "int2": "smallint",
+    "int4": "integer",
+    "int8": "bigint",
+    "float4": "real",
+    "float8": "double precision",
+    "time": "time without time zone",
+    "timestamp": "timestamp without time zone",
+    "timestamptz": "timestamp with time zone",
+    "timetz": "time with time zone",
+    "serial": "integer",
+    "bigserial": "bigint",
+    "smallserial": "smallint",
+}
+
+_TYPE_PARTS = re.compile(r"^(\w+)(.*)")
+
+
+def _normalize_type(db_type: str) -> str:
+    """Normalize a db_type() string to match Postgres format_type() output."""
+    m = _TYPE_PARTS.match(db_type)
+    if not m:
+        return db_type
+    base, suffix = m.group(1), m.group(2)
+    canonical = _TYPE_ALIASES.get(base, base)
+    return canonical + suffix
+
+
+def _ok() -> None:
+    click.secho("  ✓", fg="green", dim=True)
+
+
+def _err(msg: str) -> None:
+    click.secho(f"  ✗ {msg}", fg="red")
+
+
+def _get_actual_columns(cursor: Any, table_name: str) -> dict[str, tuple[str, bool]]:
+    """Return {column_name: (type_string, is_not_null)} from the actual DB."""
+    cursor.execute(
+        """
+        SELECT a.attname, format_type(a.atttypid, a.atttypmod), a.attnotnull
+        FROM pg_attribute a
+        JOIN pg_class c ON a.attrelid = c.oid
+        WHERE c.relname = %s AND pg_catalog.pg_table_is_visible(c.oid)
+          AND a.attnum > 0 AND NOT a.attisdropped
+        ORDER BY a.attnum
+        """,
+        [table_name],
+    )
+    return {
+        name: (type_str, is_not_null)
+        for name, type_str, is_not_null in cursor.fetchall()
+    }
+
+
+def _show_model(conn: Any, cursor: Any, model: Any) -> int:
+    """Print schema for a model, annotating any drift. Returns issue count."""
+    from ..constraints import UniqueConstraint
+
+    table_name = model.model_options.db_table
+    issues = 0
+
+    actual_columns = _get_actual_columns(cursor, table_name)
+    actual_constraints = conn.get_constraints(cursor, table_name)
+
+    actual_indexes: dict[str, dict[str, Any]] = {}
+    actual_unique: dict[str, dict[str, Any]] = {}
+    for name, info in actual_constraints.items():
+        if info.get("primary_key"):
+            continue
+        if info.get("index"):
+            actual_indexes[name] = info
+        elif info.get("unique"):
+            actual_unique[name] = info
+
+    click.secho(model.model_options.label, bold=True, nl=False)
+    click.secho(f"  →  {table_name}", dim=True)
+
+    if not actual_columns:
+        click.echo("  ", nl=False)
+        _err("table missing from database")
+        return 1
+
+    # Columns
+    expected_col_names: set[str] = set()
+
+    for field in model._model_meta.local_fields:
+        db_type = field.db_type()
+        if db_type is None:
+            continue
+
+        expected_col_names.add(field.column)
+        expected_type = _normalize_type(db_type)
+
+        col_display = field.column
+        if field.column != field.name:
+            col_display = f"{field.name} → {field.column}"
+
+        type_parts = [click.style(db_type, fg="cyan")]
+        if field.allow_null:
+            type_parts.append(click.style("NULL", dim=True))
+        if field.primary_key:
+            type_parts.append(click.style("PK", fg="yellow"))
+            suffix = field.db_type_suffix()
+            if suffix:
+                type_parts.append(click.style(suffix, dim=True))
+
+        click.echo(f"  {col_display:30s}  {' '.join(type_parts)}", nl=False)
+
+        if field.column not in actual_columns:
+            _err("missing from database")
+            issues += 1
+        else:
+            actual_type, actual_not_null = actual_columns[field.column]
+            col_issues = []
+            if expected_type != actual_type:
+                col_issues.append(
+                    f"type: expected {expected_type}, actual {actual_type}"
+                )
+            if (not field.allow_null) != actual_not_null:
+                exp = "NOT NULL" if not field.allow_null else "NULL"
+                act = "NOT NULL" if actual_not_null else "NULL"
+                col_issues.append(f"expected {exp}, actual {act}")
+            if col_issues:
+                _err("; ".join(col_issues))
+                issues += len(col_issues)
+            else:
+                _ok()
+
+    for col_name in sorted(actual_columns.keys() - expected_col_names):
+        click.echo(f"  {col_name:30s}  ", nl=False)
+        _err("extra column, not in model")
+        issues += 1
+
+    # Indexes
+    model_indexes = model.model_options.indexes
+    extra_indexes = actual_indexes.keys() - {idx.name for idx in model_indexes}
+
+    if model_indexes or extra_indexes:
+        click.echo()
+        click.secho("  Indexes:", dim=True)
+
+    for index in model_indexes:
+        fields_str = ", ".join(index.fields) if index.fields else "expressions"
+        click.echo(f"    {index.name}  ({fields_str})", nl=False)
+
+        if index.name not in actual_indexes:
+            _err("missing from database")
+            issues += 1
+        else:
+            _ok()
+
+    for name in sorted(extra_indexes):
+        cols = actual_indexes[name].get("columns", [])
+        cols_str = ", ".join(cols) if cols else "expression"
+        click.echo(f"    {name}  ({cols_str})", nl=False)
+        _err("not in model")
+        issues += 1
+
+    # Unique constraints
+    model_constraints = [
+        c for c in model.model_options.constraints if isinstance(c, UniqueConstraint)
+    ]
+    extra_constraints = actual_unique.keys() - {c.name for c in model_constraints}
+
+    if model_constraints or extra_constraints:
+        click.echo()
+        click.secho("  Constraints:", dim=True)
+
+    for constraint in model_constraints:
+        if constraint.fields:
+            fields_str = ", ".join(constraint.fields)
+        else:
+            fields_str = "expressions"
+        click.echo(f"    {constraint.name}  UNIQUE ({fields_str})", nl=False)
+
+        if constraint.name not in actual_unique:
+            _err("missing from database")
+            issues += 1
+        else:
+            _ok()
+
+    for name in sorted(extra_constraints):
+        cols = actual_unique[name].get("columns", [])
+        cols_str = ", ".join(cols) if cols else "?"
+        click.echo(f"    {name}  UNIQUE ({cols_str})", nl=False)
+        _err("not in model")
+        issues += 1
+
+    return issues
+
+
+@click.command()
+@click.argument("model_label", required=False)
+def schema(model_label: str | None) -> None:
+    """Show database schema from models, compared against the actual database"""
+    models = models_registry.get_models()
+
+    if model_label:
+        model_label_lower = model_label.lower()
+        models = [
+            m
+            for m in models
+            if m.model_options.label_lower == model_label_lower
+            or m.model_options.db_table == model_label
+            or m.__name__.lower() == model_label_lower
+        ]
+        if not models:
+            raise click.ClickException(f"No model found matching '{model_label}'")
+
+    conn = get_connection()
+    total_issues = 0
+    models_checked = 0
+
+    with conn.cursor() as cursor:
+        for i, model in enumerate(models):
+            if i > 0:
+                click.echo()
+            models_checked += 1
+            total_issues += _show_model(conn, cursor, model)
+
+    click.echo()
+    if total_issues == 0:
+        click.secho(
+            f"{models_checked} models, all match the database.",
+            fg="green",
+        )
+    else:
+        click.secho(
+            f"{models_checked} models, {total_issues} issue{'s' if total_issues != 1 else ''}.",
+            fg="red",
+        )
+        sys.exit(1)

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/diagnose/checks.py

@@ -101,24 +101,6 @@ def check_duplicate_indexes(
     """)
     rows = cursor.fetchall()
 
-    # Identify FK columns: (table_name, column_number) -> column_name
-    cursor.execute("""
-        SELECT
-            ct.relname AS table_name,
-            c.conkey[1] AS col_number,
-            a.attname AS column_name
-        FROM pg_catalog.pg_constraint c
-        JOIN pg_catalog.pg_class ct ON ct.oid = c.conrelid
-        JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
-        JOIN pg_catalog.pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = c.conkey[1]
-        WHERE c.contype = 'f'
-          AND array_length(c.conkey, 1) = 1
-          AND n.nspname = 'public'
-    """)
-    fk_columns: dict[tuple[str, int], str] = {
-        (row[0], row[1]): row[2] for row in 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:
@@ -142,18 +124,8 @@ def check_duplicate_indexes(
                         and ops_l[: len(cols_s)] == ops_s
                         and not unique_s  # unique indexes serve a constraint purpose
                     ):
-                        # Single-column index on a FK column = auto-generated FK index
-                        fk_field = (
-                            fk_columns.get((table_name, cols_s[0]))
-                            if len(cols_s) == 1
-                            else None
-                        )
-
                         source, package = _table_source(table_name, table_owners)
-                        if fk_field:
-                            app_suggestion = f'Set db_index=False on the "{fk_field}" FK field, then run makemigrations'
-                        else:
-                            app_suggestion = f'Remove "{name_s}" from model constraints, then run makemigrations'
+                        app_suggestion = f'Remove "{name_s}" from model indexes/constraints, then run makemigrations'
 
                         items.append(
                             CheckItem(
@@ -245,7 +217,7 @@ def check_unused_indexes(
                 suggestion=_index_suggestion(
                     source=source,
                     package=package,
-                    app_suggestion=f'Remove "{index_name}" from model constraints, then run makemigrations',
+                    app_suggestion=f'Remove "{index_name}" from model indexes/constraints, then run makemigrations',
                     unmanaged_suggestion=f'DROP INDEX CONCURRENTLY "{index_name}";',
                 ),
             )

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/dialect.py

@@ -109,7 +109,7 @@ DATA_TYPES: dict[str, Any] = {
     "CharField": _get_varchar_column,
     "DateField": "date",
     "DateTimeField": "timestamp with time zone",
-    "DecimalField": "numeric(%(max_digits)s, %(decimal_places)s)",
+    "DecimalField": "numeric(%(max_digits)s,%(decimal_places)s)",
     "DurationField": "interval",
     "FloatField": "double precision",
     "IntegerField": "integer",

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/fields/related.py

@@ -339,7 +339,6 @@ class ForeignKeyField(RelatedField):
         on_delete: Any,
         related_query_name: str | None = None,
         limit_choices_to: Any = None,
-        db_index: bool = True,
         db_constraint: bool = True,
         **kwargs: Any,
     ):
@@ -367,7 +366,6 @@ class ForeignKeyField(RelatedField):
             limit_choices_to=limit_choices_to,
             **kwargs,
         )
-        self.db_index = db_index
         self.db_constraint = db_constraint
 
     def __copy__(self) -> ForeignKeyField:
@@ -556,9 +554,6 @@ class ForeignKeyField(RelatedField):
         else:
             kwargs["to"] = self.remote_field.model.model_options.label_lower
 
-        if self.db_index is not True:
-            kwargs["db_index"] = self.db_index
-
         if self.db_constraint is not True:
             kwargs["db_constraint"] = self.db_constraint
 

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/indexes.py

@@ -6,7 +6,6 @@ from typing import TYPE_CHECKING, Any, Self
 from plain.postgres.expressions import Col, ExpressionList, F, Func, OrderBy
 from plain.postgres.query_utils import Q
 from plain.postgres.sql.query import Query
-from plain.postgres.utils import names_digest, split_identifier
 from plain.utils.functional import partition
 
 if TYPE_CHECKING:
@@ -65,7 +64,9 @@ class Index:
             (field_name.removeprefix("-"), "DESC" if field_name.startswith("-") else "")
             for field_name in self.fields
         ]
-        self.name = name or ""
+        if not name:
+            raise ValueError("Index.name is required.")
+        self.name = name
         self.opclasses: tuple[str, ...] = tuple(opclasses)
         self.condition = condition
         self.include = tuple(include) if include else ()
@@ -151,40 +152,6 @@ class Index:
         _, args, kwargs = self.deconstruct()
         return self.__class__(*args, **kwargs)
 
-    def set_name_with_model(self, model: type[Model]) -> None:
-        """
-        Generate a unique name for the index.
-
-        The name is divided into 3 parts - table name (12 chars), field name
-        (8 chars) and unique hash + suffix (10 chars). Each part is made to
-        fit its size by truncating the excess length.
-        """
-        _, table_name = split_identifier(model.model_options.db_table)
-        column_names = [
-            model._model_meta.get_forward_field(field_name).column
-            for field_name, order in self.fields_orders
-        ]
-        column_names_with_order = [
-            (("-%s" if order else "%s") % column_name)
-            for column_name, (field_name, order) in zip(
-                column_names, self.fields_orders
-            )
-        ]
-        # The length of the parts of the name is based on the default max
-        # length of 30 characters.
-        hash_data = [table_name] + column_names_with_order + [self.suffix]
-        self.name = "{}_{}_{}".format(
-            table_name[:11],
-            column_names[0][:7],
-            f"{names_digest(*hash_data, length=6)}_{self.suffix}",
-        )
-        if len(self.name) > self.max_name_length:
-            raise ValueError(
-                "Index name too long. Is self.suffix longer than 3 characters?"
-            )
-        if self.name[0] == "_" or self.name[0].isdigit():
-            self.name = f"D{self.name[1:]}"
-
     def __repr__(self) -> str:
         return "<{}:{}{}{}{}{}{}>".format(
             self.__class__.__qualname__,

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/meta.py

@@ -132,13 +132,6 @@ class Meta:
         instance.local_fields.sort(key=lambda f: (not f.primary_key, f.name))
         instance.local_many_to_many.sort(key=lambda f: f.name)
 
-        # Set index names now that fields are contributed
-        # Trigger model_options descriptor to ensure it's initialized
-        # (accessing it will cache the instance)
-        for index in model.model_options.indexes:
-            if not index.name:
-                index.set_name_with_model(model)
-
         return instance
 
     @property

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/options.py

@@ -168,12 +168,7 @@ class Options:
         options = {}
         for name in self._provided_options:
             if name == "indexes":
-                # Clone indexes and ensure names are set
-                indexes = [idx.clone() for idx in self.indexes]
-                for index in indexes:
-                    if not index.name:
-                        index.set_name_with_model(self.model)
-                options["indexes"] = indexes
+                options["indexes"] = [idx.clone() for idx in self.indexes]
             elif name == "constraints":
                 # Clone constraints
                 options["constraints"] = [con.clone() for con in self.constraints]

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/preflight.py

@@ -38,14 +38,6 @@ def _collect_model_indexes(model: Any) -> list[tuple[str, list[str], bool]]:
         if isinstance(constraint, UniqueConstraint) and constraint.fields:
             all_indexes.append((constraint.name, list(constraint.fields), True))
 
-    for field in model._model_meta.local_fields:
-        if (
-            isinstance(field, ForeignKeyField)
-            and field.db_index
-            and not field.primary_key
-        ):
-            all_indexes.append((f"{field.name} (auto)", [field.name], False))
-
     return all_indexes
 
 
@@ -55,8 +47,9 @@ class CheckAllModels(PreflightCheck):
 
     def run(self) -> list[PreflightResult]:
         db_table_models = defaultdict(list)
-        indexes = defaultdict(list)
-        constraints = defaultdict(list)
+        # Indexes and constraints share the same Postgres namespace,
+        # so track them together to catch cross-type collisions.
+        relation_names = defaultdict(list)
         errors = []
         models = models_registry.get_models()
         for model in models:
@@ -74,9 +67,9 @@ class CheckAllModels(PreflightCheck):
             else:
                 errors.extend(model.preflight())
             for model_index in model.model_options.indexes:
-                indexes[model_index.name].append(model.model_options.label)
+                relation_names[model_index.name].append(model.model_options.label)
             for model_constraint in model.model_options.constraints:
-                constraints[model_constraint.name].append(model.model_options.label)
+                relation_names[model_constraint.name].append(model.model_options.label)
         for db_table, model_labels in db_table_models.items():
             if len(model_labels) != 1:
                 model_labels_str = ", ".join(model_labels)
@@ -87,34 +80,20 @@ class CheckAllModels(PreflightCheck):
                         id="postgres.duplicate_db_table",
                     )
                 )
-        for index_name, model_labels in indexes.items():
-            if len(model_labels) > 1:
-                model_labels = set(model_labels)
-                errors.append(
-                    PreflightResult(
-                        fix="index name '{}' is not unique {} {}.".format(
-                            index_name,
-                            "for model" if len(model_labels) == 1 else "among models:",
-                            ", ".join(sorted(model_labels)),
-                        ),
-                        id="postgres.index_name_not_unique_single"
-                        if len(model_labels) == 1
-                        else "postgres.index_name_not_unique_multiple",
-                    ),
-                )
-        for constraint_name, model_labels in constraints.items():
+        for relation_name, model_labels in relation_names.items():
             if len(model_labels) > 1:
-                model_labels = set(model_labels)
+                unique_models = set(model_labels)
+                single_model = len(unique_models) == 1
                 errors.append(
                     PreflightResult(
-                        fix="constraint name '{}' is not unique {} {}.".format(
-                            constraint_name,
-                            "for model" if len(model_labels) == 1 else "among models:",
-                            ", ".join(sorted(model_labels)),
+                        fix="index/constraint name '{}' is not unique {} {}.".format(
+                            relation_name,
+                            "for model" if single_model else "among models:",
+                            ", ".join(sorted(unique_models)),
                         ),
-                        id="postgres.constraint_name_not_unique_single"
-                        if len(model_labels) == 1
-                        else "postgres.constraint_name_not_unique_multiple",
+                        id="postgres.relation_name_not_unique_single"
+                        if single_model
+                        else "postgres.relation_name_not_unique_multiple",
                     ),
                 )
         return errors
@@ -391,7 +370,6 @@ class CheckMissingFKIndexes(PreflightCheck):
                     isinstance(field, ForeignKeyField)
                     and not field.primary_key
                     and field.name not in covered_fields
-                    and not field.db_index
                 ):
                     results.append(
                         PreflightResult(

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/schema.py

@@ -951,41 +951,6 @@ class DatabaseSchemaEditor:
                             self.sql_delete_fk, new_rel.related_model, fk_name
                         )
                     )
-        # Removed an index? (no strict check, as multiple indexes are possible)
-        # Remove indexes if db_index switched to False or a unique constraint
-        # will now be used in lieu of an index. The following lines from the
-        # truth table show all True cases; the rest are False:
-        #
-        # old_field.db_index | old_field.primary_key | new_field.db_index | new_field.primary_key
-        # ------------------------------------------------------------------------------
-        # True               | False            | False              | False
-        # True               | False            | False              | True
-        # True               | False            | True               | True
-        if (
-            isinstance(old_field, ForeignKeyField)
-            and old_field.db_index
-            and not old_field.primary_key
-            and (
-                not (isinstance(new_field, ForeignKeyField) and new_field.db_index)
-                or new_field.primary_key
-            )
-        ):
-            # Find the index for this field
-            meta_index_names = {index.name for index in model.model_options.indexes}
-            # Retrieve only BTREE indexes since this is what's created with
-            # db_index=True.
-            index_names = self._constraint_names(
-                model,
-                [old_field.column],
-                index=True,
-                type_=Index.suffix,
-                exclude=meta_index_names,
-            )
-            for index_name in index_names:
-                # The only way to check if an index was created with
-                # db_index=True or with Index(['field'], name='foo')
-                # is to look at its name (refs #28053).
-                self.execute(self._delete_index_sql(model, index_name))
         # Change check constraints?
         old_db_check = self._field_db_check(old_field, old_db_params)
         new_db_check = self._field_db_check(new_field, new_db_params)
@@ -1109,25 +1074,6 @@ class DatabaseSchemaEditor:
         if old_field.primary_key and not new_field.primary_key:
             self._delete_primary_key(model, strict)
 
-        # Added an index? Add an index if db_index switched to True or a unique
-        # constraint will no longer be used in lieu of an index. The following
-        # lines from the truth table show all True cases; the rest are False:
-        #
-        # old_field.db_index | old_field.primary_key | new_field.db_index | new_field.primary_key
-        # ------------------------------------------------------------------------------
-        # False              | False            | True               | False
-        # False              | True             | True               | False
-        # True               | True             | True               | False
-        if (
-            (
-                not (isinstance(old_field, ForeignKeyField) and old_field.db_index)
-                or old_field.primary_key
-            )
-            and isinstance(new_field, ForeignKeyField)
-            and new_field.db_index
-            and not new_field.primary_key
-        ):
-            self.execute(self._create_index_sql(model, fields=[new_field]))
         # Type alteration on primary key? Then we need to alter the column
         # referring to us.
         rels_to_update = []
@@ -1201,24 +1147,14 @@ class DatabaseSchemaEditor:
             }
             self.execute(sql, params)
 
-        # Added an index? Create any PostgreSQL-specific indexes.
-        if (
-            not (
-                (isinstance(old_field, ForeignKeyField) and old_field.db_index)
-                or old_field.primary_key
-            )
-            and isinstance(new_field, ForeignKeyField)
-            and new_field.db_index
-        ) or (not old_field.primary_key and new_field.primary_key):
+        # Added a primary key? Create any PostgreSQL-specific indexes.
+        if not old_field.primary_key and new_field.primary_key:
             like_index_statement = self._create_like_index_sql(model, new_field)
             if like_index_statement is not None:
                 self.execute(like_index_statement)
 
-        # Removed an index? Drop any PostgreSQL-specific indexes.
-        if old_field.primary_key and not (
-            (isinstance(new_field, ForeignKeyField) and new_field.db_index)
-            or new_field.primary_key
-        ):
+        # Removed a primary key? Drop any PostgreSQL-specific indexes.
+        if old_field.primary_key and not new_field.primary_key:
             index_to_remove = self._create_index_name(
                 model.model_options.db_table, [old_field.column], suffix="_like"
             )
@@ -1570,8 +1506,6 @@ class DatabaseSchemaEditor:
         Return a list of all index SQL statements for the specified field.
         """
         output: list[Statement] = []
-        if self._field_should_be_indexed(model, field):
-            output.append(self._create_index_sql(model, fields=[field]))
         # Add LIKE index for varchar/text primary keys
         like_index_statement = self._create_like_index_sql(model, field)
         if like_index_statement is not None:
@@ -1632,11 +1566,6 @@ class DatabaseSchemaEditor:
             old_kwargs,
         ) != (new_path, new_args, new_kwargs)
 
-    def _field_should_be_indexed(self, model: type[Model], field: Field) -> bool:
-        if isinstance(field, ForeignKeyField):
-            return bool(field.remote_field) and field.db_index and not field.primary_key
-        return False
-
     def _field_became_primary_key(self, old_field: Field, new_field: Field) -> bool:
         return not old_field.primary_key and new_field.primary_key
 

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/plain/postgres/types.pyi

@@ -628,7 +628,6 @@ def ForeignKeyField[T: Model](
     *,
     related_query_name: str | None = None,
     limit_choices_to: Any = None,
-    db_index: bool = True,
     db_constraint: bool = True,
     max_length: int | None = None,
     required: bool = True,
@@ -645,7 +644,6 @@ def ForeignKeyField[T: Model](
     *,
     related_query_name: str | None = None,
     limit_choices_to: Any = None,
-    db_index: bool = True,
     db_constraint: bool = True,
     max_length: int | None = None,
     required: bool = True,

{plain_postgres-0.88.2 → plain_postgres-0.89.1}/pyproject.toml

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