# Documentation Django 6.0.7

# Contraintes de bases de données spécifiques à PostgreSQL

PostgreSQL offre des contraintes d’intégrité de données supplémentaires dans le module `django.contrib.postgres.constraints`. Elles sont ajoutées dans l’option `Meta.constraints` des modèles.

## `ExclusionConstraint`

class ExclusionConstraint(*, name, expressions, index_type=None, condition=None, deferrable=None, include=None, violation_error_code=None, violation_error_message=None)

  Crée une contrainte d’exclusion dans la base de données. En interne, PostgreSQL implémente les contraintes d’exclusion par des index. Le type d’index par défaut est GiST. Pour les utiliser, vous devez activer l’extension btree_gist dans PostgreSQL. Vous pouvez installer l’extension par une opération de migration `BtreeGistExtension`.

  Si vous essayez d’insérer une nouvelle ligne qui entre en conflit avec une ligne existante, une erreur `IntegrityError` se produit. De même lorsqu’un conflit survient lors d’une mise à jour.

  Les contraintes d’exclusion sont vérifiées durant la validation des modèles.

### `name`

ExclusionConstraint.name

Voir `BaseConstraint.name`.

### `expressions`

ExclusionConstraint.expressions

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),
    ]

Restrictions sur les opérateurs.

Seuls des opérateurs commutatifs peuvent être utilisés dans des contraintes d’exclusion.

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_type`

ExclusionConstraint.index_type

The index type of the constraint. Accepted values are `GiST`, `Hash`, or `SPGiST`. Matching is case insensitive. If not provided, the default index type is `GIST`.

Changed in Django 6.1:

Support for exclusion constraints using Hash indexes was added.

### `condition`

ExclusionConstraint.condition

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`.

### `deferrable`

ExclusionConstraint.deferrable

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.

Avertissement

Les contraintes d’exclusion différées peuvent amener à des performances réduites.

### `include`

ExclusionConstraint.include

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` is supported for GiST and SP-GiST indexes.

### `violation_error_code`

ExclusionConstraint.violation_error_code

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_message`

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`.

### Exemples

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),
                ),
            ]