Constraints referenceLink to this heading#

nameLink to this heading#

BaseConstraint.nameLink to this definition#

The name of the constraint. You must always specify a unique name for the constraint.

violation_error_codeLink to this heading#

BaseConstraint.violation_error_codeLink to this definition#

The error code used when ValidationError is raised during model validation. Defaults to None.

violation_error_messageLink to this heading#

BaseConstraint.violation_error_messageLink to this definition#

The error message used when ValidationError is raised during model validation. Defaults to "Constraint “%(name)s” is violated.".

validate()Link to this heading#

BaseConstraint.validate(model, instance, exclude=None, using=DEFAULT_DB_ALIAS)Link to this definition#

Validates that the constraint, defined on model, is respected on the instance. This will do a query on the database to ensure that the constraint is respected. If fields in the exclude list are needed to validate the constraint, the constraint is ignored.

Raise a ValidationError if the constraint is violated.

This method must be implemented by a subclass.

checkLink to this heading#

CheckConstraint.checkLink to this definition#

A Q object or boolean Expression that specifies the check you want the constraint to enforce.

For example, CheckConstraint(check=Q(age__gte=18), name='age_gte_18') ensures the age field is never less than 18.

expressionsLink to this heading#

UniqueConstraint.expressionsLink to this definition#

Positional argument *expressions allows creating functional unique constraints on expressions and database functions.

For example:

UniqueConstraint(Lower("name").desc(), "category", name="unique_lower_name_category")

creates a unique constraint on the lowercased value of the name field in descending order and the category field in the default ascending order.

Functional unique constraints have the same database restrictions as Index.expressions.

fieldsLink to this heading#

UniqueConstraint.fieldsLink to this definition#

A list of field names that specifies the unique set of columns you want the constraint to enforce.

For example, UniqueConstraint(fields=['room', 'date'], name='unique_booking') ensures each room can only be booked once for each date.

conditionLink to this heading#

UniqueConstraint.conditionLink to this definition#

A Q object that specifies the condition you want the constraint to enforce.

For example:

UniqueConstraint(fields=["user"], condition=Q(status="DRAFT"), name="unique_draft_user")

ensures that each user only has one draft.

These conditions have the same database restrictions as Index.condition.

deferrableLink to this heading#

UniqueConstraint.deferrableLink to this definition#

Set this parameter to create a deferrable unique constraint. Accepted values are Deferrable.DEFERRED or Deferrable.IMMEDIATE. For example:

from django.db.models import Deferrable, UniqueConstraint

UniqueConstraint(
    name="unique_order",
    fields=["order"],
    deferrable=Deferrable.DEFERRED,
)

By default constraints are not deferred. A deferred constraint will not be enforced until the end of the transaction. An immediate constraint will be enforced immediately after every command.

includeLink to this heading#

UniqueConstraint.includeLink to this definition#

A list or tuple of the names of the fields to be included in the covering unique index as non-key columns. This allows index-only scans to be used for queries that select only included fields (include) and filter only by unique fields (fields).

For example:

UniqueConstraint(name="unique_booking", fields=["room", "date"], include=["full_name"])

will allow filtering on room and date, also selecting full_name, while fetching data only from the index.

Unique constraints with non-key columns are ignored for databases besides PostgreSQL.

Non-key columns have the same database restrictions as Index.include.

opclassesLink to this heading#

UniqueConstraint.opclassesLink to this definition#

The names of the PostgreSQL operator classes to use for this unique index. If you require a custom operator class, you must provide one for each field in the index.

For example:

UniqueConstraint(
    name="unique_username", fields=["username"], opclasses=["varchar_pattern_ops"]
)

creates a unique index on username using varchar_pattern_ops.

opclasses are ignored for databases besides PostgreSQL.

nulls_distinctLink to this heading#

UniqueConstraint.nulls_distinctLink to this definition#

Whether rows containing NULL values covered by the unique constraint should be considered distinct from each other. The default value is None which uses the database default which is True on most backends.

For example:

UniqueConstraint(name="ordering", fields=["ordering"], nulls_distinct=False)

creates a unique constraint that only allows one row to store a NULL value in the ordering column.

Unique constraints with nulls_distinct are ignored for databases besides PostgreSQL 15+.

violation_error_codeLink to this heading#

UniqueConstraint.violation_error_codeLink to this definition#

The error code used when ValidationError is raised during model validation. Defaults to None.

This code is not used for UniqueConstraints with fields and without a condition. Such UniqueConstraints have the same error code as constraints defined with Field.unique or in Meta.unique_together.

violation_error_messageLink to this heading#

UniqueConstraint.violation_error_messageLink to this definition#

The error message used when ValidationError is raised during model validation. Defaults to BaseConstraint.violation_error_message.

This message is not used for UniqueConstraints with fields and without a condition. Such UniqueConstraints show the same message as constraints defined with Field.unique or in Meta.unique_together.