plain.models 0.50.0__py3-none-any.whl → 0.51.1__py3-none-any.whl

plain/models/backends/base/schema.py

@@ -28,6 +28,8 @@ if TYPE_CHECKING:
     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")
 
@@ -51,7 +53,7 @@ def _is_relevant_relation(relation: Any, altered_field: Field) -> bool:
 def _all_related_fields(model: type[Model]) -> list[Any]:
     # Related fields must be returned in a deterministic order.
     return sorted(
-        model._meta._get_fields(  # type: ignore[attr-defined]
+        model._model_meta._get_fields(
             forward=False,
             reverse=True,
             include_hidden=True,
@@ -225,7 +227,7 @@ class BaseDatabaseSchemaEditor:
         # 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:
@@ -241,8 +243,8 @@ class BaseDatabaseSchemaEditor:
             params.extend(extra_params)
             # FK.
             if field.remote_field and field.db_constraint:  # type: ignore[attr-defined]
-                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
                 if self.sql_create_inline_fk:
@@ -262,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)
@@ -442,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
@@ -467,13 +471,13 @@ class BaseDatabaseSchemaEditor:
         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)
 
@@ -553,7 +557,7 @@ class BaseDatabaseSchemaEditor:
         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 ""),
             }
         )
@@ -582,11 +586,11 @@ class BaseDatabaseSchemaEditor:
             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 "",
@@ -602,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,
         }
@@ -617,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)
@@ -654,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)
@@ -664,7 +668,7 @@ 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)
 
@@ -763,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,))
@@ -775,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,
@@ -786,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))
@@ -800,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(
@@ -827,7 +831,7 @@ class BaseDatabaseSchemaEditor:
             )
         ):
             # 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(
@@ -847,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,
@@ -857,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))
@@ -865,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 = []
@@ -939,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,
@@ -949,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",
                     },
@@ -961,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,
@@ -1020,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],
@@ -1049,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"])
@@ -1061,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)
@@ -1157,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:
@@ -1199,7 +1205,7 @@ class BaseDatabaseSchemaEditor:
         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),
             },
@@ -1210,37 +1216,45 @@ class BaseDatabaseSchemaEditor:
         return self.quote_value(comment or "")
 
     def _alter_many_to_many(
-        self, model: type[Model], old_field: Field, new_field: Field, strict: bool
+        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  # type: ignore[attr-defined]
-            != new_field.remote_field.through._meta.db_table  # type: ignore[attr-defined]
+            old_rel.through.model_options.db_table
+            != new_rel.through.model_options.db_table
         ):
             self.alter_db_table(
-                old_field.remote_field.through,  # type: ignore[attr-defined]
-                old_field.remote_field.through._meta.db_table,  # type: ignore[attr-defined]
-                new_field.remote_field.through._meta.db_table,  # type: ignore[attr-defined]
+                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,  # type: ignore[attr-defined]
+            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(  # type: ignore[attr-defined]
+            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(  # type: ignore[attr-defined]
+            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,  # type: ignore[attr-defined]
+            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()),  # type: ignore[attr-defined]
-            new_field.remote_field.through._meta.get_field(new_field.m2m_field_name()),  # type: ignore[attr-defined]
+            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(
@@ -1290,7 +1304,7 @@ class BaseDatabaseSchemaEditor:
             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(
@@ -1318,7 +1332,7 @@ 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: Any, **kwargs: Any) -> str:
             nonlocal name
@@ -1346,7 +1360,7 @@ class BaseDatabaseSchemaEditor:
     ) -> 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),
         )
 
@@ -1355,7 +1369,7 @@ class BaseDatabaseSchemaEditor:
     ) -> 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),
         )
