Model Classes

Django adds an auto-incrementing id field. Its class comes from the app's AppConfig.default_auto_field if set, otherwise from the DEFAULT_AUTO_FIELD setting, which defaults to BigAutoField since Django 6.0 (AutoField before).

class Meta holds model-level options rather than fields: the table name (db_table), default ordering, human-readable names, indexes, constraints and a few behaviour switches. Django reads it when building the model's _meta; it never becomes a column.

on_delete tells Django what to do with rows that reference an object when that object is deleted: delete them too (CASCADE), refuse the delete (PROTECT, RESTRICT), or rewrite their key (SET_NULL, SET_DEFAULT, SET()). It is required on every ForeignKey and OneToOneField.

TextChoices and IntegerChoices are enums whose members carry a stored value and a human label; pass the class as choices=. Choices are enforced by model validation and forms only, so save(), update() or raw SQL can still store any value.

Give Like a ForeignKey to ContentType, an object_id column holding the target's primary key, and a GenericForeignKey combining the two; add GenericRelation(Like) on Photo, Comment and Post for reverse access, and add the index yourself.

from_db_value() converts column values into Python objects whenever rows are loaded; to_python() converts form or fixture input during cleaning and deserialization; get_prep_value() turns a Python object into a query value; get_db_prep_value() adds any backend-specific conversion.

Choose by what the database must hold: an abstract base gives each vehicle type its own complete table, multi-table inheritance keeps a queryable Vehicle table joined one-to-one to each child, and a proxy changes behaviour on one existing table without new columns.

full_clean() validates an instance: clean_fields(), then clean(), validate_unique() and validate_constraints(), raising one ValidationError. clean() is your hook for cross-field rules. save() never calls them, so code saving directly must validate itself.

QuerySet.update(), bulk_create(), bulk_update(), raw SQL, loaddata fixtures and data migrations using historical models all skip an overridden save(). QuerySet.delete() and cascades likewise skip an overridden delete().

Add UniqueConstraint(fields=["user"], condition=Q(status="active"), name=...) to Meta.constraints. The database then allows many cancelled rows per user but only one active one. unique_together cannot take a condition and is the legacy option.

related_name names the reverse accessor on the target model (default book_set); related_query_name names the reverse lookup in filters (defaulting to related_name, else the model name). You must set them when two relations would produce clashing reverse names, including on abstract models.

ContentType is the contenttypes app's registry: one row per installed model, identified by app_label and model name. get_for_model() returns that row for a model class or instance, creating it if missing and caching it in-process.

A custom field usually means two classes: a value class such as Money that code works with, and a Field subclass that converts that value to and from its column. The model attribute holds the Money object; the field lives in Model._meta.

It makes the model an abstract base class: Django creates no table and no manager for it, and every concrete subclass inherits its fields, managers and (unless overridden) its Meta in a complete table of its own.

str gives each instance a human-readable label, used by the admin, the shell and templates; the default is "WikiPage object (42)". get_absolute_url returns the object's canonical URL, used by redirect(), generic edit views, the admin's View on site link, sitemaps and feeds.

The database enforces what reaches the schema: null=False (NOT NULL), unique=True (a unique constraint), CharField max_length (VARCHAR length) and db_default. blank, choices, validators and unique_for_date are checked only by full_clean() and forms.

DecimalField maps to a fixed-precision numeric column and Python's decimal.Decimal, so 12.50 stays exact; FloatField uses binary floating point, which cannot represent most prices exactly. max_digits caps total digits and decimal_places the digits after the point.

A GenericForeignKey has no column and no reverse relation, so the ORM cannot build a lookup on it. Filter on content_type and object_id directly, or declare a GenericRelation, optionally with related_query_name, to filter and aggregate across the link.

Subclass a built-in field when its column and validation already fit; return a built-in name from get_internal_type() to borrow its per-backend column type; override db_type(connection) only for a type Django lacks, branching on connection.vendor.

Django's migrations record every field as the arguments needed to rebuild it, and deconstruct() supplies them as (name, path, args, kwargs). Override it whenever your init adds or forces arguments, so migrations can recreate the exact field.

GeneratedField declares a GENERATED ALWAYS column: expression is the database-side formula, output_field sets the column's type, and db_persist chooses a stored column (True) or a virtual one computed on read (False). Django never writes it.

Django adds a <parent>_ptr OneToOneField with parent_link=True and primary_key=True to the child, so the child row's primary key is also a foreign key to its parent row, and loading child objects joins the parent table.

A proxy model reuses its parent's table and columns but may change Python-side behaviour: methods, str, default ordering, the default manager, and a separate admin and permissions. It may not add fields and must have exactly one concrete base.

save(update_fields=[...]) writes only the named columns in an UPDATE, so other columns changed elsewhere are not overwritten. It forces an update, skips auto_now fields and derived fields not listed, and raises NotUpdated if no row matches.

Add models.CheckConstraint(condition=Q(...), name=...) to Meta.constraints. The database rejects any write that breaks it with IntegrityError, whatever the code path; full_clean() also checks it and raises ValidationError. The old check= keyword was removed in Django 6.0.

Meta.ordering adds an ORDER BY to every query on the model that does not call order_by(), including related managers and first()/last(). Aggregation queries with GROUP BY skip it. The cost is a sort on every such query.

Use a through model when the link itself carries data, such as an author's position and royalty share on a book. add(), create() and set() still work, but required link fields must come via through_defaults, and pair uniqueness is yours to declare.

OneToOneField is a unique foreign key whose reverse side returns a single object instead of a manager. Use it when each row has at most one partner. When no partner exists, the reverse accessor raises RelatedObjectDoesNotExist.

default is computed by Python when an instance is created and leaves no DEFAULT on the column; db_default (Django 5.0+) puts a DEFAULT clause in the schema, so the database fills any INSERT that omits the column.