Contraintes de bases de données spécifiques à PostgreSQLLien vers cette rubrique#

nameLien vers cette rubrique#

ExclusionConstraint.nameLien vers cette définition#

Voir BaseConstraint.name.

expressionsLien vers cette rubrique#

ExclusionConstraint.expressionsLien vers cette définition#

Un itérable de tuples binaires. Le premier élément est une expression ou une chaîne. Le second élément est un opérateur SQL sous forme de chaîne. Pour éviter les erreurs syntaxiques, vous pouvez utiliser RangeOperators qui fait correspondre les opérateurs à des chaînes. Par exemple

expressions = [
    ("timespan", RangeOperators.ADJACENT_TO),
    (F("room"), RangeOperators.EQUAL),
]

L’expression OpClass() peut être utilisée pour indiquer une classe d’opérateur personnalisée pour les expressions de contrainte. Par exemple

expressions = [
    (OpClass("circle", name="circle_ops"), RangeOperators.OVERLAPS),
]

crée une contrainte d’exclusion sur circle en utilisant circle_ops.

index_typeLien vers cette rubrique#

ExclusionConstraint.index_typeLien vers cette définition#

Le type d’index de la contrainte. La valeurs admises sont GIST ou SPGIST. Les correspondances ne tiennent pas compte de la casse. En cas d’absence, le type d’index par défaut est GIST.

conditionLien vers cette rubrique#

ExclusionConstraint.conditionLien vers cette définition#

Un objet Q qui indique la condition de restriction d’une contrainte à un sous-ensemble de lignes. Par exemple, condition=Q(annule=False).

Ces conditions sont soumises aux mêmes restrictions de base de données que django.db.models.Index.condition.

deferrableLien vers cette rubrique#

ExclusionConstraint.deferrableLien vers cette définition#

Définissez ce paramètre pour créer une contrainte d’exclusion différable. Les valeurs acceptées sont Deferrable.DEFERRED ou Deferrable.IMMEDIATE. Par exemple

from django.contrib.postgres.constraints import ExclusionConstraint
from django.contrib.postgres.fields import RangeOperators
from django.db.models import Deferrable

ExclusionConstraint(
    name="exclude_overlapping_deferred",
    expressions=[
        ("timespan", RangeOperators.OVERLAPS),
    ],
    deferrable=Deferrable.DEFERRED,
)

Par défaut, les contraintes ne sont pas différées. Une contrainte différée ne sera pas appliquée avant la fin de la transaction. Une contrainte immédiate sera appliquée immédiatement après chaque commande.

includeLien vers cette rubrique#

ExclusionConstraint.includeLien vers cette définition#

Une liste ou un tuple de noms de champs à inclure dans la contrainte d’exclusion de couverture, représentant des colonnes qui ne sont pas des clés. Cela permet des analyses en index pur avec des requêtes qui ne sélectionnent que les champs inclus (include) et qui ne filtrent que sur les champs indexés (expressions).

include est pris en charge par les index GiST. PostgreSQL 14+ prend aussi en charge include pour les index SP-GiST.

violation_error_codeLien vers cette rubrique#

ExclusionConstraint.violation_error_codeLien vers cette définition#

Le code d’erreur utilisé lorsque ValidationError est générée pendant la phase de validation des modèles. Contient None par défaut.

violation_error_messageLien vers cette rubrique#

Le message d’erreur utilisé lorsque ValidationError est générée pendant la phase de validation des modèles. Contient par défaut BaseConstraint.violation_error_message.

ExemplesLien vers cette rubrique#

L’exemple suivant évite les chevauchements de réservations d’une même salle, sans tenir compte des réservations annulées

from django.contrib.postgres.constraints import ExclusionConstraint
from django.contrib.postgres.fields import DateTimeRangeField, RangeOperators
from django.db import models
from django.db.models import Q


class Room(models.Model):
    number = models.IntegerField()


class Reservation(models.Model):
    room = models.ForeignKey("Room", on_delete=models.CASCADE)
    timespan = DateTimeRangeField()
    cancelled = models.BooleanField(default=False)

    class Meta:
        constraints = [
            ExclusionConstraint(
                name="exclude_overlapping_reservations",
                expressions=[
                    ("timespan", RangeOperators.OVERLAPS),
                    ("room", RangeOperators.EQUAL),
                ],
                condition=Q(cancelled=False),
            ),
        ]

Dans le cas où un modèle définit un intervalle avec deux champs, au lieu des types d’intervalle natifs de PostgreSQL, vous devriez écrire une expression qui utilise la fonction équivalente (par ex. TsTzRange()), et utiliser les délimiteurs du champ. La plupart du temps, les délimiteurs seront '[)', ce qui signifie que la limite inférieure est inclusive et la limite supérieure exclusive. Vous pouvez utiliser RangeBoundary qui fournit des correspondances d’expression pour les limites d’intervalle. Par exemple

from django.contrib.postgres.constraints import ExclusionConstraint
from django.contrib.postgres.fields import (
    DateTimeRangeField,
    RangeBoundary,
    RangeOperators,
)
from django.db import models
from django.db.models import Func, Q


class TsTzRange(Func):
    function = "TSTZRANGE"
    output_field = DateTimeRangeField()


class Reservation(models.Model):
    room = models.ForeignKey("Room", on_delete=models.CASCADE)
    start = models.DateTimeField()
    end = models.DateTimeField()
    cancelled = models.BooleanField(default=False)

    class Meta:
        constraints = [
            ExclusionConstraint(
                name="exclude_overlapping_reservations",
                expressions=[
                    (
                        TsTzRange("start", "end", RangeBoundary()),
                        RangeOperators.OVERLAPS,
                    ),
                    ("room", RangeOperators.EQUAL),
                ],
                condition=Q(cancelled=False),
            ),
        ]