@@ -1374,10 +1388,10 @@ class BaseDatabaseSchemaEditor:
         Return a list of all index SQL statements (field indexes, Meta.indexes) for the specified model.
         """
         output: list[Statement | None] = []
-        for field in model._meta.local_fields:
+        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
@@ -1430,14 +1444,16 @@ class BaseDatabaseSchemaEditor:
         }
 
     def _create_fk_sql(
-        self, model: type[Model], field: Field, suffix: str
+        self, model: type[Model], field: ForeignKey, suffix: str
     ) -> Statement:
-        table = Table(model._meta.db_table, self.quote_name)
+        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)  # type: ignore[attr-defined]
+        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,  # type: ignore[attr-defined]
+            field.target_field.model.model_options.db_table,
             [field.target_field.column],  # type: ignore[attr-defined]
             self.quote_name,
         )
@@ -1453,15 +1469,15 @@ class BaseDatabaseSchemaEditor:
         )
 
     def _fk_constraint_name(
-        self, model: type[Model], field: Field, suffix: str
+        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],  # type: ignore[attr-defined]
+            split_identifier(field.target_field.model.model_options.db_table)[1],
             [field.target_field.column],  # type: ignore[attr-defined]
             suffix,
             create_fk_name,
@@ -1544,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)
@@ -1624,7 +1640,7 @@ class BaseDatabaseSchemaEditor:
             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,
         )
@@ -1639,7 +1655,7 @@ class BaseDatabaseSchemaEditor:
     ) -> 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),
         )
 
@@ -1667,7 +1683,7 @@ 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: list[str] = []
         for name, infodict in constraints.items():
@@ -1692,7 +1708,7 @@ class BaseDatabaseSchemaEditor:
         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))
@@ -1700,13 +1716,15 @@ class BaseDatabaseSchemaEditor:
     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: type[Model], name: str) -> Statement:

plain/models/backends/base/validation.py

@@ -28,7 +28,7 @@ class BaseDatabaseValidation:
             # Ignore fields with unsupported features.
             db_supports_all_required_features = all(
                 getattr(self.connection.features, feature, False)
-                for feature in field.model._meta.required_db_features
+                for feature in field.model.model_options.required_db_features
             )
             if db_supports_all_required_features:
                 field_type = field.db_type(self.connection)

plain/models/backends/mysql/compiler.py

@@ -66,7 +66,7 @@ class SQLUpdateCompiler(compiler.SQLUpdateCompiler, SQLCompiler):
         if self.query.order_by:
             order_by_sql = []
             order_by_params = []
-            db_table = self.query.get_meta().db_table
+            db_table = self.query.get_model_meta().db_table
             try:
                 for resolved, (sql, params, _) in self.get_order_by():
                     if (

plain/models/backends/mysql/operations.py

@@ -233,7 +233,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         if not fields:
             return "", ()
         columns = [
-            f"{self.quote_name(field.model._meta.db_table)}.{self.quote_name(field.column)}"
+            f"{self.quote_name(field.model.model_options.db_table)}.{self.quote_name(field.column)}"
             for field in fields
         ]
         return "RETURNING {}".format(", ".join(columns)), ()

plain/models/backends/mysql/schema.py

@@ -125,7 +125,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
             effective_default = self.effective_default(field)
             self.execute(
-                f"UPDATE {self.quote_name(model._meta.db_table)} SET {self.quote_name(field.column)} = %s",
+                f"UPDATE {self.quote_name(model.model_options.db_table)} SET {self.quote_name(field.column)} = %s",
                 [effective_default],
             )
 
@@ -154,7 +154,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             return False
 
         storage = self.connection.introspection.get_storage_engine(
-            self.connection.cursor(), model._meta.db_table
+            self.connection.cursor(), model.model_options.db_table
         )
         # No need to create an index for ForeignKey fields except if
         # db_constraint=False because the index from that constraint won't be
@@ -197,7 +197,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         if not first_field_name:
             return
 
-        first_field = model._meta.get_field(first_field_name)
+        first_field = model._model_meta.get_field(first_field_name)
         if first_field.get_internal_type() == "ForeignKey":
             column = self.connection.introspection.identifier_converter(
                 first_field.column
@@ -206,7 +206,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
                 constraint_names = [
                     name
                     for name, infodict in self.connection.introspection.get_constraints(
-                        cursor, model._meta.db_table
+                        cursor, model.model_options.db_table
                     ).items()
                     if infodict["index"] and infodict["columns"][0] == column
                 ]

plain/models/backends/postgresql/operations.py

@@ -270,7 +270,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         if not fields:
             return "", ()
         columns = [
-            f"{self.quote_name(field.model._meta.db_table)}.{self.quote_name(field.column)}"
+            f"{self.quote_name(field.model.model_options.db_table)}.{self.quote_name(field.column)}"
             for field in fields
         ]
         return "RETURNING {}".format(", ".join(columns)), ()

plain/models/backends/postgresql/schema.py

@@ -173,7 +173,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             or (old_type.startswith("citext") and not new_type.startswith("citext"))
         ):
             index_name = self._create_index_name(
-                model._meta.db_table, [old_field.column], suffix="_like"
+                model.model_options.db_table, [old_field.column], suffix="_like"
             )
             self.execute(self._delete_index_sql(model, index_name))
 
@@ -186,7 +186,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
         new_internal_type = new_field.get_internal_type()
         old_internal_type = old_field.get_internal_type()
         # Make ALTER TYPE with IDENTITY make sense.
-        table = strip_quotes(model._meta.db_table)
+        table = strip_quotes(model.model_options.db_table)
         auto_field_types = {"PrimaryKeyField"}
         old_is_auto = old_internal_type in auto_field_types
         new_is_auto = new_internal_type in auto_field_types
@@ -306,7 +306,7 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
             or new_field.primary_key
         ):
             index_to_remove = self._create_index_name(
-                model._meta.db_table, [old_field.column], suffix="_like"
+                model.model_options.db_table, [old_field.column], suffix="_like"
             )
             self.execute(self._delete_index_sql(model, index_to_remove))
 

plain/models/backends/sqlite3/operations.py

@@ -439,7 +439,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         if not fields:
             return "", ()
         columns = [
-            f"{self.quote_name(field.model._meta.db_table)}.{self.quote_name(field.column)}"
+            f"{self.quote_name(field.model.model_options.db_table)}.{self.quote_name(field.column)}"
             for field in fields
         ]
         return "RETURNING {}".format(", ".join(columns)), ()