plain.models 0.49.2__py3-none-any.whl → 0.51.0__py3-none-any.whl

plain/models/backends/base/schema.py

@@ -1,6 +1,10 @@
+from __future__ import annotations
+
 import logging
 import operator
+from collections.abc import Generator
 from datetime import datetime
+from typing import TYPE_CHECKING, Any
 
 from plain.models.backends.ddl_references import (
     Columns,
@@ -17,10 +21,20 @@ from plain.models.sql import Query
 from plain.models.transaction import TransactionManagementError, atomic
 from plain.utils import timezone
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.base import Model
+    from plain.models.constraints import BaseConstraint
+    from plain.models.fields import Field
+    from plain.models.fields.related import ForeignKey, ManyToManyField
+    from plain.models.fields.reverse_related import ManyToManyRel
+
 logger = logging.getLogger("plain.models.backends.schema")
 
 
-def _is_relevant_relation(relation, altered_field):
+def _is_relevant_relation(relation: Any, altered_field: Field) -> bool:
     """
     When altering the given field, must constraints on its model from the given
     relation be temporarily dropped?
@@ -36,10 +50,10 @@ def _is_relevant_relation(relation, altered_field):
     return altered_field.name == "id"
 
 
-def _all_related_fields(model):
+def _all_related_fields(model: type[Model]) -> list[Any]:
     # Related fields must be returned in a deterministic order.
     return sorted(
-        model._meta._get_fields(
+        model._model_meta._get_fields(
             forward=False,
             reverse=True,
             include_hidden=True,
@@ -48,7 +62,9 @@ def _all_related_fields(model):
     )
 
 
-def _related_non_m2m_objects(old_field, new_field):
+def _related_non_m2m_objects(
+    old_field: Field, new_field: Field
+) -> Generator[tuple[Any, Any], None, None]:
     # Filter out m2m objects from reverse relations.
     # Return (old_relation, new_relation) tuples.
     related_fields = zip(
@@ -140,23 +156,28 @@ class BaseDatabaseSchemaEditor:
     sql_alter_table_comment = "COMMENT ON TABLE %(table)s IS %(comment)s"
     sql_alter_column_comment = "COMMENT ON COLUMN %(table)s.%(column)s IS %(comment)s"
 
-    def __init__(self, connection, collect_sql=False, atomic=True):
+    def __init__(
+        self,
+        connection: BaseDatabaseWrapper,
+        collect_sql: bool = False,
+        atomic: bool = True,
+    ):
         self.connection = connection
         self.collect_sql = collect_sql
         if self.collect_sql:
-            self.collected_sql = []
+            self.collected_sql: list[str] = []
         self.atomic_migration = self.connection.features.can_rollback_ddl and atomic
 
     # State-managing methods
 
-    def __enter__(self):
-        self.deferred_sql = []
+    def __enter__(self) -> BaseDatabaseSchemaEditor:
+        self.deferred_sql: list[Any] = []
         if self.atomic_migration:
             self.atomic = atomic()
             self.atomic.__enter__()
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         if exc_type is None:
             for sql in self.deferred_sql:
                 self.execute(sql)
@@ -165,7 +186,9 @@ class BaseDatabaseSchemaEditor:
 
     # Core utility functions
 
-    def execute(self, sql, params=()):
+    def execute(
+        self, sql: str | Statement, params: tuple[Any, ...] | list[Any] | None = ()
+    ) -> None:
         """Execute the given SQL statement, with optional parameters."""
         # Don't perform the transactional DDL check if SQL is being collected
         # as it's not going to be executed anyway.
@@ -196,15 +219,15 @@ class BaseDatabaseSchemaEditor:
             with self.connection.cursor() as cursor:
                 cursor.execute(sql, params)
 
-    def quote_name(self, name):
+    def quote_name(self, name: str) -> str:
         return self.connection.ops.quote_name(name)
 
-    def table_sql(self, model):
+    def table_sql(self, model: type[Model]) -> tuple[str, list[Any]]:
         """Take a model and return its table definition."""
         # Create column SQL, add FK deferreds if needed.
         column_sqls = []
         params = []
-        for field in model._meta.local_fields:
+        for field in model._model_meta.local_fields:
             # SQL.
             definition, extra_params = self.column_sql(model, field)
             if definition is None:
@@ -219,9 +242,9 @@ class BaseDatabaseSchemaEditor:
                 definition += f" {col_type_suffix}"
             params.extend(extra_params)
             # FK.
-            if field.remote_field and field.db_constraint:
-                to_table = field.remote_field.model._meta.db_table
-                to_column = field.remote_field.model._meta.get_field(
+            if field.remote_field and field.db_constraint:  # type: ignore[attr-defined]
+                to_table = field.remote_field.model.model_options.db_table
+                to_column = field.remote_field.model._model_meta.get_field(
                     field.remote_field.field_name
                 ).column
                 if self.sql_create_inline_fk:
@@ -241,16 +264,16 @@ class BaseDatabaseSchemaEditor:
             # variant).
             if field.get_internal_type() in ("PrimaryKeyField",):
                 autoinc_sql = self.connection.ops.autoinc_sql(
-                    model._meta.db_table, field.column
+                    model.model_options.db_table, field.column
                 )
                 if autoinc_sql:
                     self.deferred_sql.extend(autoinc_sql)
         constraints = [
             constraint.constraint_sql(model, self)
-            for constraint in model._meta.constraints
+            for constraint in model.model_options.constraints
         ]
         sql = self.sql_create_table % {
-            "table": self.quote_name(model._meta.db_table),
+            "table": self.quote_name(model.model_options.db_table),
             "definition": ", ".join(
                 str(constraint)
                 for constraint in (*column_sqls, *constraints)
@@ -262,8 +285,14 @@ class BaseDatabaseSchemaEditor:
     # Field <-> database mapping functions
 
     def _iter_column_sql(
-        self, column_db_type, params, model, field, field_db_params, include_default
-    ):
+        self,
+        column_db_type: str,
+        params: list[Any],
+        model: type[Model],
+        field: Field,
+        field_db_params: dict[str, Any],
+        include_default: bool,
+    ) -> Generator[str, None, None]:
         yield column_db_type
         if collation := field_db_params.get("collation"):
             yield self._collate_sql(collation)
@@ -302,7 +331,9 @@ class BaseDatabaseSchemaEditor:
         if field.primary_key:
             yield "PRIMARY KEY"
 
-    def column_sql(self, model, field, include_default=False):
+    def column_sql(
+        self, model: type[Model], field: Field, include_default: bool = False
+    ) -> tuple[str | None, list[Any] | None]:
         """
         Return the column definition for a field. The field must already have
         had set_attributes_from_name() called.
@@ -313,7 +344,7 @@ class BaseDatabaseSchemaEditor:
         # Check for fields that aren't actually columns (e.g. M2M).
         if column_db_type is None:
             return None, None
-        params = []
+        params: list[Any] = []
         return (
             " ".join(
                 # This appends to the params being returned.
@@ -329,21 +360,21 @@ class BaseDatabaseSchemaEditor:
             params,
         )
 
-    def skip_default(self, field):
+    def skip_default(self, field: Field) -> bool:
         """
         Some backends don't accept default values for certain columns types
         (i.e. MySQL longtext and longblob).
         """
         return False
 
-    def skip_default_on_alter(self, field):
+    def skip_default_on_alter(self, field: Field) -> bool:
         """
         Some backends don't accept default values for certain columns types
         (i.e. MySQL longtext and longblob) in the ALTER COLUMN statement.
         """
         return False
 
-    def prepare_default(self, value):
+    def prepare_default(self, value: Any) -> str:
         """
         Only used for backends which have requires_literal_defaults feature
         """
@@ -352,7 +383,7 @@ class BaseDatabaseSchemaEditor:
             "requires_literal_defaults must provide a prepare_default() method"
         )
 
-    def _column_default_sql(self, field):
+    def _column_default_sql(self, field: Field) -> str:
         """
         Return the SQL to use in a DEFAULT clause. The resulting string should
         contain a '%s' placeholder for a default value.
@@ -360,7 +391,7 @@ class BaseDatabaseSchemaEditor:
         return "%s"
 
     @staticmethod
-    def _effective_default(field):
+    def _effective_default(field: Field) -> Any:
         # This method allows testing its logic without a connection.
         if field.has_default():
             default = field.get_default()
@@ -385,11 +416,11 @@ class BaseDatabaseSchemaEditor:
             default = None
         return default
 
-    def effective_default(self, field):
+    def effective_default(self, field: Field) -> Any:
         """Return a field's effective database default value."""
         return field.get_db_prep_save(self._effective_default(field), self.connection)
 
-    def quote_value(self, value):
+    def quote_value(self, value: Any) -> str:
         """
         Return a quoted version of the value so it's safe to use in an SQL
         string. This is not safe against injection from user code; it is
@@ -401,7 +432,7 @@ class BaseDatabaseSchemaEditor:
 
     # Actions
 
-    def create_model(self, model):
+    def create_model(self, model: type[Model]) -> None:
         """
         Create a table and any accompanying indexes or unique constraints for
         the given `model`.
@@ -413,11 +444,13 @@ class BaseDatabaseSchemaEditor:
 
         if self.connection.features.supports_comments:
             # Add table comment.
-            if model._meta.db_table_comment:
-                self.alter_db_table_comment(model, None, model._meta.db_table_comment)
+            if model.model_options.db_table_comment:
+                self.alter_db_table_comment(
+                    model, None, model.model_options.db_table_comment
+                )
             # Add column comments.
             if not self.connection.features.supports_comments_inline:
-                for field in model._meta.local_fields:
+                for field in model._model_meta.local_fields:
                     if field.db_comment:
                         field_db_params = field.db_parameters(
                             connection=self.connection
@@ -431,24 +464,24 @@ class BaseDatabaseSchemaEditor:
         # Add any field index (deferred as SQLite _remake_table needs it).
         self.deferred_sql.extend(self._model_indexes_sql(model))
 
-    def delete_model(self, model):
+    def delete_model(self, model: type[Model]) -> None:
         """Delete a model from the database."""
 
         # Delete the table
         self.execute(
             self.sql_delete_table
             % {
-                "table": self.quote_name(model._meta.db_table),
+                "table": self.quote_name(model.model_options.db_table),
             }
         )
         # Remove all deferred statements referencing the deleted table.
         for sql in list(self.deferred_sql):
             if isinstance(sql, Statement) and sql.references_table(
-                model._meta.db_table
+                model.model_options.db_table
             ):
                 self.deferred_sql.remove(sql)
 
-    def add_index(self, model, index):
+    def add_index(self, model: type[Model], index: Index) -> None:
         """Add an index on a model."""
         if (
             index.contains_expressions
@@ -459,7 +492,7 @@ class BaseDatabaseSchemaEditor:
         # necessity to avoid escaping attempts on execution.
         self.execute(index.create_sql(model, self), params=None)
 
-    def remove_index(self, model, index):
+    def remove_index(self, model: type[Model], index: Index) -> None:
         """Remove an index from a model."""
         if (
             index.contains_expressions
@@ -468,7 +501,9 @@ class BaseDatabaseSchemaEditor:
             return None
         self.execute(index.remove_sql(model, self))
 
-    def rename_index(self, model, old_index, new_index):
+    def rename_index(
+        self, model: type[Model], old_index: Index, new_index: Index
+    ) -> None:
         if self.connection.features.can_rename_index:
             self.execute(
                 self._rename_index_sql(model, old_index.name, new_index.name),
@@ -478,7 +513,7 @@ class BaseDatabaseSchemaEditor:
             self.remove_index(model, old_index)
             self.add_index(model, new_index)
 
-    def add_constraint(self, model, constraint):
+    def add_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         """Add a constraint to a model."""
         sql = constraint.create_sql(model, self)
         if sql:
@@ -486,13 +521,15 @@ class BaseDatabaseSchemaEditor:
             # params=None a necessity to avoid escaping attempts on execution.
             self.execute(sql, params=None)
 
-    def remove_constraint(self, model, constraint):
+    def remove_constraint(self, model: type[Model], constraint: BaseConstraint) -> None:
         """Remove a constraint from a model."""
         sql = constraint.remove_sql(model, self)
         if sql:
             self.execute(sql)
 
-    def alter_db_table(self, model, old_db_table, new_db_table):
+    def alter_db_table(
+        self, model: type[Model], old_db_table: str, new_db_table: str
+    ) -> None:
         """Rename the table a model points to."""
         if old_db_table == new_db_table or (
             self.connection.features.ignores_table_name_case
@@ -511,16 +548,21 @@ class BaseDatabaseSchemaEditor:
             if isinstance(sql, Statement):
                 sql.rename_table_references(old_db_table, new_db_table)
 
-    def alter_db_table_comment(self, model, old_db_table_comment, new_db_table_comment):
+    def alter_db_table_comment(
+        self,
+        model: type[Model],
+        old_db_table_comment: str | None,
+        new_db_table_comment: str | None,
+    ) -> None:
         self.execute(
             self.sql_alter_table_comment
             % {
-                "table": self.quote_name(model._meta.db_table),
+                "table": self.quote_name(model.model_options.db_table),
                 "comment": self.quote_value(new_db_table_comment or ""),
             }
         )
 
-    def add_field(self, model, field):
+    def add_field(self, model: type[Model], field: Field) -> None:
         """
         Create a field on a model. Usually involves adding a column, but may
         involve adding a table instead (for M2M fields).
@@ -539,16 +581,16 @@ class BaseDatabaseSchemaEditor:
         if (
             field.remote_field
             and self.connection.features.supports_foreign_keys
-            and field.db_constraint
+            and field.db_constraint  # type: ignore[attr-defined]
         ):
             constraint_suffix = "_fk_%(to_table)s_%(to_column)s"
             # Add FK constraint inline, if supported.
             if self.sql_create_column_inline_fk:
-                to_table = field.remote_field.model._meta.db_table
-                to_column = field.remote_field.model._meta.get_field(
+                to_table = field.remote_field.model.model_options.db_table
+                to_column = field.remote_field.model._model_meta.get_field(
                     field.remote_field.field_name
                 ).column
-                namespace, _ = split_identifier(model._meta.db_table)
+                namespace, _ = split_identifier(model.model_options.db_table)
                 definition += " " + self.sql_create_column_inline_fk % {
                     "name": self._fk_constraint_name(model, field, constraint_suffix),
                     "namespace": f"{self.quote_name(namespace)}." if namespace else "",
@@ -564,7 +606,7 @@ class BaseDatabaseSchemaEditor:
                 )
         # Build the SQL and run it
         sql = self.sql_create_column % {
-            "table": self.quote_name(model._meta.db_table),
+            "table": self.quote_name(model.model_options.db_table),
             "column": self.quote_name(field.column),
             "definition": definition,
         }
@@ -579,7 +621,7 @@ class BaseDatabaseSchemaEditor:
                 model, None, field, drop=True
             )
             sql = self.sql_alter_column % {
-                "table": self.quote_name(model._meta.db_table),
+                "table": self.quote_name(model.model_options.db_table),
                 "changes": changes_sql,
             }
             self.execute(sql, params)
@@ -601,7 +643,7 @@ class BaseDatabaseSchemaEditor:
         if self.connection.features.connection_persists_old_columns:
             self.connection.close()
 
-    def remove_field(self, model, field):
+    def remove_field(self, model: type[Model], field: Field) -> None:
         """
         Remove a field from a model. Usually involves deleting a column,
         but for M2Ms may involve deleting a table.
@@ -616,7 +658,7 @@ class BaseDatabaseSchemaEditor:
                 self.execute(self._delete_fk_sql(model, fk_name))
         # Delete the column
         sql = self.sql_delete_column % {
-            "table": self.quote_name(model._meta.db_table),
+            "table": self.quote_name(model.model_options.db_table),
             "column": self.quote_name(field.column),
         }
         self.execute(sql)
@@ -626,11 +668,17 @@ class BaseDatabaseSchemaEditor:
         # Remove all deferred statements referencing the deleted column.
         for sql in list(self.deferred_sql):
             if isinstance(sql, Statement) and sql.references_column(
-                model._meta.db_table, field.column
+                model.model_options.db_table, field.column
             ):
                 self.deferred_sql.remove(sql)
 
-    def alter_field(self, model, old_field, new_field, strict=False):
+    def alter_field(
+        self,
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        strict: bool = False,
+    ) -> None:
         """
         Allow a field's type, uniqueness, nullability, default, column,
         constraints, etc. to be modified.
@@ -655,7 +703,7 @@ class BaseDatabaseSchemaEditor:
         elif (
             old_type is None
             and new_type is None
-            and (old_field.remote_field.through and new_field.remote_field.through)
+            and (old_field.remote_field.through and new_field.remote_field.through)  # type: ignore[attr-defined]
         ):
             # Both sides have through models; this is a no-op.
             return
@@ -677,7 +725,9 @@ class BaseDatabaseSchemaEditor:
             strict,
         )
 
-    def _field_db_check(self, field, field_db_params):
+    def _field_db_check(
+        self, field: Field, field_db_params: dict[str, Any]
+    ) -> str | None:
         # Always check constraints with the same mocked column name to avoid
         # recreating constrains when the column is renamed.
         check_constraints = self.connection.data_type_check_constraints
@@ -690,22 +740,22 @@ class BaseDatabaseSchemaEditor:
 
     def _alter_field(
         self,
-        model,
-        old_field,
-        new_field,
-        old_type,
-        new_type,
-        old_db_params,
-        new_db_params,
-        strict=False,
-    ):
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        old_type: str,
+        new_type: str,
+        old_db_params: dict[str, Any],
+        new_db_params: dict[str, Any],
+        strict: bool = False,
+    ) -> None:
         """Perform a "physical" (non-ManyToMany) field update."""
         # Drop any FK constraints, we'll remake them later
         fks_dropped = set()
         if (
             self.connection.features.supports_foreign_keys
             and old_field.remote_field
-            and old_field.db_constraint
+            and old_field.db_constraint  # type: ignore[attr-defined]
             and self._field_should_be_altered(
                 old_field,
                 new_field,
@@ -717,7 +767,7 @@ class BaseDatabaseSchemaEditor:
             )
             if strict and len(fk_names) != 1:
                 raise ValueError(
-                    f"Found wrong number ({len(fk_names)}) of foreign key constraints for {model._meta.db_table}.{old_field.column}"
+                    f"Found wrong number ({len(fk_names)}) of foreign key constraints for {model.model_options.db_table}.{old_field.column}"
                 )
             for fk_name in fk_names:
                 fks_dropped.add((old_field.column,))
@@ -729,7 +779,7 @@ class BaseDatabaseSchemaEditor:
         ):
             # Find the unique constraint for this field
             meta_constraint_names = {
-                constraint.name for constraint in model._meta.constraints
+                constraint.name for constraint in model.model_options.constraints
             }
             constraint_names = self._constraint_names(
                 model,
@@ -740,7 +790,7 @@ class BaseDatabaseSchemaEditor:
             )
             if strict and len(constraint_names) != 1:
                 raise ValueError(
-                    f"Found wrong number ({len(constraint_names)}) of unique constraints for {model._meta.db_table}.{old_field.column}"
+                    f"Found wrong number ({len(constraint_names)}) of unique constraints for {model.model_options.db_table}.{old_field.column}"
                 )
             for constraint_name in constraint_names:
                 self.execute(self._delete_unique_sql(model, constraint_name))
@@ -754,7 +804,7 @@ class BaseDatabaseSchemaEditor:
             and ((old_type != new_type) or (old_collation != new_collation))
         )
         if drop_foreign_keys:
-            # '_meta.related_field' also contains M2M reverse fields, these
+            # '_model_meta.related_field' also contains M2M reverse fields, these
             # will be filtered out
             for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                 rel_fk_names = self._constraint_names(
@@ -773,15 +823,15 @@ class BaseDatabaseSchemaEditor:
         # True               | False            | False              | True
         # True               | False            | True               | True
         if (
-            (old_field.remote_field and old_field.db_index)
+            (old_field.remote_field and old_field.db_index)  # type: ignore[attr-defined]
             and not old_field.primary_key
             and (
-                not (new_field.remote_field and new_field.db_index)
+                not (new_field.remote_field and new_field.db_index)  # type: ignore[attr-defined]
                 or new_field.primary_key
             )
         ):
             # Find the index for this field
-            meta_index_names = {index.name for index in model._meta.indexes}
+            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(
@@ -801,7 +851,7 @@ class BaseDatabaseSchemaEditor:
         new_db_check = self._field_db_check(new_field, new_db_params)
         if old_db_check != new_db_check and old_db_check:
             meta_constraint_names = {
-                constraint.name for constraint in model._meta.constraints
+                constraint.name for constraint in model.model_options.constraints
             }
             constraint_names = self._constraint_names(
                 model,
@@ -811,7 +861,7 @@ class BaseDatabaseSchemaEditor:
             )
             if strict and len(constraint_names) != 1:
                 raise ValueError(
-                    f"Found wrong number ({len(constraint_names)}) of check constraints for {model._meta.db_table}.{old_field.column}"
+                    f"Found wrong number ({len(constraint_names)}) of check constraints for {model.model_options.db_table}.{old_field.column}"
                 )
             for constraint_name in constraint_names:
                 self.execute(self._delete_check_sql(model, constraint_name))
@@ -819,14 +869,14 @@ class BaseDatabaseSchemaEditor:
         if old_field.column != new_field.column:
             self.execute(
                 self._rename_field_sql(
-                    model._meta.db_table, old_field, new_field, new_type
+                    model.model_options.db_table, old_field, new_field, new_type
                 )
             )
             # Rename all references to the renamed column.
             for sql in self.deferred_sql:
                 if isinstance(sql, Statement):
                     sql.rename_column_references(
-                        model._meta.db_table, old_field.column, new_field.column
+                        model.model_options.db_table, old_field.column, new_field.column
                     )
         # Next, start accumulating actions to do
         actions = []
@@ -893,7 +943,7 @@ class BaseDatabaseSchemaEditor:
                 self.execute(
                     self.sql_alter_column
                     % {
-                        "table": self.quote_name(model._meta.db_table),
+                        "table": self.quote_name(model.model_options.db_table),
                         "changes": sql,
                     },
                     params,
@@ -903,7 +953,7 @@ class BaseDatabaseSchemaEditor:
                 self.execute(
                     self.sql_update_with_default
                     % {
-                        "table": self.quote_name(model._meta.db_table),
+                        "table": self.quote_name(model.model_options.db_table),
                         "column": self.quote_name(new_field.column),
                         "default": "%s",
                     },
@@ -915,7 +965,7 @@ class BaseDatabaseSchemaEditor:
                     self.execute(
                         self.sql_alter_column
                         % {
-                            "table": self.quote_name(model._meta.db_table),
+                            "table": self.quote_name(model.model_options.db_table),
                             "changes": sql,
                         },
                         params,
@@ -938,10 +988,10 @@ class BaseDatabaseSchemaEditor:
         # True               | True             | True               | False
         if (
             (
-                not (old_field.remote_field and old_field.db_index)
+                not (old_field.remote_field and old_field.db_index)  # type: ignore[attr-defined]
                 or old_field.primary_key
             )
-            and (new_field.remote_field and new_field.db_index)
+            and (new_field.remote_field and new_field.db_index)  # type: ignore[attr-defined]
             and not new_field.primary_key
         ):
             self.execute(self._create_index_sql(model, fields=[new_field]))
@@ -974,7 +1024,9 @@ class BaseDatabaseSchemaEditor:
             self.execute(
                 self.sql_alter_column
                 % {
-                    "table": self.quote_name(new_rel.related_model._meta.db_table),
+                    "table": self.quote_name(
+                        new_rel.related_model.model_options.db_table
+                    ),
                     "changes": fragment[0],
                 },
                 fragment[1],
@@ -986,9 +1038,9 @@ class BaseDatabaseSchemaEditor:
             self.connection.features.supports_foreign_keys
             and new_field.remote_field
             and (
-                fks_dropped or not old_field.remote_field or not old_field.db_constraint
+                fks_dropped or not old_field.remote_field or not old_field.db_constraint  # type: ignore[attr-defined]
             )
-            and new_field.db_constraint
+            and new_field.db_constraint  # type: ignore[attr-defined]
         ):
             self.execute(
                 self._create_fk_sql(model, new_field, "_fk_%(to_table)s_%(to_column)s")
@@ -1003,7 +1055,7 @@ class BaseDatabaseSchemaEditor:
         # Does it have check constraints we need to add?
         if old_db_check != new_db_check and new_db_check:
             constraint_name = self._create_index_name(
-                model._meta.db_table, [new_field.column], suffix="_check"
+                model.model_options.db_table, [new_field.column], suffix="_check"
             )
             self.execute(
                 self._create_check_sql(model, constraint_name, new_db_params["check"])
@@ -1015,7 +1067,7 @@ class BaseDatabaseSchemaEditor:
                 model, old_field, new_field, drop=True
             )
             sql = self.sql_alter_column % {
-                "table": self.quote_name(model._meta.db_table),
+                "table": self.quote_name(model.model_options.db_table),
                 "changes": changes_sql,
             }
             self.execute(sql, params)
@@ -1023,7 +1075,9 @@ class BaseDatabaseSchemaEditor:
         if self.connection.features.connection_persists_old_columns:
             self.connection.close()
 
-    def _alter_column_null_sql(self, model, old_field, new_field):
+    def _alter_column_null_sql(
+        self, model: type[Model], old_field: Field, new_field: Field
+    ) -> tuple[str, list[Any]]:
         """
         Hook to specialize column null alteration.
 
@@ -1045,7 +1099,13 @@ class BaseDatabaseSchemaEditor:
             [],
         )
 
-    def _alter_column_default_sql(self, model, old_field, new_field, drop=False):
+    def _alter_column_default_sql(
+        self,
+        model: type[Model],
+        old_field: Field | None,
+        new_field: Field,
+        drop: bool = False,
+    ) -> tuple[str, list[Any]]:
         """
         Hook to specialize column default alteration.
 
@@ -1084,8 +1144,14 @@ class BaseDatabaseSchemaEditor:
         )
 
     def _alter_column_type_sql(
-        self, model, old_field, new_field, new_type, old_collation, new_collation
-    ):
+        self,
+        model: type[Model],
+        old_field: Field,
+        new_field: Field,
+        new_type: str,
+        old_collation: str | None,
+        new_collation: str | None,
+    ) -> tuple[tuple[str, list[Any]], list[tuple[str, list[Any]]]]:
         """
         Hook to specialize column type alteration for different backends,
         for cases when a creation type is different to an alteration type
@@ -1097,7 +1163,7 @@ class BaseDatabaseSchemaEditor:
         """
         other_actions = []
         if collate_sql := self._collate_sql(
-            new_collation, old_collation, model._meta.db_table
+            new_collation, old_collation, model.model_options.db_table
         ):
             collate_sql = f" {collate_sql}"
         else:
@@ -1129,53 +1195,71 @@ class BaseDatabaseSchemaEditor:
             other_actions,
         )
 
-    def _alter_column_comment_sql(self, model, new_field, new_type, new_db_comment):
+    def _alter_column_comment_sql(
+        self,
+        model: type[Model],
+        new_field: Field,
+        new_type: str,
+        new_db_comment: str | None,
+    ) -> tuple[str, list[Any]]:
         return (
             self.sql_alter_column_comment
             % {
-                "table": self.quote_name(model._meta.db_table),
+                "table": self.quote_name(model.model_options.db_table),
                 "column": self.quote_name(new_field.column),
                 "comment": self._comment_sql(new_db_comment),
             },
             [],
         )
 
-    def _comment_sql(self, comment):
+    def _comment_sql(self, comment: str | None) -> str:
         return self.quote_value(comment or "")
 
-    def _alter_many_to_many(self, model, old_field, new_field, strict):
+    def _alter_many_to_many(
+        self,
+        model: type[Model],
+        old_field: ManyToManyField,
+        new_field: ManyToManyField,
+        strict: bool,
+    ) -> None:
         """Alter M2Ms to repoint their to= endpoints."""
+        # Type narrow for ManyToManyField.remote_field
+        old_rel: ManyToManyRel = old_field.remote_field  # type: ignore[assignment]
+        new_rel: ManyToManyRel = new_field.remote_field  # type: ignore[assignment]
+
         # Rename the through table
         if (
-            old_field.remote_field.through._meta.db_table
-            != new_field.remote_field.through._meta.db_table
+            old_rel.through.model_options.db_table
+            != new_rel.through.model_options.db_table
         ):
             self.alter_db_table(
-                old_field.remote_field.through,
-                old_field.remote_field.through._meta.db_table,
-                new_field.remote_field.through._meta.db_table,
+                old_rel.through,
+                old_rel.through.model_options.db_table,
+                new_rel.through.model_options.db_table,
             )
         # Repoint the FK to the other side
         self.alter_field(
-            new_field.remote_field.through,
+            new_rel.through,
             # The field that points to the target model is needed, so we can
             # tell alter_field to change it - this is m2m_reverse_field_name()
             # (as opposed to m2m_field_name(), which points to our model).
-            old_field.remote_field.through._meta.get_field(
-                old_field.m2m_reverse_field_name()
+            old_rel.through._model_meta.get_field(
+                old_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
             ),
-            new_field.remote_field.through._meta.get_field(
-                new_field.m2m_reverse_field_name()
+            new_rel.through._model_meta.get_field(
+                new_field.m2m_reverse_field_name()  # type: ignore[attr-defined]
             ),
         )
         self.alter_field(
-            new_field.remote_field.through,
+            new_rel.through,
             # for self-referential models we need to alter field from the other end too
-            old_field.remote_field.through._meta.get_field(old_field.m2m_field_name()),
-            new_field.remote_field.through._meta.get_field(new_field.m2m_field_name()),
+            old_rel.through._model_meta.get_field(old_field.m2m_field_name()),
+            new_rel.through._model_meta.get_field(new_field.m2m_field_name()),
         )
 
-    def _create_index_name(self, table_name, column_names, suffix=""):
+    def _create_index_name(
+        self, table_name: str, column_names: list[str], suffix: str = ""
+    ) -> str:
         """
         Generate a unique name for an index/unique constraint.
 
@@ -1208,34 +1292,36 @@ class BaseDatabaseSchemaEditor:
             index_name = f"D{index_name[:-1]}"
         return index_name
 
-    def _index_condition_sql(self, condition):
+    def _index_condition_sql(self, condition: str | None) -> str:
         if condition:
             return " WHERE " + condition
         return ""
 
-    def _index_include_sql(self, model, columns):
+    def _index_include_sql(
+        self, model: type[Model], columns: list[str] | None
+    ) -> str | Statement:
         if not columns or not self.connection.features.supports_covering_indexes:
             return ""
         return Statement(
             " INCLUDE (%(columns)s)",
-            columns=Columns(model._meta.db_table, columns, self.quote_name),
+            columns=Columns(model.model_options.db_table, columns, self.quote_name),
         )
 
     def _create_index_sql(
         self,
-        model,
+        model: type[Model],
         *,
-        fields=None,
-        name=None,
-        suffix="",
-        using="",
-        col_suffixes=(),
-        sql=None,
-        opclasses=(),
-        condition=None,
-        include=None,
-        expressions=None,
-    ):
+        fields: list[Field] | None = None,
+        name: str | None = None,
+        suffix: str = "",
+        using: str = "",
+        col_suffixes: tuple[str, ...] = (),
+        sql: str | None = None,
+        opclasses: tuple[str, ...] = (),
+        condition: str | None = None,
+        include: list[str] | None = None,
+        expressions: Any = None,
+    ) -> Statement:
         """
         Return the SQL statement to create the index for one or several fields
         or expressions. `sql` can be specified if the syntax differs from the
@@ -1246,9 +1332,9 @@ class BaseDatabaseSchemaEditor:
         compiler = Query(model, alias_cols=False).get_compiler()
         columns = [field.column for field in fields]
         sql_create_index = sql or self.sql_create_index
-        table = model._meta.db_table
+        table = model.model_options.db_table
 
-        def create_index_name(*args, **kwargs):
+        def create_index_name(*args: Any, **kwargs: Any) -> str:
             nonlocal name
             if name is None:
                 name = self._create_index_name(*args, **kwargs)
@@ -1269,33 +1355,43 @@ class BaseDatabaseSchemaEditor:
             include=self._index_include_sql(model, include),
         )
 
-    def _delete_index_sql(self, model, name, sql=None):
+    def _delete_index_sql(
+        self, model: type[Model], name: str, sql: str | None = None
+    ) -> Statement:
         return Statement(
             sql or self.sql_delete_index,
-            table=Table(model._meta.db_table, self.quote_name),
+            table=Table(model.model_options.db_table, self.quote_name),
             name=self.quote_name(name),
         )
 
-    def _rename_index_sql(self, model, old_name, new_name):
+    def _rename_index_sql(
+        self, model: type[Model], old_name: str, new_name: str
+    ) -> Statement:
         return Statement(
             self.sql_rename_index,
-            table=Table(model._meta.db_table, self.quote_name),
+            table=Table(model.model_options.db_table, self.quote_name),
             old_name=self.quote_name(old_name),
             new_name=self.quote_name(new_name),
         )
 
-    def _index_columns(self, table, columns, col_suffixes, opclasses):
+    def _index_columns(
+        self,
+        table: str,
+        columns: list[str],
+        col_suffixes: tuple[str, ...],
+        opclasses: tuple[str, ...],
+    ) -> Columns:
         return Columns(table, columns, self.quote_name, col_suffixes=col_suffixes)
 
-    def _model_indexes_sql(self, model):
+    def _model_indexes_sql(self, model: type[Model]) -> list[Statement | None]:
         """
         Return a list of all index SQL statements (field indexes, Meta.indexes) for the specified model.
         """
-        output = []
-        for field in model._meta.local_fields:
+        output: list[Statement | None] = []
+        for field in model._model_meta.local_fields:
             output.extend(self._field_indexes_sql(model, field))
 
-        for index in model._meta.indexes:
+        for index in model.model_options.indexes:
             if (
                 not index.contains_expressions
                 or self.connection.features.supports_expression_indexes
@@ -1303,16 +1399,18 @@ class BaseDatabaseSchemaEditor:
                 output.append(index.create_sql(model, self))
         return output
 
-    def _field_indexes_sql(self, model, field):
+    def _field_indexes_sql(self, model: type[Model], field: Field) -> list[Statement]:
         """
         Return a list of all index SQL statements for the specified field.
         """
-        output = []
+        output: list[Statement] = []
         if self._field_should_be_indexed(model, field):
             output.append(self._create_index_sql(model, fields=[field]))
         return output
 
-    def _field_should_be_altered(self, old_field, new_field, ignore=None):
+    def _field_should_be_altered(
+        self, old_field: Field, new_field: Field, ignore: set[str] | None = None
+    ) -> bool:
         ignore = ignore or set()
         _, old_path, old_args, old_kwargs = old_field.deconstruct()
         _, new_path, new_args, new_kwargs = new_field.deconstruct()
@@ -1321,21 +1419,23 @@ class BaseDatabaseSchemaEditor:
         # - changing an attribute that doesn't affect the schema
         # - changing an attribute in the provided set of ignored attributes
         # - adding only a db_column and the column name is not changed
-        for attr in ignore.union(old_field.non_db_attrs):
+        for attr in ignore.union(old_field.non_db_attrs):  # type: ignore[attr-defined]
             old_kwargs.pop(attr, None)
-        for attr in ignore.union(new_field.non_db_attrs):
+        for attr in ignore.union(new_field.non_db_attrs):  # type: ignore[attr-defined]
             new_kwargs.pop(attr, None)
         return self.quote_name(old_field.column) != self.quote_name(
             new_field.column
         ) or (old_path, old_args, old_kwargs) != (new_path, new_args, new_kwargs)
 
-    def _field_should_be_indexed(self, model, field):
-        return (field.remote_field and field.db_index) and not field.primary_key
+    def _field_should_be_indexed(self, model: type[Model], field: Field) -> bool:
+        return (field.remote_field and field.db_index) and not field.primary_key  # type: ignore[attr-defined]
 
-    def _field_became_primary_key(self, old_field, new_field):
+    def _field_became_primary_key(self, old_field: Field, new_field: Field) -> bool:
         return not old_field.primary_key and new_field.primary_key
 
-    def _rename_field_sql(self, table, old_field, new_field, new_type):
+    def _rename_field_sql(
+        self, table: str, old_field: Field, new_field: Field, new_type: str
+    ) -> str:
         return self.sql_rename_column % {
             "table": self.quote_name(table),
             "old_column": self.quote_name(old_field.column),
@@ -1343,14 +1443,18 @@ class BaseDatabaseSchemaEditor:
             "type": new_type,
         }
 
-    def _create_fk_sql(self, model, field, suffix):
-        table = Table(model._meta.db_table, self.quote_name)
+    def _create_fk_sql(
+        self, model: type[Model], field: ForeignKey, suffix: str
+    ) -> Statement:
+        table = Table(model.model_options.db_table, self.quote_name)
         name = self._fk_constraint_name(model, field, suffix)
-        column = Columns(model._meta.db_table, [field.column], self.quote_name)
-        to_table = Table(field.target_field.model._meta.db_table, self.quote_name)
+        column = Columns(model.model_options.db_table, [field.column], self.quote_name)
+        to_table = Table(
+            field.target_field.model.model_options.db_table, self.quote_name
+        )
         to_column = Columns(
-            field.target_field.model._meta.db_table,
-            [field.target_field.column],
+            field.target_field.model.model_options.db_table,
+            [field.target_field.column],  # type: ignore[attr-defined]
             self.quote_name,
         )
         deferrable = self.connection.ops.deferrable_sql()
@@ -1364,41 +1468,44 @@ class BaseDatabaseSchemaEditor:
             deferrable=deferrable,
         )
 
-    def _fk_constraint_name(self, model, field, suffix):
-        def create_fk_name(*args, **kwargs):
+    def _fk_constraint_name(
+        self, model: type[Model], field: ForeignKey, suffix: str
+    ) -> ForeignKeyName:
+        def create_fk_name(*args: Any, **kwargs: Any) -> str:
             return self.quote_name(self._create_index_name(*args, **kwargs))
 
         return ForeignKeyName(
-            model._meta.db_table,
+            model.model_options.db_table,
             [field.column],
-            split_identifier(field.target_field.model._meta.db_table)[1],
-            [field.target_field.column],
+            split_identifier(field.target_field.model.model_options.db_table)[1],
+            [field.target_field.column],  # type: ignore[attr-defined]
             suffix,
             create_fk_name,
         )
 
-    def _delete_fk_sql(self, model, name):
+    def _delete_fk_sql(self, model: type[Model], name: str) -> Statement:
         return self._delete_constraint_sql(self.sql_delete_fk, model, name)
 
-    def _deferrable_constraint_sql(self, deferrable):
+    def _deferrable_constraint_sql(self, deferrable: Deferrable | None) -> str:
         if deferrable is None:
             return ""
         if deferrable == Deferrable.DEFERRED:
             return " DEFERRABLE INITIALLY DEFERRED"
         if deferrable == Deferrable.IMMEDIATE:
             return " DEFERRABLE INITIALLY IMMEDIATE"
+        return ""
 
     def _unique_sql(
         self,
-        model,
-        fields,
-        name,
-        condition=None,
-        deferrable=None,
-        include=None,
-        opclasses=None,
-        expressions=None,
-    ):
+        model: type[Model],
+        fields: Iterable[Field],
+        name: str,
+        condition: str | None = None,
+        deferrable: Deferrable | None = None,
+        include: list[str] | None = None,
+        opclasses: tuple[str, ...] | None = None,
+        expressions: Any = None,
+    ) -> str | None:
         if (
             deferrable
             and not self.connection.features.supports_deferrable_unique_constraints
@@ -1430,15 +1537,15 @@ class BaseDatabaseSchemaEditor:
 
     def _create_unique_sql(
         self,
-        model,
-        fields,
-        name=None,
-        condition=None,
-        deferrable=None,
-        include=None,
-        opclasses=None,
-        expressions=None,
-    ):
+        model: type[Model],
+        fields: Iterable[Field],
+        name: str | None = None,
+        condition: str | None = None,
+        deferrable: Deferrable | None = None,
+        include: list[str] | None = None,
+        opclasses: tuple[str, ...] | None = None,
+        expressions: Any = None,
+    ) -> Statement | None:
         if (
             (
                 deferrable
@@ -1453,7 +1560,7 @@ class BaseDatabaseSchemaEditor:
             return None
 
         compiler = Query(model, alias_cols=False).get_compiler()
-        table = model._meta.db_table
+        table = model.model_options.db_table
         columns = [field.column for field in fields]
         if name is None:
             name = self._unique_constraint_name(table, columns, quote=True)
@@ -1464,25 +1571,27 @@ class BaseDatabaseSchemaEditor:
         else:
             sql = self.sql_create_unique
         if columns:
-            columns = self._index_columns(
+            columns_obj: Columns | Expressions = self._index_columns(
                 table, columns, col_suffixes=(), opclasses=opclasses
             )
         else:
-            columns = Expressions(table, expressions, compiler, self.quote_value)
+            columns_obj = Expressions(table, expressions, compiler, self.quote_value)
         return Statement(
             sql,
             table=Table(table, self.quote_name),
             name=name,
-            columns=columns,
+            columns=columns_obj,
             condition=self._index_condition_sql(condition),
             deferrable=self._deferrable_constraint_sql(deferrable),
             include=self._index_include_sql(model, include),
         )
 
-    def _unique_constraint_name(self, table, columns, quote=True):
+    def _unique_constraint_name(
+        self, table: str, columns: list[str], quote: bool = True
+    ) -> IndexName | str:
         if quote:
 
-            def create_unique_name(*args, **kwargs):
+            def create_unique_name(*args: Any, **kwargs: Any) -> str:
                 return self.quote_name(self._create_index_name(*args, **kwargs))
 
         else:
@@ -1492,14 +1601,14 @@ class BaseDatabaseSchemaEditor:
 
     def _delete_unique_sql(
         self,
-        model,
-        name,
-        condition=None,
-        deferrable=None,
-        include=None,
-        opclasses=None,
-        expressions=None,
-    ):
+        model: type[Model],
+        name: str,
+        condition: str | None = None,
+        deferrable: Deferrable | None = None,
+        include: list[str] | None = None,
+        opclasses: tuple[str, ...] | None = None,
+        expressions: Any = None,
+    ) -> Statement | None:
         if (
             (
                 deferrable
@@ -1518,46 +1627,50 @@ class BaseDatabaseSchemaEditor:
             sql = self.sql_delete_unique
         return self._delete_constraint_sql(sql, model, name)
 
-    def _check_sql(self, name, check):
+    def _check_sql(self, name: str, check: str) -> str:
         return self.sql_constraint % {
             "name": self.quote_name(name),
             "constraint": self.sql_check_constraint % {"check": check},
         }
 
-    def _create_check_sql(self, model, name, check):
+    def _create_check_sql(
+        self, model: type[Model], name: str, check: str
+    ) -> Statement | None:
         if not self.connection.features.supports_table_check_constraints:
             return None
         return Statement(
             self.sql_create_check,
-            table=Table(model._meta.db_table, self.quote_name),
+            table=Table(model.model_options.db_table, self.quote_name),
             name=self.quote_name(name),
             check=check,
         )
 
-    def _delete_check_sql(self, model, name):
+    def _delete_check_sql(self, model: type[Model], name: str) -> Statement | None:
         if not self.connection.features.supports_table_check_constraints:
             return None
         return self._delete_constraint_sql(self.sql_delete_check, model, name)
 
-    def _delete_constraint_sql(self, template, model, name):
+    def _delete_constraint_sql(
+        self, template: str, model: type[Model], name: str
+    ) -> Statement:
         return Statement(
             template,
-            table=Table(model._meta.db_table, self.quote_name),
+            table=Table(model.model_options.db_table, self.quote_name),
             name=self.quote_name(name),
         )
 
     def _constraint_names(
         self,
-        model,
-        column_names=None,
-        unique=None,
-        primary_key=None,
-        index=None,
-        foreign_key=None,
-        check=None,
-        type_=None,
-        exclude=None,
-    ):
+        model: type[Model],
+        column_names: list[str] | None = None,
+        unique: bool | None = None,
+        primary_key: bool | None = None,
+        index: bool | None = None,
+        foreign_key: bool | None = None,
+        check: bool | None = None,
+        type_: str | None = None,
+        exclude: set[str] | None = None,
+    ) -> list[str]:
         """Return all constraint names matching the columns and conditions."""
         if column_names is not None:
             column_names = [
@@ -1570,9 +1683,9 @@ class BaseDatabaseSchemaEditor:
             ]
         with self.connection.cursor() as cursor:
             constraints = self.connection.introspection.get_constraints(
-                cursor, model._meta.db_table
+                cursor, model.model_options.db_table
             )
-        result = []
+        result: list[str] = []
         for name, infodict in constraints.items():
             if column_names is None or column_names == infodict["columns"]:
                 if unique is not None and infodict["unique"] != unique:
@@ -1591,29 +1704,36 @@ class BaseDatabaseSchemaEditor:
                     result.append(name)
         return result
 
-    def _delete_primary_key(self, model, strict=False):
+    def _delete_primary_key(self, model: type[Model], strict: bool = False) -> None:
         constraint_names = self._constraint_names(model, primary_key=True)
         if strict and len(constraint_names) != 1:
             raise ValueError(
-                f"Found wrong number ({len(constraint_names)}) of PK constraints for {model._meta.db_table}"
+                f"Found wrong number ({len(constraint_names)}) of PK constraints for {model.model_options.db_table}"
             )
         for constraint_name in constraint_names:
             self.execute(self._delete_primary_key_sql(model, constraint_name))
 
-    def _create_primary_key_sql(self, model, field):
+    def _create_primary_key_sql(self, model: type[Model], field: Field) -> Statement:
         return Statement(
             self.sql_create_pk,
-            table=Table(model._meta.db_table, self.quote_name),
+            table=Table(model.model_options.db_table, self.quote_name),
             name=self.quote_name(
                 self._create_index_name(
-                    model._meta.db_table, [field.column], suffix="_pk"
+                    model.model_options.db_table, [field.column], suffix="_pk"
                 )
             ),
-            columns=Columns(model._meta.db_table, [field.column], self.quote_name),
+            columns=Columns(
+                model.model_options.db_table, [field.column], self.quote_name
+            ),
         )
 
-    def _delete_primary_key_sql(self, model, name):
+    def _delete_primary_key_sql(self, model: type[Model], name: str) -> Statement:
         return self._delete_constraint_sql(self.sql_delete_pk, model, name)
 
-    def _collate_sql(self, collation, old_collation=None, table_name=None):
+    def _collate_sql(
+        self,
+        collation: str | None,
+        old_collation: str | None = None,
+        table_name: str | None = None,
+    ) -> str:
         return "COLLATE " + self.quote_name(collation) if collation else ""